diff --git a/extras/amalgamator/juce_AmalgamatorMain.cpp b/extras/amalgamator/juce_AmalgamatorMain.cpp
new file mode 100644
index 0000000000..792218c831
--- /dev/null
+++ b/extras/amalgamator/juce_AmalgamatorMain.cpp
@@ -0,0 +1,340 @@
+/*
+ ==============================================================================
+
+ This file is part of the JUCE library - "Jules' Utility Class Extensions"
+ Copyright 2004-7 by Raw Material Software ltd.
+
+ ------------------------------------------------------------------------------
+
+ JUCE can be redistributed and/or modified under the terms of the
+ GNU General Public License, as published by the Free Software Foundation;
+ either version 2 of the License, or (at your option) any later version.
+
+ JUCE is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with JUCE; if not, visit www.gnu.org/licenses or write to the
+ Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ Boston, MA 02111-1307 USA
+
+ ------------------------------------------------------------------------------
+
+ If you'd like to release a closed-source product which uses JUCE, commercial
+ licenses are also available: visit www.rawmaterialsoftware.com/juce for
+ more information.
+
+ ==============================================================================
+*/
+
+#include "juce_AppConfig.h"
+#include "../../juce_amalgamated.h"
+
+
+//==============================================================================
+static bool matchesWildcard (const String& filename, const StringArray& wildcards)
+{
+ for (int i = wildcards.size(); --i >= 0;)
+ if (filename.matchesWildcard (wildcards[i], true))
+ return true;
+
+ return false;
+}
+
+static bool canFileBeReincluded (const File& f)
+{
+ String content (f.loadFileAsString());
+
+ for (;;)
+ {
+ content = content.trimStart();
+
+ if (content.startsWith (T("//")))
+ content = content.fromFirstOccurrenceOf (T("\n"), false, false);
+ else if (content.startsWith (T("/*")))
+ content = content.fromFirstOccurrenceOf (T("*/"), false, false);
+ else
+ break;
+ }
+
+ StringArray lines;
+ lines.addLines (content);
+ lines.trim();
+ lines.removeEmptyStrings();
+
+ const String l1 (lines[0].removeCharacters (T(" \t")).trim());
+ const String l2 (lines[1].removeCharacters (T(" \t")).trim());
+
+ if (l1.replace (T("#ifndef"), T("#define")) == l2)
+ return false;
+
+ return true;
+}
+
+//==============================================================================
+static bool parseFile (const File& rootFolder,
+ const File& newTargetFile,
+ StringArray& dest,
+ const File& file,
+ StringArray& alreadyIncludedFiles,
+ const StringArray& includesToIgnore,
+ const StringArray& wildcards,
+ const bool isOuterFile,
+ const bool stripUnnecessaryStuff)
+{
+ printf ("reading: " + file.getFileName() + "\n");
+
+ if (! file.exists())
+ {
+ printf ("!! ERROR - file doesn't exist!");
+ return false;
+ }
+
+ String content (file.loadFileAsString());
+
+ if (stripUnnecessaryStuff && ! isOuterFile)
+ {
+ if (content.startsWith (T("/*")))
+ content = content.fromFirstOccurrenceOf (T("*/"), false, false).trimStart();
+
+ content = content.replace (T("\r\n\r\n\r\n"), T("\r\n\r\n"));
+ }
+
+ StringArray lines;
+ lines.addLines (content);
+ while (lines[0].trim().isEmpty())
+ lines.remove (0);
+
+ for (int i = 0; i < lines.size(); ++i)
+ {
+ String line (lines[i]);
+
+ if ((! isOuterFile) && line.contains (T("//================================================================")))
+ line = String::empty;
+
+ if (line.trimStart().startsWithChar (T('#'))
+ && line.removeCharacters (T(" \t")).startsWithIgnoreCase (T("#include\"")))
+ {
+ const int endOfInclude = line.indexOfChar (line.indexOfChar (T('\"')) + 1, T('\"')) + 1;
+ const String lineUpToEndOfInclude (line.substring (0, endOfInclude));
+ const String lineAfterInclude (line.substring (endOfInclude));
+
+ const String filename (line.fromFirstOccurrenceOf (T("\""), false, false)
+ .upToLastOccurrenceOf (T("\""), false, false));
+ const File targetFile (file.getSiblingFile (filename));
+
+ if (targetFile.exists()
+ && targetFile.isAChildOf (rootFolder))
+ {
+ if (matchesWildcard (filename.replaceCharacter (T('\\'), T('/')), wildcards)
+ && ! includesToIgnore.contains (targetFile.getFileName()))
+ {
+ if (! alreadyIncludedFiles.contains (targetFile.getFullPathName()))
+ {
+ if (! canFileBeReincluded (targetFile))
+ alreadyIncludedFiles.add (targetFile.getFullPathName());
+
+ dest.add (String::empty);
+ dest.add (T("/********* Start of inlined file: ")
+ + targetFile.getFileName()
+ + T(" *********/"));
+
+ if (! parseFile (rootFolder, newTargetFile,
+ dest, targetFile, alreadyIncludedFiles, includesToIgnore,
+ wildcards, false, stripUnnecessaryStuff))
+ {
+ return false;
+ }
+
+ dest.add (T("/********* End of inlined file: ")
+ + targetFile.getFileName()
+ + T(" *********/"));
+ dest.add (String::empty);
+
+ line = lineAfterInclude;
+ }
+ else
+ {
+ if (stripUnnecessaryStuff)
+ line = String::empty;
+ else
+ line = T("/* ") + lineUpToEndOfInclude + T(" */") + lineAfterInclude;
+ }
+ }
+ else
+ {
+ line = lineUpToEndOfInclude.upToFirstOccurrenceOf (T("\""), true, false)
+ + targetFile.getRelativePathFrom (newTargetFile.getParentDirectory())
+ .replaceCharacter (T('\\'), T('/'))
+ + T("\"")
+ + lineAfterInclude;
+ }
+ }
+ }
+
+ dest.add (line.trimEnd());
+ }
+
+ return true;
+}
+
+//==============================================================================
+static bool munge (const File& templateFile, const File& targetFile, const String& wildcard,
+ const bool stripUnnecessaryStuff, StringArray& alreadyIncludedFiles,
+ const StringArray& includesToIgnore)
+{
+ if (! templateFile.existsAsFile())
+ {
+ printf (" The template file doesn't exist!\n\n");
+ return false;
+ }
+
+ StringArray lines, wildcards;
+ wildcards.addTokens (wildcard, T(";,"), T("'\""));
+ wildcards.trim();
+ wildcards.removeEmptyStrings();
+
+ if (! parseFile (targetFile.getParentDirectory(),
+ targetFile,
+ lines, templateFile,
+ alreadyIncludedFiles,
+ includesToIgnore,
+ wildcards,
+ true, stripUnnecessaryStuff))
+ {
+ return false;
+ }
+
+ //lines.trim();
+ //lines.removeEmptyStrings();
+ printf ("\nwriting: " + targetFile.getFullPathName() + "...\n\n");
+
+ for (int i = 0; i < lines.size() - 2; ++i)
+ {
+ if (lines[i].isEmpty() && lines[i + 1].isEmpty())
+ {
+ lines.remove (i + 1);
+ --i;
+ }
+ }
+
+ MemoryBlock newData, oldData;
+ const String newText (lines.joinIntoString (T("\n")) + T("\n"));
+ newData.append ((const char*) newText, (int) strlen ((const char*) newText));
+ targetFile.loadFileAsData (oldData);
+
+ if (oldData == newData)
+ {
+ printf ("(No need to write - new file is identical)\n\n");
+ return true;
+ }
+
+ if (! targetFile.replaceWithData (newData.getData(), newData.getSize()))
+ {
+ printf ("\n!! ERROR - couldn't write to the target file: " + targetFile.getFullPathName() + "\n\n");
+ return false;
+ }
+
+ return true;
+}
+
+static void findAllFilesIncludedIn (const File& hppTemplate, StringArray& alreadyIncludedFiles)
+{
+ StringArray lines;
+ lines.addLines (hppTemplate.loadFileAsString());
+
+ for (int i = 0; i < lines.size(); ++i)
+ {
+ String line (lines[i]);
+
+ if (line.removeCharacters (T(" \t")).startsWithIgnoreCase (T("#include\"")))
+ {
+ const String filename (line.fromFirstOccurrenceOf (T("\""), false, false)
+ .upToLastOccurrenceOf (T("\""), false, false));
+ const File targetFile (hppTemplate.getSiblingFile (filename));
+
+ if (! alreadyIncludedFiles.contains (targetFile.getFullPathName()))
+ {
+ alreadyIncludedFiles.add (targetFile.getFullPathName());
+
+ if (targetFile.getFileName().containsIgnoreCase (T("juce_")) && targetFile.exists())
+ findAllFilesIncludedIn (targetFile, alreadyIncludedFiles);
+ }
+ }
+ }
+}
+
+//==============================================================================
+static void mungeJuce (const File& juceFolder)
+{
+ if (! juceFolder.isDirectory())
+ {
+ printf (" The folder supplied must be the root of your Juce directory!\n\n");
+ return;
+ }
+
+ const File hppTemplate (juceFolder.getChildFile (T("src/juce_amalgamated_template.h")));
+ const File cppTemplate (juceFolder.getChildFile (T("src/juce_amalgamated_template.cpp")));
+
+ const File hppTarget (juceFolder.getChildFile (T("juce_amalgamated.h")));
+ const File cppTarget (juceFolder.getChildFile (T("juce_amalgamated.cpp")));
+
+ StringArray alreadyIncludedFiles, includesToIgnore;
+
+ if (! munge (hppTemplate, hppTarget,
+ "*.h", true, alreadyIncludedFiles, includesToIgnore))
+ {
+ return;
+ }
+
+ findAllFilesIncludedIn (hppTemplate, alreadyIncludedFiles);
+ includesToIgnore.add (hppTarget.getFileName());
+
+ munge (cppTemplate, cppTarget,
+ "*.cpp;*.c;*.h;*.mm;*.m", true, alreadyIncludedFiles,
+ includesToIgnore);
+}
+
+//==============================================================================
+int main (int argc, char* argv[])
+{
+ // If you're running a command-line app, you need to initialise juce manually
+ // before calling any Juce functionality..
+ initialiseJuce_NonGUI();
+
+ printf ("\n The C++ Amalgamator! Copyright 2008 by Julian Storer - www.rawmaterialsoftware.com\n\n");
+
+ if (argc == 4)
+ {
+ const File templateFile (File::getCurrentWorkingDirectory().getChildFile (argv[1]));
+ const File targetFile (File::getCurrentWorkingDirectory().getChildFile (argv[2]));
+ const String wildcard (String (argv[3]).unquoted());
+ StringArray alreadyIncludedFiles, includesToIgnore;
+
+ munge (templateFile, targetFile, wildcard, false, alreadyIncludedFiles, includesToIgnore);
+ }
+ else if (argc == 2)
+ {
+ const File juceFolder (File::getCurrentWorkingDirectory().getChildFile (argv[1]));
+ mungeJuce (juceFolder);
+ }
+ else
+ {
+ printf (" Usage: amalgamator TemplateFile TargetFile \"FileToReplaceWildcard\"\n\n");
+ printf (" amalgamator will run through a C++ file and replace any\n"
+ " #include statements with the contents of the file they refer to.\n"
+ " It'll only do this for files that are within the same parent\n"
+ " directory as the target file, and will ignore include statements\n"
+ " that use '<>' instead of quotes. It'll also only include a file once,\n"
+ " ignoring any repeated instances of it.\n\n"
+ " The wildcard lets you specify what kind of files will be replaced, so\n"
+ " \"*.cpp;*.h\" would replace only includes that reference a .cpp or .h file.\n\n"
+ " Or: just run 'amalgamator YourJuceDirectory' to rebuild the juce files."
+ );
+ }
+
+ return 0;
+}
+
diff --git a/extras/amalgamator/juce_AppConfig.h b/extras/amalgamator/juce_AppConfig.h
new file mode 100644
index 0000000000..fa05cdb520
--- /dev/null
+++ b/extras/amalgamator/juce_AppConfig.h
@@ -0,0 +1,28 @@
+
+/*
+ This file contains settings that you might want to explicitly apply to
+ the your build.
+
+ Most of these are turned on or off by default, but you can override
+ that setting here by un-commenting it and giving it a 1 or 0 value.
+*/
+
+#define JUCE_ONLY_BUILD_CORE_LIBRARY 1
+//#define JUCE_FORCE_DEBUG 1
+//#define JUCE_LOG_ASSERTIONS 1
+//#define JUCE_ASIO 1
+//#define JUCE_ALSA 1
+//#define JUCE_QUICKTIME 1
+//#define JUCE_OPENGL 1
+//#define JUCE_USE_FLAC 1
+//#define JUCE_USE_OGGVORBIS 1
+//#define JUCE_USE_CDBURNER 1
+//#define JUCE_ENABLE_REPAINT_DEBUGGING 1
+//#define JUCE_USE_XINERAMA 1
+//#define JUCE_USE_XSHM 1
+//#define JUCE_PLUGINHOST_VST 1
+//#define JUCE_PLUGINHOST_AU 1
+//#define JUCE_BUILD_GUI_CLASSES 1
+//#define JUCE_CHECK_MEMORY_LEAKS 1
+//#define JUCE_CATCH_UNHANDLED_EXCEPTIONS 1
+//#define JUCE_STRINGS_ARE_UNICODE 1
diff --git a/extras/amalgamator/juce_LibrarySource.cpp b/extras/amalgamator/juce_LibrarySource.cpp
new file mode 100644
index 0000000000..5567cbfd82
--- /dev/null
+++ b/extras/amalgamator/juce_LibrarySource.cpp
@@ -0,0 +1,12 @@
+
+/*
+ This file includes the entire juce source tree via the amalgamated file.
+
+ You could add the amalgamated file directly to your project, but doing it
+ like this allows you to put your app's config settings in the
+ juce_AppConfig.h file and have them applied to both the juce headers and
+ the source code.
+*/
+
+#include "juce_AppConfig.h"
+#include "../../juce_amalgamated.cpp"
diff --git a/extras/amalgamator/vc8/Amalgamator.sln b/extras/amalgamator/vc8/Amalgamator.sln
new file mode 100644
index 0000000000..7d092650e9
--- /dev/null
+++ b/extras/amalgamator/vc8/Amalgamator.sln
@@ -0,0 +1,20 @@
+
+Microsoft Visual Studio Solution File, Format Version 9.00
+# Visual Studio 2005
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Amalgamator", "Amalgamator.vcproj", "{E616D10E-A3BF-4227-9512-186086D297A6}"
+EndProject
+Global
+ GlobalSection(SolutionConfigurationPlatforms) = preSolution
+ Debug|Win32 = Debug|Win32
+ Release|Win32 = Release|Win32
+ EndGlobalSection
+ GlobalSection(ProjectConfigurationPlatforms) = postSolution
+ {E616D10E-A3BF-4227-9512-186086D297A6}.Debug|Win32.ActiveCfg = Debug|Win32
+ {E616D10E-A3BF-4227-9512-186086D297A6}.Debug|Win32.Build.0 = Debug|Win32
+ {E616D10E-A3BF-4227-9512-186086D297A6}.Release|Win32.ActiveCfg = Release|Win32
+ {E616D10E-A3BF-4227-9512-186086D297A6}.Release|Win32.Build.0 = Release|Win32
+ EndGlobalSection
+ GlobalSection(SolutionProperties) = preSolution
+ HideSolutionNode = FALSE
+ EndGlobalSection
+EndGlobal
diff --git a/extras/amalgamator/vc8/Amalgamator.vcproj b/extras/amalgamator/vc8/Amalgamator.vcproj
new file mode 100644
index 0000000000..c3bc7ebc8b
--- /dev/null
+++ b/extras/amalgamator/vc8/Amalgamator.vcproj
@@ -0,0 +1,193 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/juce_amalgamated.cpp b/juce_amalgamated.cpp
new file mode 100644
index 0000000000..1453c1c0f9
--- /dev/null
+++ b/juce_amalgamated.cpp
@@ -0,0 +1,259886 @@
+/*
+ ==============================================================================
+
+ This file is part of the JUCE library - "Jules' Utility Class Extensions"
+ Copyright 2004-7 by Raw Material Software ltd.
+
+ ------------------------------------------------------------------------------
+
+ JUCE can be redistributed and/or modified under the terms of the
+ GNU General Public License, as published by the Free Software Foundation;
+ either version 2 of the License, or (at your option) any later version.
+
+ JUCE is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with JUCE; if not, visit www.gnu.org/licenses or write to the
+ Free Software Foundation, Inc., 59 Temple Place, Suite 330,
+ Boston, MA 02111-1307 USA
+
+ ------------------------------------------------------------------------------
+
+ If you'd like to release a closed-source product which uses JUCE, commercial
+ licenses are also available: visit www.rawmaterialsoftware.com/juce for
+ more information.
+
+ ==============================================================================
+*/
+
+/*
+ This monolithic file contains the entire Juce source tree!
+
+ To build an app which uses Juce, all you need to do is to add this
+ file to your project, and include juce.h in your own cpp files.
+
+*/
+
+//==============================================================================
+#ifdef _WIN32
+
+/********* Start of inlined file: win32_headers.h *********/
+#ifndef __WIN32_HEADERS_JUCEHEADER__
+#define __WIN32_HEADERS_JUCEHEADER__
+
+#ifndef STRICT
+ #define STRICT 1
+#endif
+#define WIN32_LEAN_AND_MEAN
+
+// don't want to get told about microsoft's mistakes..
+#ifdef _MSC_VER
+ #pragma warning (push)
+ #pragma warning (disable : 4100 4201)
+#endif
+
+// use Platform SDK as win2000 unless this is disabled
+#ifndef DISABLE_TRANSPARENT_WINDOWS
+ #define _WIN32_WINNT 0x0500
+#endif
+
+#define _UNICODE 1
+#define UNICODE 1
+
+#include
+#include
+#include
+#include
+#include
+#include
+
+#undef PACKED
+
+#ifdef _MSC_VER
+ #pragma warning (pop)
+#endif
+
+#endif // __WIN32_HEADERS_JUCEHEADER__
+/********* End of inlined file: win32_headers.h *********/
+
+ #include
+ #include
+ #include
+
+ #if JUCE_QUICKTIME
+ #include
+ #include
+ #include
+ #include
+ #include
+ #undef TARGET_OS_MAC // quicktime sets these, but they confuse some of the 3rd party libs
+ #undef MACOS
+ #endif
+
+#elif defined (LINUX)
+
+#else
+ #include
+ #include
+ #define __Point__
+ #include
+ #include
+ #include
+ #include
+ #include
+ #include
+ #include
+ #include
+
+ #include
+ #include
+ #include
+ #include
+#endif
+
+//==============================================================================
+#define DONT_SET_USING_JUCE_NAMESPACE 1
+
+#include "juce_amalgamated.h"
+
+#define NO_DUMMY_DECL
+
+#if (defined(_MSC_VER) && (_MSC_VER <= 1200))
+ #pragma warning (disable: 4309 4305)
+#endif
+
+//==============================================================================
+
+/********* Start of inlined file: juce_FileLogger.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+FileLogger::FileLogger (const File& logFile_,
+ const String& welcomeMessage,
+ const int maxInitialFileSizeBytes)
+ : logFile (logFile_)
+{
+ if (maxInitialFileSizeBytes >= 0)
+ trimFileSize (maxInitialFileSizeBytes);
+
+ if (! logFile_.exists())
+ {
+ // do this so that the parent directories get created..
+ logFile_.create();
+ }
+
+ logStream = logFile_.createOutputStream (256);
+ jassert (logStream != 0);
+
+ String welcome;
+ welcome << "\r\n**********************************************************\r\n"
+ << welcomeMessage
+ << "\r\nLog started: " << Time::getCurrentTime().toString (true, true)
+ << "\r\n";
+
+ logMessage (welcome);
+}
+
+FileLogger::~FileLogger()
+{
+ deleteAndZero (logStream);
+}
+
+void FileLogger::logMessage (const String& message)
+{
+ if (logStream != 0)
+ {
+ Logger::outputDebugString (message);
+
+ const ScopedLock sl (logLock);
+ (*logStream) << message << T("\r\n");
+ logStream->flush();
+ }
+}
+
+void FileLogger::trimFileSize (int maxFileSizeBytes) const
+{
+ if (maxFileSizeBytes <= 0)
+ {
+ logFile.deleteFile();
+ }
+ else
+ {
+ const int64 fileSize = logFile.getSize();
+
+ if (fileSize > maxFileSizeBytes)
+ {
+ FileInputStream* const in = logFile.createInputStream();
+ jassert (in != 0);
+
+ if (in != 0)
+ {
+ in->setPosition (fileSize - maxFileSizeBytes);
+ String content;
+
+ {
+ MemoryBlock contentToSave;
+ contentToSave.setSize (maxFileSizeBytes + 4);
+ contentToSave.fillWith (0);
+
+ in->read (contentToSave.getData(), maxFileSizeBytes);
+ delete in;
+
+ content = contentToSave.toString();
+ }
+
+ int newStart = 0;
+
+ while (newStart < fileSize
+ && content[newStart] != '\n'
+ && content[newStart] != '\r')
+ ++newStart;
+
+ logFile.deleteFile();
+ logFile.appendText (content.substring (newStart), false, false);
+ }
+ }
+ }
+}
+
+FileLogger* FileLogger::createDefaultAppLogger (const String& logFileSubDirectoryName,
+ const String& logFileName,
+ const String& welcomeMessage,
+ const int maxInitialFileSizeBytes)
+{
+#if JUCE_MAC
+ File logFile ("~/Library/Logs");
+ logFile = logFile.getChildFile (logFileName);
+
+#else
+ File logFile (File::getSpecialLocation (File::userApplicationDataDirectory));
+
+ if (logFile.isDirectory())
+ {
+ logFile = logFile.getChildFile (logFileSubDirectoryName)
+ .getChildFile (logFileName);
+ }
+#endif
+
+ return new FileLogger (logFile, welcomeMessage, maxInitialFileSizeBytes);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_FileLogger.cpp *********/
+
+/********* Start of inlined file: juce_Logger.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+Logger::Logger()
+{
+}
+
+Logger::~Logger()
+{
+}
+
+static Logger* currentLogger = 0;
+
+void Logger::setCurrentLogger (Logger* const newLogger,
+ const bool deleteOldLogger)
+{
+ Logger* const oldLogger = currentLogger;
+ currentLogger = newLogger;
+
+ if (deleteOldLogger && (oldLogger != 0))
+ delete oldLogger;
+}
+
+void Logger::writeToLog (const String& message)
+{
+ if (currentLogger != 0)
+ currentLogger->logMessage (message);
+ else
+ outputDebugString (message);
+}
+
+#if JUCE_LOG_ASSERTIONS
+void JUCE_API juce_LogAssertion (const char* filename, const int lineNum) throw()
+{
+ String m ("JUCE Assertion failure in ");
+ m << filename << ", line " << lineNum;
+
+ Logger::writeToLog (m);
+}
+#endif
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_Logger.cpp *********/
+
+/********* Start of inlined file: juce_Random.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+Random::Random (const int64 seedValue) throw()
+ : seed (seedValue)
+{
+}
+
+Random::~Random() throw()
+{
+}
+
+void Random::setSeed (const int64 newSeed) throw()
+{
+ seed = newSeed;
+}
+
+int Random::nextInt() throw()
+{
+ seed = (seed * literal64bit (0x5deece66d) + 11) & literal64bit (0xffffffffffff);
+
+ return (int) (seed >> 16);
+}
+
+int Random::nextInt (const int maxValue) throw()
+{
+ jassert (maxValue > 0);
+ return (nextInt() & 0x7fffffff) % maxValue;
+}
+
+int64 Random::nextInt64() throw()
+{
+ return (((int64) nextInt()) << 32) | (int64) (uint64) (uint32) nextInt();
+}
+
+bool Random::nextBool() throw()
+{
+ return (nextInt() & 0x80000000) != 0;
+}
+
+float Random::nextFloat() throw()
+{
+ return ((uint32) nextInt()) / (float) 0xffffffff;
+}
+
+double Random::nextDouble() throw()
+{
+ return ((uint32) nextInt()) / (double) 0xffffffff;
+}
+
+static Random sysRand (1);
+
+Random& Random::getSystemRandom() throw()
+{
+ return sysRand;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_Random.cpp *********/
+
+/********* Start of inlined file: juce_RelativeTime.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+RelativeTime::RelativeTime (const double seconds_) throw()
+ : seconds (seconds_)
+{
+}
+
+RelativeTime::RelativeTime (const RelativeTime& other) throw()
+ : seconds (other.seconds)
+{
+}
+
+RelativeTime::~RelativeTime() throw()
+{
+}
+
+const RelativeTime RelativeTime::milliseconds (const int milliseconds) throw()
+{
+ return RelativeTime (milliseconds * 0.001);
+}
+
+const RelativeTime RelativeTime::milliseconds (const int64 milliseconds) throw()
+{
+ return RelativeTime (milliseconds * 0.001);
+}
+
+const RelativeTime RelativeTime::minutes (const double numberOfMinutes) throw()
+{
+ return RelativeTime (numberOfMinutes * 60.0);
+}
+
+const RelativeTime RelativeTime::hours (const double numberOfHours) throw()
+{
+ return RelativeTime (numberOfHours * (60.0 * 60.0));
+}
+
+const RelativeTime RelativeTime::days (const double numberOfDays) throw()
+{
+ return RelativeTime (numberOfDays * (60.0 * 60.0 * 24.0));
+}
+
+const RelativeTime RelativeTime::weeks (const double numberOfWeeks) throw()
+{
+ return RelativeTime (numberOfWeeks * (60.0 * 60.0 * 24.0 * 7.0));
+}
+
+int64 RelativeTime::inMilliseconds() const throw()
+{
+ return (int64)(seconds * 1000.0);
+}
+
+double RelativeTime::inMinutes() const throw()
+{
+ return seconds / 60.0;
+}
+
+double RelativeTime::inHours() const throw()
+{
+ return seconds / (60.0 * 60.0);
+}
+
+double RelativeTime::inDays() const throw()
+{
+ return seconds / (60.0 * 60.0 * 24.0);
+}
+
+double RelativeTime::inWeeks() const throw()
+{
+ return seconds / (60.0 * 60.0 * 24.0 * 7.0);
+}
+
+const String RelativeTime::getDescription (const String& returnValueForZeroTime) const throw()
+{
+ if (seconds < 0.001 && seconds > -0.001)
+ return returnValueForZeroTime;
+
+ String result;
+
+ if (seconds < 0)
+ result = T("-");
+
+ int fieldsShown = 0;
+ int n = abs ((int) inWeeks());
+ if (n > 0)
+ {
+ result << n << ((n == 1) ? TRANS(" week ")
+ : TRANS(" weeks "));
+ ++fieldsShown;
+ }
+
+ n = abs ((int) inDays()) % 7;
+ if (n > 0)
+ {
+ result << n << ((n == 1) ? TRANS(" day ")
+ : TRANS(" days "));
+ ++fieldsShown;
+ }
+
+ if (fieldsShown < 2)
+ {
+ n = abs ((int) inHours()) % 24;
+ if (n > 0)
+ {
+ result << n << ((n == 1) ? TRANS(" hr ")
+ : TRANS(" hrs "));
+ ++fieldsShown;
+ }
+
+ if (fieldsShown < 2)
+ {
+ n = abs ((int) inMinutes()) % 60;
+ if (n > 0)
+ {
+ result << n << ((n == 1) ? TRANS(" min ")
+ : TRANS(" mins "));
+ ++fieldsShown;
+ }
+
+ if (fieldsShown < 2)
+ {
+ n = abs ((int) inSeconds()) % 60;
+ if (n > 0)
+ {
+ result << n << ((n == 1) ? TRANS(" sec ")
+ : TRANS(" secs "));
+ ++fieldsShown;
+ }
+
+ if (fieldsShown < 1)
+ {
+ n = abs ((int) inMilliseconds()) % 1000;
+ if (n > 0)
+ {
+ result << n << TRANS(" ms");
+ ++fieldsShown;
+ }
+ }
+ }
+ }
+ }
+
+ return result.trimEnd();
+}
+
+const RelativeTime& RelativeTime::operator= (const RelativeTime& other) throw()
+{
+ seconds = other.seconds;
+ return *this;
+}
+
+bool RelativeTime::operator== (const RelativeTime& other) const throw()
+{
+ return seconds == other.seconds;
+}
+
+bool RelativeTime::operator!= (const RelativeTime& other) const throw()
+{
+ return seconds != other.seconds;
+}
+
+bool RelativeTime::operator> (const RelativeTime& other) const throw()
+{
+ return seconds > other.seconds;
+}
+
+bool RelativeTime::operator< (const RelativeTime& other) const throw()
+{
+ return seconds < other.seconds;
+}
+
+bool RelativeTime::operator>= (const RelativeTime& other) const throw()
+{
+ return seconds >= other.seconds;
+}
+
+bool RelativeTime::operator<= (const RelativeTime& other) const throw()
+{
+ return seconds <= other.seconds;
+}
+
+const RelativeTime RelativeTime::operator+ (const RelativeTime& timeToAdd) const throw()
+{
+ return RelativeTime (seconds + timeToAdd.seconds);
+}
+
+const RelativeTime RelativeTime::operator- (const RelativeTime& timeToSubtract) const throw()
+{
+ return RelativeTime (seconds - timeToSubtract.seconds);
+}
+
+const RelativeTime RelativeTime::operator+ (const double secondsToAdd) const throw()
+{
+ return RelativeTime (seconds + secondsToAdd);
+}
+
+const RelativeTime RelativeTime::operator- (const double secondsToSubtract) const throw()
+{
+ return RelativeTime (seconds - secondsToSubtract);
+}
+
+const RelativeTime& RelativeTime::operator+= (const RelativeTime& timeToAdd) throw()
+{
+ seconds += timeToAdd.seconds;
+ return *this;
+}
+
+const RelativeTime& RelativeTime::operator-= (const RelativeTime& timeToSubtract) throw()
+{
+ seconds -= timeToSubtract.seconds;
+ return *this;
+}
+
+const RelativeTime& RelativeTime::operator+= (const double secondsToAdd) throw()
+{
+ seconds += secondsToAdd;
+ return *this;
+}
+
+const RelativeTime& RelativeTime::operator-= (const double secondsToSubtract) throw()
+{
+ seconds -= secondsToSubtract;
+ return *this;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_RelativeTime.cpp *********/
+
+/********* Start of inlined file: juce_SystemStats.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+void juce_initialiseStrings();
+
+const String SystemStats::getJUCEVersion() throw()
+{
+ return "JUCE v" + String (JUCE_MAJOR_VERSION) + "." + String (JUCE_MINOR_VERSION);
+}
+
+static bool juceInitialisedNonGUI = false;
+
+void JUCE_PUBLIC_FUNCTION initialiseJuce_NonGUI()
+{
+ if (! juceInitialisedNonGUI)
+ {
+#ifdef JUCE_DEBUG
+ // Some simple test code to keep an eye on things and make sure these functions
+ // work ok on all platforms. Let me know if any of these assertions fail!
+ int n = 1;
+ atomicIncrement (n);
+ jassert (atomicIncrementAndReturn (n) == 3);
+ atomicDecrement (n);
+ jassert (atomicDecrementAndReturn (n) == 1);
+
+ jassert (swapByteOrder ((uint32) 0x11223344) == 0x44332211);
+
+ // quick test to make sure the run-time lib doesn't crash on freeing a null-pointer.
+ SystemStats* nullPointer = 0;
+ juce_free (nullPointer);
+ delete[] nullPointer;
+ delete nullPointer;
+#endif
+ // Now the real initialisation..
+
+ juceInitialisedNonGUI = true;
+
+ DBG (SystemStats::getJUCEVersion());
+ juce_initialiseStrings();
+ SystemStats::initialiseStats();
+ Random::getSystemRandom().setSeed (Time::currentTimeMillis());
+ }
+}
+
+#if JUCE_WIN32
+ // This is imported from the sockets code..
+ typedef int (__stdcall juce_CloseWin32SocketLibCall) (void);
+ extern juce_CloseWin32SocketLibCall* juce_CloseWin32SocketLib;
+#endif
+
+#if JUCE_DEBUG
+ extern void juce_CheckForDanglingStreams();
+#endif
+
+void JUCE_PUBLIC_FUNCTION shutdownJuce_NonGUI()
+{
+ if (juceInitialisedNonGUI)
+ {
+#if JUCE_WIN32
+ // need to shut down sockets if they were used..
+ if (juce_CloseWin32SocketLib != 0)
+ (*juce_CloseWin32SocketLib)();
+#endif
+
+ LocalisedStrings::setCurrentMappings (0);
+ Thread::stopAllThreads (3000);
+
+#if JUCE_DEBUG
+ juce_CheckForDanglingStreams();
+#endif
+
+ juceInitialisedNonGUI = false;
+ }
+}
+
+#ifdef JUCE_DLL
+
+void* juce_Malloc (const int size)
+{
+ return malloc (size);
+}
+
+void* juce_Calloc (const int size)
+{
+ return calloc (1, size);
+}
+
+void* juce_Realloc (void* const block, const int size)
+{
+ return realloc (block, size);
+}
+
+void juce_Free (void* const block)
+{
+ free (block);
+}
+
+#if defined (JUCE_DEBUG) && JUCE_MSVC && JUCE_CHECK_MEMORY_LEAKS
+
+void* juce_DebugMalloc (const int size, const char* file, const int line)
+{
+ return _malloc_dbg (size, _NORMAL_BLOCK, file, line);
+}
+
+void* juce_DebugCalloc (const int size, const char* file, const int line)
+{
+ return _calloc_dbg (1, size, _NORMAL_BLOCK, file, line);
+}
+
+void* juce_DebugRealloc (void* const block, const int size, const char* file, const int line)
+{
+ return _realloc_dbg (block, size, _NORMAL_BLOCK, file, line);
+}
+
+void juce_DebugFree (void* const block)
+{
+ _free_dbg (block, _NORMAL_BLOCK);
+}
+
+#endif
+#endif
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_SystemStats.cpp *********/
+
+/********* Start of inlined file: juce_Time.cpp *********/
+#ifdef _MSC_VER
+ #pragma warning (disable: 4514)
+ #pragma warning (push)
+#endif
+
+#ifndef JUCE_WIN32
+ #include
+#else
+ #include
+#endif
+
+#include
+
+BEGIN_JUCE_NAMESPACE
+
+#ifdef _MSC_VER
+ #pragma warning (pop)
+
+ #ifdef _INC_TIME_INL
+ #define USE_NEW_SECURE_TIME_FNS
+ #endif
+#endif
+
+static void millisToLocal (const int64 millis, struct tm& result) throw()
+{
+ const int64 seconds = millis / 1000;
+
+ if (seconds < literal64bit (86400) || seconds >= literal64bit (2145916800))
+ {
+ // use extended maths for dates beyond 1970 to 2037..
+ const int timeZoneAdjustment = 31536000 - (int) (Time (1971, 0, 1, 0, 0).toMilliseconds() / 1000);
+ const int64 jdm = seconds + timeZoneAdjustment + literal64bit (210866803200);
+
+ const int days = (int) (jdm / literal64bit (86400));
+ const int a = 32044 + days;
+ const int b = (4 * a + 3) / 146097;
+ const int c = a - (b * 146097) / 4;
+ const int d = (4 * c + 3) / 1461;
+ const int e = c - (d * 1461) / 4;
+ const int m = (5 * e + 2) / 153;
+
+ result.tm_mday = e - (153 * m + 2) / 5 + 1;
+ result.tm_mon = m + 2 - 12 * (m / 10);
+ result.tm_year = b * 100 + d - 6700 + (m / 10);
+ result.tm_wday = (days + 1) % 7;
+ result.tm_yday = -1;
+
+ int t = (int) (jdm % literal64bit (86400));
+ result.tm_hour = t / 3600;
+ t %= 3600;
+ result.tm_min = t / 60;
+ result.tm_sec = t % 60;
+ result.tm_isdst = -1;
+ }
+ else
+ {
+ time_t now = (time_t) (seconds);
+
+#if JUCE_WIN32
+ #ifdef USE_NEW_SECURE_TIME_FNS
+ if (now >= 0 && now <= 0x793406fff)
+ localtime_s (&result, &now);
+ else
+ zeromem (&result, sizeof (result));
+ #else
+ result = *localtime (&now);
+ #endif
+#else
+ // more thread-safe
+ localtime_r (&now, &result);
+#endif
+ }
+}
+
+Time::Time() throw()
+ : millisSinceEpoch (0)
+{
+}
+
+Time::Time (const Time& other) throw()
+ : millisSinceEpoch (other.millisSinceEpoch)
+{
+}
+
+Time::Time (const int64 ms) throw()
+ : millisSinceEpoch (ms)
+{
+}
+
+Time::Time (const int year,
+ const int month,
+ const int day,
+ const int hours,
+ const int minutes,
+ const int seconds,
+ const int milliseconds) throw()
+{
+ jassert (year > 100); // year must be a 4-digit version
+
+ if (year < 1971 || year >= 2038)
+ {
+ // use extended maths for dates beyond 1970 to 2037..
+ const int timeZoneAdjustment = 31536000 - (int) (Time (1971, 0, 1, 0, 0).toMilliseconds() / 1000);
+ const int a = (13 - month) / 12;
+ const int y = year + 4800 - a;
+ const int jd = day + (153 * (month + 12 * a - 2) + 2) / 5
+ + (y * 365) + (y / 4) - (y / 100) + (y / 400)
+ - 32045;
+
+ const int64 s = ((int64) jd) * literal64bit (86400) - literal64bit (210866803200);
+
+ millisSinceEpoch = 1000 * (s + (hours * 3600 + minutes * 60 + seconds - timeZoneAdjustment))
+ + milliseconds;
+ }
+ else
+ {
+ struct tm t;
+ t.tm_year = year - 1900;
+ t.tm_mon = month;
+ t.tm_mday = day;
+ t.tm_hour = hours;
+ t.tm_min = minutes;
+ t.tm_sec = seconds;
+ t.tm_isdst = -1;
+
+ millisSinceEpoch = 1000 * (int64) mktime (&t);
+
+ if (millisSinceEpoch < 0)
+ millisSinceEpoch = 0;
+ else
+ millisSinceEpoch += milliseconds;
+ }
+}
+
+Time::~Time() throw()
+{
+}
+
+const Time& Time::operator= (const Time& other) throw()
+{
+ millisSinceEpoch = other.millisSinceEpoch;
+ return *this;
+}
+
+int64 Time::currentTimeMillis() throw()
+{
+ static uint32 lastCounterResult = 0xffffffff;
+ static int64 correction = 0;
+
+ const uint32 now = getMillisecondCounter();
+
+ // check the counter hasn't wrapped (also triggered the first time this function is called)
+ if (now < lastCounterResult)
+ {
+ // double-check it's actually wrapped, in case multi-cpu machines have timers that drift a bit.
+ if (lastCounterResult == 0xffffffff || now < lastCounterResult - 10)
+ {
+ // get the time once using normal library calls, and store the difference needed to
+ // turn the millisecond counter into a real time.
+#if JUCE_WIN32
+ struct _timeb t;
+ #ifdef USE_NEW_SECURE_TIME_FNS
+ _ftime_s (&t);
+ #else
+ _ftime (&t);
+ #endif
+ correction = (((int64) t.time) * 1000 + t.millitm) - now;
+#else
+ struct timeval tv;
+ struct timezone tz;
+ gettimeofday (&tv, &tz);
+ correction = (((int64) tv.tv_sec) * 1000 + tv.tv_usec / 1000) - now;
+#endif
+ }
+ }
+
+ lastCounterResult = now;
+
+ return correction + now;
+}
+
+uint32 juce_millisecondsSinceStartup() throw();
+static uint32 lastMSCounterValue = 0;
+
+uint32 Time::getMillisecondCounter() throw()
+{
+ const uint32 now = juce_millisecondsSinceStartup();
+
+ if (now < lastMSCounterValue)
+ {
+ // in multi-threaded apps this might be called concurrently, so
+ // make sure that our last counter value only increases and doesn't
+ // go backwards..
+ if (now < lastMSCounterValue - 1000)
+ lastMSCounterValue = now;
+ }
+ else
+ {
+ lastMSCounterValue = now;
+ }
+
+ return now;
+}
+
+uint32 Time::getApproximateMillisecondCounter() throw()
+{
+ jassert (lastMSCounterValue != 0);
+ return lastMSCounterValue;
+}
+
+void Time::waitForMillisecondCounter (const uint32 targetTime) throw()
+{
+ for (;;)
+ {
+ const uint32 now = getMillisecondCounter();
+
+ if (now >= targetTime)
+ break;
+
+ const int toWait = targetTime - now;
+
+ if (toWait > 2)
+ {
+ Thread::sleep (jmin (20, toWait >> 1));
+ }
+ else
+ {
+ // xxx should consider using mutex_pause on the mac as it apparently
+ // makes it seem less like a spinlock and avoids lowering the thread pri.
+ for (int i = 10; --i >= 0;)
+ Thread::yield();
+ }
+ }
+}
+
+double Time::highResolutionTicksToSeconds (const int64 ticks) throw()
+{
+ return ticks / (double) getHighResolutionTicksPerSecond();
+}
+
+int64 Time::secondsToHighResolutionTicks (const double seconds) throw()
+{
+ return (int64) (seconds * (double) getHighResolutionTicksPerSecond());
+}
+
+const Time JUCE_CALLTYPE Time::getCurrentTime() throw()
+{
+ return Time (currentTimeMillis());
+}
+
+const String Time::toString (const bool includeDate,
+ const bool includeTime,
+ const bool includeSeconds,
+ const bool use24HourClock) const throw()
+{
+ String result;
+
+ if (includeDate)
+ {
+ result << getDayOfMonth() << ' '
+ << getMonthName (true) << ' '
+ << getYear();
+
+ if (includeTime)
+ result << ' ';
+ }
+
+ if (includeTime)
+ {
+ if (includeSeconds)
+ {
+ result += String::formatted (T("%d:%02d:%02d "),
+ (use24HourClock) ? getHours()
+ : getHoursInAmPmFormat(),
+ getMinutes(),
+ getSeconds());
+ }
+ else
+ {
+ result += String::formatted (T("%d.%02d"),
+ (use24HourClock) ? getHours()
+ : getHoursInAmPmFormat(),
+ getMinutes());
+ }
+
+ if (! use24HourClock)
+ result << (isAfternoon() ? "pm" : "am");
+ }
+
+ return result.trimEnd();
+}
+
+const String Time::formatted (const tchar* const format) const throw()
+{
+ tchar buffer[80];
+
+ struct tm t;
+ millisToLocal (millisSinceEpoch, t);
+
+ if (CharacterFunctions::ftime (buffer, 79, format, &t) <= 0)
+ {
+ int bufferSize = 128;
+
+ for (;;)
+ {
+ MemoryBlock mb (bufferSize * sizeof (tchar));
+ tchar* const b = (tchar*) mb.getData();
+
+ if (CharacterFunctions::ftime (b, bufferSize, format, &t) > 0)
+ return String (b);
+
+ bufferSize += 128;
+ }
+ }
+
+ return String (buffer);
+}
+
+int Time::getYear() const throw()
+{
+ struct tm t;
+ millisToLocal (millisSinceEpoch, t);
+ return t.tm_year + 1900;
+}
+
+int Time::getMonth() const throw()
+{
+ struct tm t;
+ millisToLocal (millisSinceEpoch, t);
+ return t.tm_mon;
+}
+
+int Time::getDayOfMonth() const throw()
+{
+ struct tm t;
+ millisToLocal (millisSinceEpoch, t);
+ return t.tm_mday;
+}
+
+int Time::getDayOfWeek() const throw()
+{
+ struct tm t;
+ millisToLocal (millisSinceEpoch, t);
+ return t.tm_wday;
+}
+
+int Time::getHours() const throw()
+{
+ struct tm t;
+ millisToLocal (millisSinceEpoch, t);
+ return t.tm_hour;
+}
+
+int Time::getHoursInAmPmFormat() const throw()
+{
+ const int hours = getHours();
+
+ if (hours == 0)
+ return 12;
+ else if (hours <= 12)
+ return hours;
+ else
+ return hours - 12;
+}
+
+bool Time::isAfternoon() const throw()
+{
+ return getHours() >= 12;
+}
+
+static int extendedModulo (const int64 value, const int modulo) throw()
+{
+ return (int) (value >= 0 ? (value % modulo)
+ : (value - ((value / modulo) + 1) * modulo));
+}
+
+int Time::getMinutes() const throw()
+{
+ return extendedModulo (millisSinceEpoch / 60000, 60);
+}
+
+int Time::getSeconds() const throw()
+{
+ return extendedModulo (millisSinceEpoch / 1000, 60);
+}
+
+int Time::getMilliseconds() const throw()
+{
+ return extendedModulo (millisSinceEpoch, 1000);
+}
+
+bool Time::isDaylightSavingTime() const throw()
+{
+ struct tm t;
+ millisToLocal (millisSinceEpoch, t);
+ return t.tm_isdst != 0;
+}
+
+const String Time::getTimeZone() const throw()
+{
+ String zone[2];
+
+#if JUCE_WIN32
+ _tzset();
+
+ #ifdef USE_NEW_SECURE_TIME_FNS
+ {
+ char name [128];
+ size_t length;
+
+ for (int i = 0; i < 2; ++i)
+ {
+ zeromem (name, sizeof (name));
+ _get_tzname (&length, name, 127, i);
+ zone[i] = name;
+ }
+ }
+ #else
+ const char** const zonePtr = (const char**) _tzname;
+ zone[0] = zonePtr[0];
+ zone[1] = zonePtr[1];
+ #endif
+#else
+ tzset();
+ const char** const zonePtr = (const char**) tzname;
+ zone[0] = zonePtr[0];
+ zone[1] = zonePtr[1];
+#endif
+
+ if (isDaylightSavingTime())
+ {
+ zone[0] = zone[1];
+
+ if (zone[0].length() > 3
+ && zone[0].containsIgnoreCase (T("daylight"))
+ && zone[0].contains (T("GMT")))
+ zone[0] = "BST";
+ }
+
+ return zone[0].substring (0, 3);
+}
+
+const String Time::getMonthName (const bool threeLetterVersion) const throw()
+{
+ return getMonthName (getMonth(), threeLetterVersion);
+}
+
+const String Time::getWeekdayName (const bool threeLetterVersion) const throw()
+{
+ return getWeekdayName (getDayOfWeek(), threeLetterVersion);
+}
+
+const String Time::getMonthName (int monthNumber,
+ const bool threeLetterVersion) throw()
+{
+ const char* const shortMonthNames[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
+ const char* const longMonthNames[] = { "January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December" };
+
+ monthNumber %= 12;
+
+ return TRANS (threeLetterVersion ? shortMonthNames [monthNumber]
+ : longMonthNames [monthNumber]);
+}
+
+const String Time::getWeekdayName (int day,
+ const bool threeLetterVersion) throw()
+{
+ const char* const shortDayNames[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
+ const char* const longDayNames[] = { "Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday" };
+
+ day %= 7;
+
+ return TRANS (threeLetterVersion ? shortDayNames [day]
+ : longDayNames [day]);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_Time.cpp *********/
+
+/********* Start of inlined file: juce_BitArray.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+BitArray::BitArray() throw()
+ : numValues (4),
+ highestBit (-1),
+ negative (false)
+{
+ values = (unsigned int*) juce_calloc (sizeof (unsigned int) * (numValues + 1));
+}
+
+BitArray::BitArray (const int value) throw()
+ : numValues (4),
+ highestBit (31),
+ negative (value < 0)
+{
+ values = (unsigned int*) juce_calloc (sizeof (unsigned int) * (numValues + 1));
+ values[0] = abs (value);
+ highestBit = getHighestBit();
+}
+
+BitArray::BitArray (int64 value) throw()
+ : numValues (4),
+ highestBit (63),
+ negative (value < 0)
+{
+ values = (unsigned int*) juce_calloc (sizeof (unsigned int) * (numValues + 1));
+
+ if (value < 0)
+ value = -value;
+
+ values[0] = (unsigned int) value;
+ values[1] = (unsigned int) (value >> 32);
+ highestBit = getHighestBit();
+}
+
+BitArray::BitArray (const unsigned int value) throw()
+ : numValues (4),
+ highestBit (31),
+ negative (false)
+{
+ values = (unsigned int*) juce_calloc (sizeof (unsigned int) * (numValues + 1));
+ values[0] = value;
+ highestBit = getHighestBit();
+}
+
+BitArray::BitArray (const BitArray& other) throw()
+ : numValues (jmax (4, (other.highestBit >> 5) + 1)),
+ highestBit (other.getHighestBit()),
+ negative (other.negative)
+{
+ const int bytes = sizeof (unsigned int) * (numValues + 1);
+ values = (unsigned int*) juce_malloc (bytes);
+ memcpy (values, other.values, bytes);
+}
+
+BitArray::~BitArray() throw()
+{
+ juce_free (values);
+}
+
+const BitArray& BitArray::operator= (const BitArray& other) throw()
+{
+ if (this != &other)
+ {
+ juce_free (values);
+
+ highestBit = other.getHighestBit();
+ numValues = jmax (4, (highestBit >> 5) + 1);
+ negative = other.negative;
+ const int memSize = sizeof (unsigned int) * (numValues + 1);
+ values = (unsigned int*)juce_malloc (memSize);
+ memcpy (values, other.values, memSize);
+ }
+
+ return *this;
+}
+
+// result == 0 = the same
+// result < 0 = this number is smaller
+// result > 0 = this number is bigger
+int BitArray::compare (const BitArray& other) const throw()
+{
+ if (isNegative() == other.isNegative())
+ {
+ const int absComp = compareAbsolute (other);
+ return isNegative() ? -absComp : absComp;
+ }
+ else
+ {
+ return isNegative() ? -1 : 1;
+ }
+}
+
+int BitArray::compareAbsolute (const BitArray& other) const throw()
+{
+ const int h1 = getHighestBit();
+ const int h2 = other.getHighestBit();
+
+ if (h1 > h2)
+ return 1;
+ else if (h1 < h2)
+ return -1;
+
+ for (int i = (h1 >> 5) + 1; --i >= 0;)
+ if (values[i] != other.values[i])
+ return (values[i] > other.values[i]) ? 1 : -1;
+
+ return 0;
+}
+
+bool BitArray::operator== (const BitArray& other) const throw()
+{
+ return compare (other) == 0;
+}
+
+bool BitArray::operator!= (const BitArray& other) const throw()
+{
+ return compare (other) != 0;
+}
+
+bool BitArray::operator[] (const int bit) const throw()
+{
+ return bit >= 0 && bit <= highestBit
+ && ((values [bit >> 5] & (1 << (bit & 31))) != 0);
+}
+
+bool BitArray::isEmpty() const throw()
+{
+ return getHighestBit() < 0;
+}
+
+void BitArray::clear() throw()
+{
+ if (numValues > 16)
+ {
+ juce_free (values);
+ numValues = 4;
+ values = (unsigned int*) juce_calloc (sizeof (unsigned int) * (numValues + 1));
+ }
+ else
+ {
+ zeromem (values, sizeof (unsigned int) * (numValues + 1));
+ }
+
+ highestBit = -1;
+ negative = false;
+}
+
+void BitArray::setBit (const int bit) throw()
+{
+ if (bit >= 0)
+ {
+ if (bit > highestBit)
+ {
+ ensureSize (bit >> 5);
+ highestBit = bit;
+ }
+
+ values [bit >> 5] |= (1 << (bit & 31));
+ }
+}
+
+void BitArray::setBit (const int bit,
+ const bool shouldBeSet) throw()
+{
+ if (shouldBeSet)
+ setBit (bit);
+ else
+ clearBit (bit);
+}
+
+void BitArray::clearBit (const int bit) throw()
+{
+ if (bit >= 0 && bit <= highestBit)
+ values [bit >> 5] &= ~(1 << (bit & 31));
+}
+
+void BitArray::setRange (int startBit,
+ int numBits,
+ const bool shouldBeSet) throw()
+{
+ while (--numBits >= 0)
+ setBit (startBit++, shouldBeSet);
+}
+
+void BitArray::insertBit (const int bit,
+ const bool shouldBeSet) throw()
+{
+ if (bit >= 0)
+ shiftBits (1, bit);
+
+ setBit (bit, shouldBeSet);
+}
+
+void BitArray::andWith (const BitArray& other) throw()
+{
+ // this operation will only work with the absolute values
+ jassert (isNegative() == other.isNegative());
+
+ int n = numValues;
+
+ while (n > other.numValues)
+ values[--n] = 0;
+
+ while (--n >= 0)
+ values[n] &= other.values[n];
+
+ if (other.highestBit < highestBit)
+ highestBit = other.highestBit;
+
+ highestBit = getHighestBit();
+}
+
+void BitArray::orWith (const BitArray& other) throw()
+{
+ if (other.highestBit < 0)
+ return;
+
+ // this operation will only work with the absolute values
+ jassert (isNegative() == other.isNegative());
+
+ ensureSize (other.highestBit >> 5);
+
+ int n = (other.highestBit >> 5) + 1;
+
+ while (--n >= 0)
+ values[n] |= other.values[n];
+
+ if (other.highestBit > highestBit)
+ highestBit = other.highestBit;
+
+ highestBit = getHighestBit();
+}
+
+void BitArray::xorWith (const BitArray& other) throw()
+{
+ if (other.highestBit < 0)
+ return;
+
+ // this operation will only work with the absolute values
+ jassert (isNegative() == other.isNegative());
+
+ ensureSize (other.highestBit >> 5);
+
+ int n = (other.highestBit >> 5) + 1;
+
+ while (--n >= 0)
+ values[n] ^= other.values[n];
+
+ if (other.highestBit > highestBit)
+ highestBit = other.highestBit;
+
+ highestBit = getHighestBit();
+}
+
+void BitArray::add (const BitArray& other) throw()
+{
+ if (other.isNegative())
+ {
+ BitArray o (other);
+ o.negate();
+ subtract (o);
+ return;
+ }
+
+ if (isNegative())
+ {
+ if (compareAbsolute (other) < 0)
+ {
+ BitArray temp (*this);
+ temp.negate();
+ *this = other;
+ subtract (temp);
+ }
+ else
+ {
+ negate();
+ subtract (other);
+ negate();
+ }
+
+ return;
+ }
+
+ if (other.highestBit > highestBit)
+ highestBit = other.highestBit;
+
+ ++highestBit;
+
+ const int numInts = (highestBit >> 5) + 1;
+ ensureSize (numInts);
+
+ int64 remainder = 0;
+
+ for (int i = 0; i <= numInts; ++i)
+ {
+ if (i < numValues)
+ remainder += values[i];
+
+ if (i < other.numValues)
+ remainder += other.values[i];
+
+ values[i] = (unsigned int) remainder;
+ remainder >>= 32;
+ }
+
+ jassert (remainder == 0);
+ highestBit = getHighestBit();
+}
+
+void BitArray::subtract (const BitArray& other) throw()
+{
+ if (other.isNegative())
+ {
+ BitArray o (other);
+ o.negate();
+ add (o);
+ return;
+ }
+
+ if (! isNegative())
+ {
+ if (compareAbsolute (other) < 0)
+ {
+ BitArray temp (*this);
+ *this = other;
+ subtract (temp);
+ negate();
+ return;
+ }
+ }
+ else
+ {
+ negate();
+ add (other);
+ negate();
+ return;
+ }
+
+ const int numInts = (highestBit >> 5) + 1;
+ const int maxOtherInts = (other.highestBit >> 5) + 1;
+ int64 amountToSubtract = 0;
+
+ for (int i = 0; i <= numInts; ++i)
+ {
+ if (i <= maxOtherInts)
+ amountToSubtract += (int64)other.values[i];
+
+ if (values[i] >= amountToSubtract)
+ {
+ values[i] = (unsigned int) (values[i] - amountToSubtract);
+ amountToSubtract = 0;
+ }
+ else
+ {
+ const int64 n = ((int64) values[i] + (((int64) 1) << 32)) - amountToSubtract;
+ values[i] = (unsigned int) n;
+ amountToSubtract = 1;
+ }
+ }
+}
+
+void BitArray::multiplyBy (const BitArray& other) throw()
+{
+ BitArray total;
+ highestBit = getHighestBit();
+ const bool wasNegative = isNegative();
+ setNegative (false);
+
+ for (int i = 0; i <= highestBit; ++i)
+ {
+ if (operator[](i))
+ {
+ BitArray n (other);
+ n.setNegative (false);
+ n.shiftBits (i);
+ total.add (n);
+ }
+ }
+
+ *this = total;
+ negative = wasNegative ^ other.isNegative();
+}
+
+void BitArray::divideBy (const BitArray& divisor, BitArray& remainder) throw()
+{
+ jassert (this != &remainder); // (can't handle passing itself in to get the remainder)
+
+ const int divHB = divisor.getHighestBit();
+ const int ourHB = getHighestBit();
+
+ if (divHB < 0 || ourHB < 0)
+ {
+ // division by zero
+ remainder.clear();
+ clear();
+ }
+ else
+ {
+ remainder = *this;
+ remainder.setNegative (false);
+ const bool wasNegative = isNegative();
+ clear();
+
+ BitArray temp (divisor);
+ temp.setNegative (false);
+
+ int leftShift = ourHB - divHB;
+ temp.shiftBits (leftShift);
+
+ while (leftShift >= 0)
+ {
+ if (remainder.compareAbsolute (temp) >= 0)
+ {
+ remainder.subtract (temp);
+ setBit (leftShift);
+ }
+
+ if (--leftShift >= 0)
+ temp.shiftBits (-1);
+ }
+
+ negative = wasNegative ^ divisor.isNegative();
+ remainder.setNegative (wasNegative);
+ }
+}
+
+void BitArray::modulo (const BitArray& divisor) throw()
+{
+ BitArray remainder;
+ divideBy (divisor, remainder);
+ *this = remainder;
+}
+
+static const BitArray simpleGCD (BitArray* m, BitArray* n) throw()
+{
+ while (! m->isEmpty())
+ {
+ if (n->compareAbsolute (*m) > 0)
+ swapVariables (m, n);
+
+ m->subtract (*n);
+ }
+
+ return *n;
+}
+
+const BitArray BitArray::findGreatestCommonDivisor (BitArray n) const throw()
+{
+ BitArray m (*this);
+
+ while (! n.isEmpty())
+ {
+ if (abs (m.getHighestBit() - n.getHighestBit()) <= 16)
+ return simpleGCD (&m, &n);
+
+ BitArray temp1 (m), temp2;
+ temp1.divideBy (n, temp2);
+
+ m = n;
+ n = temp2;
+ }
+
+ return m;
+}
+
+void BitArray::exponentModulo (const BitArray& exponent,
+ const BitArray& modulus) throw()
+{
+ BitArray exp (exponent);
+ exp.modulo (modulus);
+
+ BitArray value (*this);
+ value.modulo (modulus);
+
+ clear();
+ setBit (0);
+
+ while (! exp.isEmpty())
+ {
+ if (exp [0])
+ {
+ multiplyBy (value);
+ this->modulo (modulus);
+ }
+
+ value.multiplyBy (value);
+ value.modulo (modulus);
+
+ exp.shiftBits (-1);
+ }
+}
+
+void BitArray::inverseModulo (const BitArray& modulus) throw()
+{
+ const BitArray one (1);
+
+ if (modulus == one || modulus.isNegative())
+ {
+ clear();
+ return;
+ }
+
+ if (isNegative() || compareAbsolute (modulus) >= 0)
+ this->modulo (modulus);
+
+ if (*this == one)
+ return;
+
+ if (! (*this)[0])
+ {
+ // not invertible
+ clear();
+ return;
+ }
+
+ BitArray a1 (modulus);
+ BitArray a2 (*this);
+ BitArray b1 (modulus);
+ BitArray b2 (1);
+
+ while (a2 != one)
+ {
+ BitArray temp1, temp2, multiplier (a1);
+ multiplier.divideBy (a2, temp1);
+
+ temp1 = a2;
+ temp1.multiplyBy (multiplier);
+ temp2 = a1;
+ temp2.subtract (temp1);
+ a1 = a2;
+ a2 = temp2;
+
+ temp1 = b2;
+ temp1.multiplyBy (multiplier);
+ temp2 = b1;
+ temp2.subtract (temp1);
+ b1 = b2;
+ b2 = temp2;
+ }
+
+ while (b2.isNegative())
+ b2.add (modulus);
+
+ b2.modulo (modulus);
+ *this = b2;
+}
+
+void BitArray::shiftBits (int bits, const int startBit) throw()
+{
+ if (highestBit < 0)
+ return;
+
+ if (startBit > 0)
+ {
+ if (bits < 0)
+ {
+ // right shift
+ for (int i = startBit; i <= highestBit; ++i)
+ setBit (i, operator[] (i - bits));
+
+ highestBit = getHighestBit();
+ }
+ else if (bits > 0)
+ {
+ // left shift
+ for (int i = highestBit + 1; --i >= startBit;)
+ setBit (i + bits, operator[] (i));
+
+ while (--bits >= 0)
+ clearBit (bits + startBit);
+ }
+ }
+ else
+ {
+ if (bits < 0)
+ {
+ // right shift
+ bits = -bits;
+
+ if (bits > highestBit)
+ {
+ clear();
+ }
+ else
+ {
+ const int wordsToMove = bits >> 5;
+ int top = 1 + (highestBit >> 5) - wordsToMove;
+ highestBit -= bits;
+
+ if (wordsToMove > 0)
+ {
+ int i;
+ for (i = 0; i < top; ++i)
+ values [i] = values [i + wordsToMove];
+
+ for (i = 0; i < wordsToMove; ++i)
+ values [top + i] = 0;
+
+ bits &= 31;
+ }
+
+ if (bits != 0)
+ {
+ const int invBits = 32 - bits;
+
+ --top;
+ for (int i = 0; i < top; ++i)
+ values[i] = (values[i] >> bits) | (values [i + 1] << invBits);
+
+ values[top] = (values[top] >> bits);
+ }
+
+ highestBit = getHighestBit();
+ }
+ }
+ else if (bits > 0)
+ {
+ // left shift
+ ensureSize (((highestBit + bits) >> 5) + 1);
+
+ const int wordsToMove = bits >> 5;
+ int top = 1 + (highestBit >> 5);
+ highestBit += bits;
+
+ if (wordsToMove > 0)
+ {
+ int i;
+ for (i = top; --i >= 0;)
+ values [i + wordsToMove] = values [i];
+
+ for (i = 0; i < wordsToMove; ++i)
+ values [i] = 0;
+
+ bits &= 31;
+ }
+
+ if (bits != 0)
+ {
+ const int invBits = 32 - bits;
+
+ for (int i = top + 1 + wordsToMove; --i > wordsToMove;)
+ values[i] = (values[i] << bits) | (values [i - 1] >> invBits);
+
+ values [wordsToMove] = values [wordsToMove] << bits;
+ }
+
+ highestBit = getHighestBit();
+ }
+ }
+}
+
+int BitArray::getBitRangeAsInt (const int startBit, int numBits) const throw()
+{
+ if (numBits > 32)
+ {
+ jassertfalse
+ numBits = 32;
+ }
+
+ if (startBit == 0)
+ {
+ if (numBits < 32)
+ return values[0] & ((1 << numBits) - 1);
+
+ return values[0];
+ }
+
+ int n = 0;
+ for (int i = numBits; --i >= 0;)
+ {
+ n <<= 1;
+
+ if (operator[] (startBit + i))
+ n |= 1;
+ }
+
+ return n;
+}
+
+void BitArray::setBitRangeAsInt (const int startBit, int numBits, unsigned int valueToSet) throw()
+{
+ if (numBits > 32)
+ {
+ jassertfalse
+ numBits = 32;
+ }
+
+ for (int i = 0; i < numBits; ++i)
+ {
+ setBit (startBit + i, (valueToSet & 1) != 0);
+ valueToSet >>= 1;
+ }
+}
+
+void BitArray::fillBitsRandomly (int startBit, int numBits) throw()
+{
+ highestBit = jmax (highestBit, startBit + numBits);
+ ensureSize (((startBit + numBits) >> 5) + 1);
+
+ while ((startBit & 31) != 0 && numBits > 0)
+ {
+ setBit (startBit++, Random::getSystemRandom().nextBool());
+
+ --numBits;
+ }
+
+ while (numBits >= 32)
+ {
+ values [startBit >> 5] = (unsigned int) Random::getSystemRandom().nextInt();
+
+ startBit += 32;
+ numBits -= 32;
+ }
+
+ while (--numBits >= 0)
+ {
+ setBit (startBit + numBits, Random::getSystemRandom().nextBool());
+ }
+
+ highestBit = getHighestBit();
+}
+
+void BitArray::createRandomNumber (const BitArray& maximumValue) throw()
+{
+ clear();
+
+ do
+ {
+ fillBitsRandomly (0, maximumValue.getHighestBit() + 1);
+ }
+ while (compare (maximumValue) >= 0);
+}
+
+bool BitArray::isNegative() const throw()
+{
+ return negative && ! isEmpty();
+}
+
+void BitArray::setNegative (const bool neg) throw()
+{
+ negative = neg;
+}
+
+void BitArray::negate() throw()
+{
+ negative = (! negative) && ! isEmpty();
+}
+
+int BitArray::countNumberOfSetBits() const throw()
+{
+ int total = 0;
+
+ for (int i = (highestBit >> 5) + 1; --i >= 0;)
+ {
+ unsigned int n = values[i];
+
+ if (n == 0xffffffff)
+ {
+ total += 32;
+ }
+ else
+ {
+ while (n != 0)
+ {
+ total += (n & 1);
+ n >>= 1;
+ }
+ }
+ }
+
+ return total;
+}
+
+int BitArray::getHighestBit() const throw()
+{
+ for (int i = highestBit + 1; --i >= 0;)
+ if ((values [i >> 5] & (1 << (i & 31))) != 0)
+ return i;
+
+ return -1;
+}
+
+int BitArray::findNextSetBit (int i) const throw()
+{
+ for (; i <= highestBit; ++i)
+ if ((values [i >> 5] & (1 << (i & 31))) != 0)
+ return i;
+
+ return -1;
+}
+
+int BitArray::findNextClearBit (int i) const throw()
+{
+ for (; i <= highestBit; ++i)
+ if ((values [i >> 5] & (1 << (i & 31))) == 0)
+ break;
+
+ return i;
+}
+
+void BitArray::ensureSize (const int numVals) throw()
+{
+ if (numVals + 2 >= numValues)
+ {
+ int oldSize = numValues;
+ numValues = ((numVals + 2) * 3) / 2;
+ values = (unsigned int*) juce_realloc (values, sizeof (unsigned int) * numValues + 4);
+
+ while (oldSize < numValues)
+ values [oldSize++] = 0;
+ }
+}
+
+const String BitArray::toString (const int base) const throw()
+{
+ String s;
+ BitArray v (*this);
+
+ if (base == 2 || base == 8 || base == 16)
+ {
+ const int bits = (base == 2) ? 1 : (base == 8 ? 3 : 4);
+ static const tchar* const hexDigits = T("0123456789abcdef");
+
+ for (;;)
+ {
+ const int remainder = v.getBitRangeAsInt (0, bits);
+
+ v.shiftBits (-bits);
+
+ if (remainder == 0 && v.isEmpty())
+ break;
+
+ s = String::charToString (hexDigits [remainder]) + s;
+ }
+ }
+ else if (base == 10)
+ {
+ const BitArray ten (10);
+ BitArray remainder;
+
+ for (;;)
+ {
+ v.divideBy (ten, remainder);
+
+ if (remainder.isEmpty() && v.isEmpty())
+ break;
+
+ s = String (remainder.getBitRangeAsInt (0, 8)) + s;
+ }
+ }
+ else
+ {
+ jassertfalse // can't do the specified base
+ return String::empty;
+ }
+
+ if (s.isEmpty())
+ return T("0");
+
+ return isNegative() ? T("-") + s : s;
+}
+
+void BitArray::parseString (const String& text,
+ const int base) throw()
+{
+ clear();
+ const tchar* t = (const tchar*) text;
+
+ if (base == 2 || base == 8 || base == 16)
+ {
+ const int bits = (base == 2) ? 1 : (base == 8 ? 3 : 4);
+
+ for (;;)
+ {
+ const tchar c = *t++;
+ const int digit = CharacterFunctions::getHexDigitValue (c);
+
+ if (((unsigned int) digit) < (unsigned int) base)
+ {
+ shiftBits (bits);
+ add (digit);
+ }
+ else if (c == 0)
+ {
+ break;
+ }
+ }
+ }
+ else if (base == 10)
+ {
+ const BitArray ten ((unsigned int) 10);
+
+ for (;;)
+ {
+ const tchar c = *t++;
+
+ if (c >= T('0') && c <= T('9'))
+ {
+ multiplyBy (ten);
+ add ((int) (c - T('0')));
+ }
+ else if (c == 0)
+ {
+ break;
+ }
+ }
+ }
+
+ setNegative (text.trimStart().startsWithChar (T('-')));
+}
+
+const MemoryBlock BitArray::toMemoryBlock() const throw()
+{
+ const int numBytes = (getHighestBit() + 7) >> 3;
+ MemoryBlock mb (numBytes);
+
+ for (int i = 0; i < numBytes; ++i)
+ mb[i] = (uint8) getBitRangeAsInt (i << 3, 8);
+
+ return mb;
+}
+
+void BitArray::loadFromMemoryBlock (const MemoryBlock& data) throw()
+{
+ clear();
+
+ for (int i = data.getSize(); --i >= 0;)
+ this->setBitRangeAsInt (i << 3, 8, data [i]);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_BitArray.cpp *********/
+
+/********* Start of inlined file: juce_MemoryBlock.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+MemoryBlock::MemoryBlock() throw()
+ : data (0),
+ size (0)
+{
+}
+
+MemoryBlock::MemoryBlock (const int initialSize,
+ const bool initialiseToZero) throw()
+{
+ if (initialSize > 0)
+ {
+ size = initialSize;
+
+ if (initialiseToZero)
+ data = (char*) juce_calloc (initialSize);
+ else
+ data = (char*) juce_malloc (initialSize);
+ }
+ else
+ {
+ data = 0;
+ size = 0;
+ }
+}
+
+MemoryBlock::MemoryBlock (const MemoryBlock& other) throw()
+ : data (0),
+ size (other.size)
+{
+ if (size > 0)
+ {
+ jassert (other.data != 0);
+ data = (char*) juce_malloc (size);
+ memcpy (data, other.data, size);
+ }
+}
+
+MemoryBlock::MemoryBlock (const void* const dataToInitialiseFrom,
+ const int sizeInBytes) throw()
+ : data (0),
+ size (jmax (0, sizeInBytes))
+{
+ jassert (sizeInBytes >= 0);
+
+ if (size > 0)
+ {
+ jassert (dataToInitialiseFrom != 0); // non-zero size, but a zero pointer passed-in?
+
+ data = (char*) juce_malloc (size);
+
+ if (dataToInitialiseFrom != 0)
+ memcpy (data, dataToInitialiseFrom, size);
+ }
+}
+
+MemoryBlock::~MemoryBlock() throw()
+{
+ jassert (size >= 0); // should never happen
+ jassert (size == 0 || data != 0); // non-zero size but no data allocated?
+
+ juce_free (data);
+}
+
+const MemoryBlock& MemoryBlock::operator= (const MemoryBlock& other) throw()
+{
+ if (this != &other)
+ {
+ setSize (other.size, false);
+ memcpy (data, other.data, size);
+ }
+
+ return *this;
+}
+
+bool MemoryBlock::operator== (const MemoryBlock& other) const throw()
+{
+ return (size == other.size)
+ && (memcmp (data, other.data, size) == 0);
+}
+
+bool MemoryBlock::operator!= (const MemoryBlock& other) const throw()
+{
+ return ! operator== (other);
+}
+
+// this will resize the block to this size
+void MemoryBlock::setSize (const int newSize,
+ const bool initialiseToZero) throw()
+{
+ if (size != newSize)
+ {
+ if (newSize <= 0)
+ {
+ juce_free (data);
+ data = 0;
+ size = 0;
+ }
+ else
+ {
+ if (data != 0)
+ {
+ data = (char*) juce_realloc (data, newSize);
+
+ if (initialiseToZero && (newSize > size))
+ zeromem (data + size, newSize - size);
+ }
+ else
+ {
+ if (initialiseToZero)
+ data = (char*) juce_calloc (newSize);
+ else
+ data = (char*) juce_malloc (newSize);
+ }
+
+ size = newSize;
+ }
+ }
+}
+
+void MemoryBlock::ensureSize (const int minimumSize,
+ const bool initialiseToZero) throw()
+{
+ if (size < minimumSize)
+ setSize (minimumSize, initialiseToZero);
+}
+
+void MemoryBlock::fillWith (const uint8 value) throw()
+{
+ memset (data, (int) value, size);
+}
+
+void MemoryBlock::append (const void* const srcData,
+ const int numBytes) throw()
+{
+ if (numBytes > 0)
+ {
+ const int oldSize = size;
+ setSize (size + numBytes);
+ memcpy (data + oldSize, srcData, numBytes);
+ }
+}
+
+void MemoryBlock::copyFrom (const void* const src, int offset, int num) throw()
+{
+ const char* d = (const char*) src;
+
+ if (offset < 0)
+ {
+ d -= offset;
+ num -= offset;
+ offset = 0;
+ }
+
+ if (offset + num > size)
+ num = size - offset;
+
+ if (num > 0)
+ memcpy (data + offset, d, num);
+}
+
+void MemoryBlock::copyTo (void* const dst, int offset, int num) const throw()
+{
+ char* d = (char*) dst;
+
+ if (offset < 0)
+ {
+ zeromem (d, -offset);
+ d -= offset;
+
+ num += offset;
+ offset = 0;
+ }
+
+ if (offset + num > size)
+ {
+ const int newNum = size - offset;
+ zeromem (d + newNum, num - newNum);
+ num = newNum;
+ }
+
+ if (num > 0)
+ memcpy (d, data + offset, num);
+}
+
+void MemoryBlock::removeSection (int startByte, int numBytesToRemove) throw()
+{
+ if (startByte < 0)
+ {
+ numBytesToRemove += startByte;
+ startByte = 0;
+ }
+
+ if (startByte + numBytesToRemove >= size)
+ {
+ setSize (startByte);
+ }
+ else if (numBytesToRemove > 0)
+ {
+ memmove (data + startByte,
+ data + startByte + numBytesToRemove,
+ size - (startByte + numBytesToRemove));
+
+ setSize (size - numBytesToRemove);
+ }
+}
+
+const String MemoryBlock::toString() const throw()
+{
+ return String (data, size);
+}
+
+int MemoryBlock::getBitRange (const int bitRangeStart, int numBits) const throw()
+{
+ int res = 0;
+
+ int byte = bitRangeStart >> 3;
+ int offsetInByte = bitRangeStart & 7;
+ int bitsSoFar = 0;
+
+ while (numBits > 0 && byte < size)
+ {
+ const int bitsThisTime = jmin (numBits, 8 - offsetInByte);
+ const int mask = (0xff >> (8 - bitsThisTime)) << offsetInByte;
+
+ res |= (((data[byte] & mask) >> offsetInByte) << bitsSoFar);
+
+ bitsSoFar += bitsThisTime;
+ numBits -= bitsThisTime;
+ ++byte;
+ offsetInByte = 0;
+ }
+
+ return res;
+}
+
+void MemoryBlock::setBitRange (const int bitRangeStart, int numBits, int bitsToSet) throw()
+{
+ int byte = bitRangeStart >> 3;
+ int offsetInByte = bitRangeStart & 7;
+ unsigned int mask = ~((((unsigned int)0xffffffff) << (32 - numBits)) >> (32 - numBits));
+
+ while (numBits > 0 && byte < size)
+ {
+ const int bitsThisTime = jmin (numBits, 8 - offsetInByte);
+
+ const unsigned int tempMask = (mask << offsetInByte) | ~((((unsigned int)0xffffffff) >> offsetInByte) << offsetInByte);
+ const unsigned int tempBits = bitsToSet << offsetInByte;
+
+ data[byte] = (char)((data[byte] & tempMask) | tempBits);
+
+ ++byte;
+ numBits -= bitsThisTime;
+ bitsToSet >>= bitsThisTime;
+ mask >>= bitsThisTime;
+ offsetInByte = 0;
+ }
+}
+
+void MemoryBlock::loadFromHexString (const String& hex) throw()
+{
+ ensureSize (hex.length() >> 1);
+ char* dest = data;
+ int i = 0;
+
+ for (;;)
+ {
+ int byte = 0;
+
+ for (int loop = 2; --loop >= 0;)
+ {
+ byte <<= 4;
+
+ for (;;)
+ {
+ const tchar c = hex [i++];
+
+ if (c >= T('0') && c <= T('9'))
+ {
+ byte |= c - T('0');
+ break;
+ }
+ else if (c >= T('a') && c <= T('z'))
+ {
+ byte |= c - (T('a') - 10);
+ break;
+ }
+ else if (c >= T('A') && c <= T('Z'))
+ {
+ byte |= c - (T('A') - 10);
+ break;
+ }
+ else if (c == 0)
+ {
+ setSize ((int) (dest - data));
+ return;
+ }
+ }
+ }
+
+ *dest++ = (char) byte;
+ }
+}
+
+static const char* const encodingTable
+ = ".ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+";
+
+const String MemoryBlock::toBase64Encoding() const throw()
+{
+ const int numChars = ((size << 3) + 5) / 6;
+
+ String destString (size); // store the length, followed by a '.', and then the data.
+ const int initialLen = destString.length();
+ destString.preallocateStorage (initialLen + 2 + numChars);
+
+ tchar* d = const_cast (((const tchar*) destString) + initialLen);
+ *d++ = T('.');
+
+ for (int i = 0; i < numChars; ++i)
+ *d++ = encodingTable [getBitRange (i * 6, 6)];
+
+ *d++ = 0;
+
+ return destString;
+}
+
+bool MemoryBlock::fromBase64Encoding (const String& s) throw()
+{
+ const int startPos = s.indexOfChar (T('.')) + 1;
+
+ if (startPos <= 0)
+ return false;
+
+ const int numBytesNeeded = s.substring (0, startPos - 1).getIntValue();
+
+ setSize (numBytesNeeded, true);
+
+ const int numChars = s.length() - startPos;
+ const tchar* const srcChars = ((const tchar*) s) + startPos;
+
+ for (int i = 0; i < numChars; ++i)
+ {
+ const char c = (char) srcChars[i];
+
+ for (int j = 0; j < 64; ++j)
+ {
+ if (encodingTable[j] == c)
+ {
+ setBitRange (i * 6, 6, j);
+ break;
+ }
+ }
+ }
+
+ return true;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_MemoryBlock.cpp *********/
+
+/********* Start of inlined file: juce_PropertySet.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+PropertySet::PropertySet (const bool ignoreCaseOfKeyNames) throw()
+ : properties (ignoreCaseOfKeyNames),
+ fallbackProperties (0),
+ ignoreCaseOfKeys (ignoreCaseOfKeyNames)
+{
+}
+
+PropertySet::PropertySet (const PropertySet& other) throw()
+ : properties (other.properties),
+ fallbackProperties (other.fallbackProperties),
+ ignoreCaseOfKeys (other.ignoreCaseOfKeys)
+{
+}
+
+const PropertySet& PropertySet::operator= (const PropertySet& other) throw()
+{
+ properties = other.properties;
+ fallbackProperties = other.fallbackProperties;
+ ignoreCaseOfKeys = other.ignoreCaseOfKeys;
+
+ propertyChanged();
+ return *this;
+}
+
+PropertySet::~PropertySet()
+{
+}
+
+void PropertySet::clear()
+{
+ const ScopedLock sl (lock);
+
+ if (properties.size() > 0)
+ {
+ properties.clear();
+ propertyChanged();
+ }
+}
+
+const String PropertySet::getValue (const String& keyName,
+ const String& defaultValue) const throw()
+{
+ const ScopedLock sl (lock);
+
+ const int index = properties.getAllKeys().indexOf (keyName, ignoreCaseOfKeys);
+
+ if (index >= 0)
+ return properties.getAllValues() [index];
+
+ return fallbackProperties != 0 ? fallbackProperties->getValue (keyName, defaultValue)
+ : defaultValue;
+}
+
+int PropertySet::getIntValue (const String& keyName,
+ const int defaultValue) const throw()
+{
+ const ScopedLock sl (lock);
+ const int index = properties.getAllKeys().indexOf (keyName, ignoreCaseOfKeys);
+
+ if (index >= 0)
+ return properties.getAllValues() [index].getIntValue();
+
+ return fallbackProperties != 0 ? fallbackProperties->getIntValue (keyName, defaultValue)
+ : defaultValue;
+}
+
+double PropertySet::getDoubleValue (const String& keyName,
+ const double defaultValue) const throw()
+{
+ const ScopedLock sl (lock);
+ const int index = properties.getAllKeys().indexOf (keyName, ignoreCaseOfKeys);
+
+ if (index >= 0)
+ return properties.getAllValues()[index].getDoubleValue();
+
+ return fallbackProperties != 0 ? fallbackProperties->getDoubleValue (keyName, defaultValue)
+ : defaultValue;
+}
+
+bool PropertySet::getBoolValue (const String& keyName,
+ const bool defaultValue) const throw()
+{
+ const ScopedLock sl (lock);
+ const int index = properties.getAllKeys().indexOf (keyName, ignoreCaseOfKeys);
+
+ if (index >= 0)
+ return properties.getAllValues() [index].getIntValue() != 0;
+
+ return fallbackProperties != 0 ? fallbackProperties->getBoolValue (keyName, defaultValue)
+ : defaultValue;
+}
+
+XmlElement* PropertySet::getXmlValue (const String& keyName) const
+{
+ XmlDocument doc (getValue (keyName));
+
+ return doc.getDocumentElement();
+}
+
+void PropertySet::setValue (const String& keyName,
+ const String& value) throw()
+{
+ jassert (keyName.isNotEmpty()); // shouldn't use an empty key name!
+
+ if (keyName.isNotEmpty())
+ {
+ const ScopedLock sl (lock);
+
+ const int index = properties.getAllKeys().indexOf (keyName, ignoreCaseOfKeys);
+
+ if (index < 0 || properties.getAllValues() [index] != value)
+ {
+ properties.set (keyName, value);
+ propertyChanged();
+ }
+ }
+}
+
+void PropertySet::removeValue (const String& keyName) throw()
+{
+ if (keyName.isNotEmpty())
+ {
+ const ScopedLock sl (lock);
+ const int index = properties.getAllKeys().indexOf (keyName, ignoreCaseOfKeys);
+
+ if (index >= 0)
+ {
+ properties.remove (keyName);
+ propertyChanged();
+ }
+ }
+}
+
+void PropertySet::setValue (const String& keyName, const tchar* const value) throw()
+{
+ setValue (keyName, String (value));
+}
+
+void PropertySet::setValue (const String& keyName, const int value) throw()
+{
+ setValue (keyName, String (value));
+}
+
+void PropertySet::setValue (const String& keyName, const double value) throw()
+{
+ setValue (keyName, String (value));
+}
+
+void PropertySet::setValue (const String& keyName, const bool value) throw()
+{
+ setValue (keyName, String ((value) ? T("1") : T("0")));
+}
+
+void PropertySet::setValue (const String& keyName, const XmlElement* const xml)
+{
+ setValue (keyName, (xml == 0) ? String::empty
+ : xml->createDocument (String::empty, true));
+}
+
+bool PropertySet::containsKey (const String& keyName) const throw()
+{
+ const ScopedLock sl (lock);
+ return properties.getAllKeys().contains (keyName, ignoreCaseOfKeys);
+}
+
+void PropertySet::setFallbackPropertySet (PropertySet* fallbackProperties_) throw()
+{
+ const ScopedLock sl (lock);
+ fallbackProperties = fallbackProperties_;
+}
+
+XmlElement* PropertySet::createXml (const String& nodeName) const throw()
+{
+ const ScopedLock sl (lock);
+ XmlElement* const xml = new XmlElement (nodeName);
+
+ for (int i = 0; i < properties.getAllKeys().size(); ++i)
+ {
+ XmlElement* const e = new XmlElement (T("VALUE"));
+
+ e->setAttribute (T("name"), properties.getAllKeys()[i]);
+ e->setAttribute (T("val"), properties.getAllValues()[i]);
+
+ xml->addChildElement (e);
+ }
+
+ return xml;
+}
+
+void PropertySet::restoreFromXml (const XmlElement& xml) throw()
+{
+ const ScopedLock sl (lock);
+ clear();
+
+ forEachXmlChildElementWithTagName (xml, e, T("VALUE"))
+ {
+ if (e->hasAttribute (T("name"))
+ && e->hasAttribute (T("val")))
+ {
+ properties.set (e->getStringAttribute (T("name")),
+ e->getStringAttribute (T("val")));
+ }
+ }
+
+ if (properties.size() > 0)
+ propertyChanged();
+}
+
+void PropertySet::propertyChanged()
+{
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_PropertySet.cpp *********/
+
+/********* Start of inlined file: juce_BlowFish.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+static const uint32 initialPValues [18] =
+{
+ 0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
+ 0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
+ 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
+ 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
+ 0x9216d5d9, 0x8979fb1b
+};
+
+static const uint32 initialSValues [4 * 256] =
+{
+ 0xd1310ba6, 0x98dfb5ac, 0x2ffd72db, 0xd01adfb7,
+ 0xb8e1afed, 0x6a267e96, 0xba7c9045, 0xf12c7f99,
+ 0x24a19947, 0xb3916cf7, 0x0801f2e2, 0x858efc16,
+ 0x636920d8, 0x71574e69, 0xa458fea3, 0xf4933d7e,
+ 0x0d95748f, 0x728eb658, 0x718bcd58, 0x82154aee,
+ 0x7b54a41d, 0xc25a59b5, 0x9c30d539, 0x2af26013,
+ 0xc5d1b023, 0x286085f0, 0xca417918, 0xb8db38ef,
+ 0x8e79dcb0, 0x603a180e, 0x6c9e0e8b, 0xb01e8a3e,
+ 0xd71577c1, 0xbd314b27, 0x78af2fda, 0x55605c60,
+ 0xe65525f3, 0xaa55ab94, 0x57489862, 0x63e81440,
+ 0x55ca396a, 0x2aab10b6, 0xb4cc5c34, 0x1141e8ce,
+ 0xa15486af, 0x7c72e993, 0xb3ee1411, 0x636fbc2a,
+ 0x2ba9c55d, 0x741831f6, 0xce5c3e16, 0x9b87931e,
+ 0xafd6ba33, 0x6c24cf5c, 0x7a325381, 0x28958677,
+ 0x3b8f4898, 0x6b4bb9af, 0xc4bfe81b, 0x66282193,
+ 0x61d809cc, 0xfb21a991, 0x487cac60, 0x5dec8032,
+ 0xef845d5d, 0xe98575b1, 0xdc262302, 0xeb651b88,
+ 0x23893e81, 0xd396acc5, 0x0f6d6ff3, 0x83f44239,
+ 0x2e0b4482, 0xa4842004, 0x69c8f04a, 0x9e1f9b5e,
+ 0x21c66842, 0xf6e96c9a, 0x670c9c61, 0xabd388f0,
+ 0x6a51a0d2, 0xd8542f68, 0x960fa728, 0xab5133a3,
+ 0x6eef0b6c, 0x137a3be4, 0xba3bf050, 0x7efb2a98,
+ 0xa1f1651d, 0x39af0176, 0x66ca593e, 0x82430e88,
+ 0x8cee8619, 0x456f9fb4, 0x7d84a5c3, 0x3b8b5ebe,
+ 0xe06f75d8, 0x85c12073, 0x401a449f, 0x56c16aa6,
+ 0x4ed3aa62, 0x363f7706, 0x1bfedf72, 0x429b023d,
+ 0x37d0d724, 0xd00a1248, 0xdb0fead3, 0x49f1c09b,
+ 0x075372c9, 0x80991b7b, 0x25d479d8, 0xf6e8def7,
+ 0xe3fe501a, 0xb6794c3b, 0x976ce0bd, 0x04c006ba,
+ 0xc1a94fb6, 0x409f60c4, 0x5e5c9ec2, 0x196a2463,
+ 0x68fb6faf, 0x3e6c53b5, 0x1339b2eb, 0x3b52ec6f,
+ 0x6dfc511f, 0x9b30952c, 0xcc814544, 0xaf5ebd09,
+ 0xbee3d004, 0xde334afd, 0x660f2807, 0x192e4bb3,
+ 0xc0cba857, 0x45c8740f, 0xd20b5f39, 0xb9d3fbdb,
+ 0x5579c0bd, 0x1a60320a, 0xd6a100c6, 0x402c7279,
+ 0x679f25fe, 0xfb1fa3cc, 0x8ea5e9f8, 0xdb3222f8,
+ 0x3c7516df, 0xfd616b15, 0x2f501ec8, 0xad0552ab,
+ 0x323db5fa, 0xfd238760, 0x53317b48, 0x3e00df82,
+ 0x9e5c57bb, 0xca6f8ca0, 0x1a87562e, 0xdf1769db,
+ 0xd542a8f6, 0x287effc3, 0xac6732c6, 0x8c4f5573,
+ 0x695b27b0, 0xbbca58c8, 0xe1ffa35d, 0xb8f011a0,
+ 0x10fa3d98, 0xfd2183b8, 0x4afcb56c, 0x2dd1d35b,
+ 0x9a53e479, 0xb6f84565, 0xd28e49bc, 0x4bfb9790,
+ 0xe1ddf2da, 0xa4cb7e33, 0x62fb1341, 0xcee4c6e8,
+ 0xef20cada, 0x36774c01, 0xd07e9efe, 0x2bf11fb4,
+ 0x95dbda4d, 0xae909198, 0xeaad8e71, 0x6b93d5a0,
+ 0xd08ed1d0, 0xafc725e0, 0x8e3c5b2f, 0x8e7594b7,
+ 0x8ff6e2fb, 0xf2122b64, 0x8888b812, 0x900df01c,
+ 0x4fad5ea0, 0x688fc31c, 0xd1cff191, 0xb3a8c1ad,
+ 0x2f2f2218, 0xbe0e1777, 0xea752dfe, 0x8b021fa1,
+ 0xe5a0cc0f, 0xb56f74e8, 0x18acf3d6, 0xce89e299,
+ 0xb4a84fe0, 0xfd13e0b7, 0x7cc43b81, 0xd2ada8d9,
+ 0x165fa266, 0x80957705, 0x93cc7314, 0x211a1477,
+ 0xe6ad2065, 0x77b5fa86, 0xc75442f5, 0xfb9d35cf,
+ 0xebcdaf0c, 0x7b3e89a0, 0xd6411bd3, 0xae1e7e49,
+ 0x00250e2d, 0x2071b35e, 0x226800bb, 0x57b8e0af,
+ 0x2464369b, 0xf009b91e, 0x5563911d, 0x59dfa6aa,
+ 0x78c14389, 0xd95a537f, 0x207d5ba2, 0x02e5b9c5,
+ 0x83260376, 0x6295cfa9, 0x11c81968, 0x4e734a41,
+ 0xb3472dca, 0x7b14a94a, 0x1b510052, 0x9a532915,
+ 0xd60f573f, 0xbc9bc6e4, 0x2b60a476, 0x81e67400,
+ 0x08ba6fb5, 0x571be91f, 0xf296ec6b, 0x2a0dd915,
+ 0xb6636521, 0xe7b9f9b6, 0xff34052e, 0xc5855664,
+ 0x53b02d5d, 0xa99f8fa1, 0x08ba4799, 0x6e85076a,
+ 0x4b7a70e9, 0xb5b32944, 0xdb75092e, 0xc4192623,
+ 0xad6ea6b0, 0x49a7df7d, 0x9cee60b8, 0x8fedb266,
+ 0xecaa8c71, 0x699a17ff, 0x5664526c, 0xc2b19ee1,
+ 0x193602a5, 0x75094c29, 0xa0591340, 0xe4183a3e,
+ 0x3f54989a, 0x5b429d65, 0x6b8fe4d6, 0x99f73fd6,
+ 0xa1d29c07, 0xefe830f5, 0x4d2d38e6, 0xf0255dc1,
+ 0x4cdd2086, 0x8470eb26, 0x6382e9c6, 0x021ecc5e,
+ 0x09686b3f, 0x3ebaefc9, 0x3c971814, 0x6b6a70a1,
+ 0x687f3584, 0x52a0e286, 0xb79c5305, 0xaa500737,
+ 0x3e07841c, 0x7fdeae5c, 0x8e7d44ec, 0x5716f2b8,
+ 0xb03ada37, 0xf0500c0d, 0xf01c1f04, 0x0200b3ff,
+ 0xae0cf51a, 0x3cb574b2, 0x25837a58, 0xdc0921bd,
+ 0xd19113f9, 0x7ca92ff6, 0x94324773, 0x22f54701,
+ 0x3ae5e581, 0x37c2dadc, 0xc8b57634, 0x9af3dda7,
+ 0xa9446146, 0x0fd0030e, 0xecc8c73e, 0xa4751e41,
+ 0xe238cd99, 0x3bea0e2f, 0x3280bba1, 0x183eb331,
+ 0x4e548b38, 0x4f6db908, 0x6f420d03, 0xf60a04bf,
+ 0x2cb81290, 0x24977c79, 0x5679b072, 0xbcaf89af,
+ 0xde9a771f, 0xd9930810, 0xb38bae12, 0xdccf3f2e,
+ 0x5512721f, 0x2e6b7124, 0x501adde6, 0x9f84cd87,
+ 0x7a584718, 0x7408da17, 0xbc9f9abc, 0xe94b7d8c,
+ 0xec7aec3a, 0xdb851dfa, 0x63094366, 0xc464c3d2,
+ 0xef1c1847, 0x3215d908, 0xdd433b37, 0x24c2ba16,
+ 0x12a14d43, 0x2a65c451, 0x50940002, 0x133ae4dd,
+ 0x71dff89e, 0x10314e55, 0x81ac77d6, 0x5f11199b,
+ 0x043556f1, 0xd7a3c76b, 0x3c11183b, 0x5924a509,
+ 0xf28fe6ed, 0x97f1fbfa, 0x9ebabf2c, 0x1e153c6e,
+ 0x86e34570, 0xeae96fb1, 0x860e5e0a, 0x5a3e2ab3,
+ 0x771fe71c, 0x4e3d06fa, 0x2965dcb9, 0x99e71d0f,
+ 0x803e89d6, 0x5266c825, 0x2e4cc978, 0x9c10b36a,
+ 0xc6150eba, 0x94e2ea78, 0xa5fc3c53, 0x1e0a2df4,
+ 0xf2f74ea7, 0x361d2b3d, 0x1939260f, 0x19c27960,
+ 0x5223a708, 0xf71312b6, 0xebadfe6e, 0xeac31f66,
+ 0xe3bc4595, 0xa67bc883, 0xb17f37d1, 0x018cff28,
+ 0xc332ddef, 0xbe6c5aa5, 0x65582185, 0x68ab9802,
+ 0xeecea50f, 0xdb2f953b, 0x2aef7dad, 0x5b6e2f84,
+ 0x1521b628, 0x29076170, 0xecdd4775, 0x619f1510,
+ 0x13cca830, 0xeb61bd96, 0x0334fe1e, 0xaa0363cf,
+ 0xb5735c90, 0x4c70a239, 0xd59e9e0b, 0xcbaade14,
+ 0xeecc86bc, 0x60622ca7, 0x9cab5cab, 0xb2f3846e,
+ 0x648b1eaf, 0x19bdf0ca, 0xa02369b9, 0x655abb50,
+ 0x40685a32, 0x3c2ab4b3, 0x319ee9d5, 0xc021b8f7,
+ 0x9b540b19, 0x875fa099, 0x95f7997e, 0x623d7da8,
+ 0xf837889a, 0x97e32d77, 0x11ed935f, 0x16681281,
+ 0x0e358829, 0xc7e61fd6, 0x96dedfa1, 0x7858ba99,
+ 0x57f584a5, 0x1b227263, 0x9b83c3ff, 0x1ac24696,
+ 0xcdb30aeb, 0x532e3054, 0x8fd948e4, 0x6dbc3128,
+ 0x58ebf2ef, 0x34c6ffea, 0xfe28ed61, 0xee7c3c73,
+ 0x5d4a14d9, 0xe864b7e3, 0x42105d14, 0x203e13e0,
+ 0x45eee2b6, 0xa3aaabea, 0xdb6c4f15, 0xfacb4fd0,
+ 0xc742f442, 0xef6abbb5, 0x654f3b1d, 0x41cd2105,
+ 0xd81e799e, 0x86854dc7, 0xe44b476a, 0x3d816250,
+ 0xcf62a1f2, 0x5b8d2646, 0xfc8883a0, 0xc1c7b6a3,
+ 0x7f1524c3, 0x69cb7492, 0x47848a0b, 0x5692b285,
+ 0x095bbf00, 0xad19489d, 0x1462b174, 0x23820e00,
+ 0x58428d2a, 0x0c55f5ea, 0x1dadf43e, 0x233f7061,
+ 0x3372f092, 0x8d937e41, 0xd65fecf1, 0x6c223bdb,
+ 0x7cde3759, 0xcbee7460, 0x4085f2a7, 0xce77326e,
+ 0xa6078084, 0x19f8509e, 0xe8efd855, 0x61d99735,
+ 0xa969a7aa, 0xc50c06c2, 0x5a04abfc, 0x800bcadc,
+ 0x9e447a2e, 0xc3453484, 0xfdd56705, 0x0e1e9ec9,
+ 0xdb73dbd3, 0x105588cd, 0x675fda79, 0xe3674340,
+ 0xc5c43465, 0x713e38d8, 0x3d28f89e, 0xf16dff20,
+ 0x153e21e7, 0x8fb03d4a, 0xe6e39f2b, 0xdb83adf7,
+ 0xe93d5a68, 0x948140f7, 0xf64c261c, 0x94692934,
+ 0x411520f7, 0x7602d4f7, 0xbcf46b2e, 0xd4a20068,
+ 0xd4082471, 0x3320f46a, 0x43b7d4b7, 0x500061af,
+ 0x1e39f62e, 0x97244546, 0x14214f74, 0xbf8b8840,
+ 0x4d95fc1d, 0x96b591af, 0x70f4ddd3, 0x66a02f45,
+ 0xbfbc09ec, 0x03bd9785, 0x7fac6dd0, 0x31cb8504,
+ 0x96eb27b3, 0x55fd3941, 0xda2547e6, 0xabca0a9a,
+ 0x28507825, 0x530429f4, 0x0a2c86da, 0xe9b66dfb,
+ 0x68dc1462, 0xd7486900, 0x680ec0a4, 0x27a18dee,
+ 0x4f3ffea2, 0xe887ad8c, 0xb58ce006, 0x7af4d6b6,
+ 0xaace1e7c, 0xd3375fec, 0xce78a399, 0x406b2a42,
+ 0x20fe9e35, 0xd9f385b9, 0xee39d7ab, 0x3b124e8b,
+ 0x1dc9faf7, 0x4b6d1856, 0x26a36631, 0xeae397b2,
+ 0x3a6efa74, 0xdd5b4332, 0x6841e7f7, 0xca7820fb,
+ 0xfb0af54e, 0xd8feb397, 0x454056ac, 0xba489527,
+ 0x55533a3a, 0x20838d87, 0xfe6ba9b7, 0xd096954b,
+ 0x55a867bc, 0xa1159a58, 0xcca92963, 0x99e1db33,
+ 0xa62a4a56, 0x3f3125f9, 0x5ef47e1c, 0x9029317c,
+ 0xfdf8e802, 0x04272f70, 0x80bb155c, 0x05282ce3,
+ 0x95c11548, 0xe4c66d22, 0x48c1133f, 0xc70f86dc,
+ 0x07f9c9ee, 0x41041f0f, 0x404779a4, 0x5d886e17,
+ 0x325f51eb, 0xd59bc0d1, 0xf2bcc18f, 0x41113564,
+ 0x257b7834, 0x602a9c60, 0xdff8e8a3, 0x1f636c1b,
+ 0x0e12b4c2, 0x02e1329e, 0xaf664fd1, 0xcad18115,
+ 0x6b2395e0, 0x333e92e1, 0x3b240b62, 0xeebeb922,
+ 0x85b2a20e, 0xe6ba0d99, 0xde720c8c, 0x2da2f728,
+ 0xd0127845, 0x95b794fd, 0x647d0862, 0xe7ccf5f0,
+ 0x5449a36f, 0x877d48fa, 0xc39dfd27, 0xf33e8d1e,
+ 0x0a476341, 0x992eff74, 0x3a6f6eab, 0xf4f8fd37,
+ 0xa812dc60, 0xa1ebddf8, 0x991be14c, 0xdb6e6b0d,
+ 0xc67b5510, 0x6d672c37, 0x2765d43b, 0xdcd0e804,
+ 0xf1290dc7, 0xcc00ffa3, 0xb5390f92, 0x690fed0b,
+ 0x667b9ffb, 0xcedb7d9c, 0xa091cf0b, 0xd9155ea3,
+ 0xbb132f88, 0x515bad24, 0x7b9479bf, 0x763bd6eb,
+ 0x37392eb3, 0xcc115979, 0x8026e297, 0xf42e312d,
+ 0x6842ada7, 0xc66a2b3b, 0x12754ccc, 0x782ef11c,
+ 0x6a124237, 0xb79251e7, 0x06a1bbe6, 0x4bfb6350,
+ 0x1a6b1018, 0x11caedfa, 0x3d25bdd8, 0xe2e1c3c9,
+ 0x44421659, 0x0a121386, 0xd90cec6e, 0xd5abea2a,
+ 0x64af674e, 0xda86a85f, 0xbebfe988, 0x64e4c3fe,
+ 0x9dbc8057, 0xf0f7c086, 0x60787bf8, 0x6003604d,
+ 0xd1fd8346, 0xf6381fb0, 0x7745ae04, 0xd736fccc,
+ 0x83426b33, 0xf01eab71, 0xb0804187, 0x3c005e5f,
+ 0x77a057be, 0xbde8ae24, 0x55464299, 0xbf582e61,
+ 0x4e58f48f, 0xf2ddfda2, 0xf474ef38, 0x8789bdc2,
+ 0x5366f9c3, 0xc8b38e74, 0xb475f255, 0x46fcd9b9,
+ 0x7aeb2661, 0x8b1ddf84, 0x846a0e79, 0x915f95e2,
+ 0x466e598e, 0x20b45770, 0x8cd55591, 0xc902de4c,
+ 0xb90bace1, 0xbb8205d0, 0x11a86248, 0x7574a99e,
+ 0xb77f19b6, 0xe0a9dc09, 0x662d09a1, 0xc4324633,
+ 0xe85a1f02, 0x09f0be8c, 0x4a99a025, 0x1d6efe10,
+ 0x1ab93d1d, 0x0ba5a4df, 0xa186f20f, 0x2868f169,
+ 0xdcb7da83, 0x573906fe, 0xa1e2ce9b, 0x4fcd7f52,
+ 0x50115e01, 0xa70683fa, 0xa002b5c4, 0x0de6d027,
+ 0x9af88c27, 0x773f8641, 0xc3604c06, 0x61a806b5,
+ 0xf0177a28, 0xc0f586e0, 0x006058aa, 0x30dc7d62,
+ 0x11e69ed7, 0x2338ea63, 0x53c2dd94, 0xc2c21634,
+ 0xbbcbee56, 0x90bcb6de, 0xebfc7da1, 0xce591d76,
+ 0x6f05e409, 0x4b7c0188, 0x39720a3d, 0x7c927c24,
+ 0x86e3725f, 0x724d9db9, 0x1ac15bb4, 0xd39eb8fc,
+ 0xed545578, 0x08fca5b5, 0xd83d7cd3, 0x4dad0fc4,
+ 0x1e50ef5e, 0xb161e6f8, 0xa28514d9, 0x6c51133c,
+ 0x6fd5c7e7, 0x56e14ec4, 0x362abfce, 0xddc6c837,
+ 0xd79a3234, 0x92638212, 0x670efa8e, 0x406000e0,
+ 0x3a39ce37, 0xd3faf5cf, 0xabc27737, 0x5ac52d1b,
+ 0x5cb0679e, 0x4fa33742, 0xd3822740, 0x99bc9bbe,
+ 0xd5118e9d, 0xbf0f7315, 0xd62d1c7e, 0xc700c47b,
+ 0xb78c1b6b, 0x21a19045, 0xb26eb1be, 0x6a366eb4,
+ 0x5748ab2f, 0xbc946e79, 0xc6a376d2, 0x6549c2c8,
+ 0x530ff8ee, 0x468dde7d, 0xd5730a1d, 0x4cd04dc6,
+ 0x2939bbdb, 0xa9ba4650, 0xac9526e8, 0xbe5ee304,
+ 0xa1fad5f0, 0x6a2d519a, 0x63ef8ce2, 0x9a86ee22,
+ 0xc089c2b8, 0x43242ef6, 0xa51e03aa, 0x9cf2d0a4,
+ 0x83c061ba, 0x9be96a4d, 0x8fe51550, 0xba645bd6,
+ 0x2826a2f9, 0xa73a3ae1, 0x4ba99586, 0xef5562e9,
+ 0xc72fefd3, 0xf752f7da, 0x3f046f69, 0x77fa0a59,
+ 0x80e4a915, 0x87b08601, 0x9b09e6ad, 0x3b3ee593,
+ 0xe990fd5a, 0x9e34d797, 0x2cf0b7d9, 0x022b8b51,
+ 0x96d5ac3a, 0x017da67d, 0xd1cf3ed6, 0x7c7d2d28,
+ 0x1f9f25cf, 0xadf2b89b, 0x5ad6b472, 0x5a88f54c,
+ 0xe029ac71, 0xe019a5e6, 0x47b0acfd, 0xed93fa9b,
+ 0xe8d3c48d, 0x283b57cc, 0xf8d56629, 0x79132e28,
+ 0x785f0191, 0xed756055, 0xf7960e44, 0xe3d35e8c,
+ 0x15056dd4, 0x88f46dba, 0x03a16125, 0x0564f0bd,
+ 0xc3eb9e15, 0x3c9057a2, 0x97271aec, 0xa93a072a,
+ 0x1b3f6d9b, 0x1e6321f5, 0xf59c66fb, 0x26dcf319,
+ 0x7533d928, 0xb155fdf5, 0x03563482, 0x8aba3cbb,
+ 0x28517711, 0xc20ad9f8, 0xabcc5167, 0xccad925f,
+ 0x4de81751, 0x3830dc8e, 0x379d5862, 0x9320f991,
+ 0xea7a90c2, 0xfb3e7bce, 0x5121ce64, 0x774fbe32,
+ 0xa8b6e37e, 0xc3293d46, 0x48de5369, 0x6413e680,
+ 0xa2ae0810, 0xdd6db224, 0x69852dfd, 0x09072166,
+ 0xb39a460a, 0x6445c0dd, 0x586cdecf, 0x1c20c8ae,
+ 0x5bbef7dd, 0x1b588d40, 0xccd2017f, 0x6bb4e3bb,
+ 0xdda26a7e, 0x3a59ff45, 0x3e350a44, 0xbcb4cdd5,
+ 0x72eacea8, 0xfa6484bb, 0x8d6612ae, 0xbf3c6f47,
+ 0xd29be463, 0x542f5d9e, 0xaec2771b, 0xf64e6370,
+ 0x740e0d8d, 0xe75b1357, 0xf8721671, 0xaf537d5d,
+ 0x4040cb08, 0x4eb4e2cc, 0x34d2466a, 0x0115af84,
+ 0xe1b00428, 0x95983a1d, 0x06b89fb4, 0xce6ea048,
+ 0x6f3f3b82, 0x3520ab82, 0x011a1d4b, 0x277227f8,
+ 0x611560b1, 0xe7933fdc, 0xbb3a792b, 0x344525bd,
+ 0xa08839e1, 0x51ce794b, 0x2f32c9b7, 0xa01fbac9,
+ 0xe01cc87e, 0xbcc7d1f6, 0xcf0111c3, 0xa1e8aac7,
+ 0x1a908749, 0xd44fbd9a, 0xd0dadecb, 0xd50ada38,
+ 0x0339c32a, 0xc6913667, 0x8df9317c, 0xe0b12b4f,
+ 0xf79e59b7, 0x43f5bb3a, 0xf2d519ff, 0x27d9459c,
+ 0xbf97222c, 0x15e6fc2a, 0x0f91fc71, 0x9b941525,
+ 0xfae59361, 0xceb69ceb, 0xc2a86459, 0x12baa8d1,
+ 0xb6c1075e, 0xe3056a0c, 0x10d25065, 0xcb03a442,
+ 0xe0ec6e0e, 0x1698db3b, 0x4c98a0be, 0x3278e964,
+ 0x9f1f9532, 0xe0d392df, 0xd3a0342b, 0x8971f21e,
+ 0x1b0a7441, 0x4ba3348c, 0xc5be7120, 0xc37632d8,
+ 0xdf359f8d, 0x9b992f2e, 0xe60b6f47, 0x0fe3f11d,
+ 0xe54cda54, 0x1edad891, 0xce6279cf, 0xcd3e7e6f,
+ 0x1618b166, 0xfd2c1d05, 0x848fd2c5, 0xf6fb2299,
+ 0xf523f357, 0xa6327623, 0x93a83531, 0x56cccd02,
+ 0xacf08162, 0x5a75ebb5, 0x6e163697, 0x88d273cc,
+ 0xde966292, 0x81b949d0, 0x4c50901b, 0x71c65614,
+ 0xe6c6c7bd, 0x327a140a, 0x45e1d006, 0xc3f27b9a,
+ 0xc9aa53fd, 0x62a80f00, 0xbb25bfe2, 0x35bdd2f6,
+ 0x71126905, 0xb2040222, 0xb6cbcf7c, 0xcd769c2b,
+ 0x53113ec0, 0x1640e3d3, 0x38abbd60, 0x2547adf0,
+ 0xba38209c, 0xf746ce76, 0x77afa1c5, 0x20756060,
+ 0x85cbfe4e, 0x8ae88dd8, 0x7aaaf9b0, 0x4cf9aa7e,
+ 0x1948c25c, 0x02fb8a8c, 0x01c36ae4, 0xd6ebe1f9,
+ 0x90d4f869, 0xa65cdea0, 0x3f09252d, 0xc208e69f,
+ 0xb74e6132, 0xce77e25b, 0x578fdfe3, 0x3ac372e6
+};
+
+BlowFish::BlowFish (const uint8* keyData, int keyBytes)
+{
+ p = (uint32*) juce_malloc (18 * sizeof (uint32));
+ memcpy (p, initialPValues, sizeof (p));
+
+ int i, j;
+ for (i = 4; --i >= 0;)
+ {
+ s[i] = (uint32*) juce_malloc (256 * sizeof (uint32));
+ memcpy (s[i], initialSValues + i * 256, 256 * sizeof (uint32));
+ }
+
+ j = 0;
+
+ for (i = 0; i < 18; ++i)
+ {
+ uint32 d = 0;
+
+ for (int k = 0; k < 4; ++k)
+ {
+ d = (d << 8) | keyData[j];
+
+ if (++j >= keyBytes)
+ j = 0;
+ }
+
+ p[i] = initialPValues[i] ^ d;
+ }
+
+ uint32 l = 0, r = 0;
+
+ for (i = 0; i < 18; i += 2)
+ {
+ encrypt (l, r);
+
+ p[i] = l;
+ p[i + 1] = r;
+ }
+
+ for (i = 0; i < 4; ++i)
+ {
+ for (j = 0; j < 256; j += 2)
+ {
+ encrypt (l, r);
+
+ s[i][j] = l;
+ s[i][j + 1] = r;
+ }
+ }
+}
+
+BlowFish::~BlowFish()
+{
+ juce_free (p);
+
+ for (int i = 4; --i >= 0;)
+ juce_free (s[i]);
+}
+
+uint32 BlowFish::F (uint32 x) const
+{
+ uint16 a, b, c, d;
+ uint32 y;
+
+ d = (uint16) (x & 0xff);
+ x >>= 8;
+ c = (uint16) (x & 0xff);
+ x >>= 8;
+ b = (uint16) (x & 0xff);
+ x >>= 8;
+ a = (uint16) (x & 0xff);
+
+ y = s[0][a] + s[1][b];
+ y = y ^ s[2][c];
+ y = y + s[3][d];
+
+ return y;
+}
+
+void BlowFish::encrypt (uint32& data1,
+ uint32& data2) const
+{
+ uint32 l = data1;
+ uint32 r = data2;
+
+ for (int i = 0; i < 16; ++i)
+ {
+ l = l ^ p[i];
+ r = F (l) ^ r;
+
+ const uint32 temp = l;
+ l = r;
+ r = temp;
+ }
+
+ const uint32 temp = l;
+ l = r;
+ r = temp;
+
+ r = r ^ p[16];
+ l = l ^ p[17];
+
+ data1 = l;
+ data2 = r;
+}
+
+void BlowFish::decrypt (uint32& data1,
+ uint32& data2) const
+{
+ uint32 l = data1;
+ uint32 r = data2;
+
+ for (int i = 17; i > 1; --i)
+ {
+ l =l ^ p[i];
+ r = F (l) ^ r;
+
+ const uint32 temp = l;
+ l = r;
+ r = temp;
+ }
+
+ const uint32 temp = l;
+ l = r;
+ r = temp;
+
+ r = r ^ p[1];
+ l = l ^ p[0];
+
+ data1 = l;
+ data2 = r;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_BlowFish.cpp *********/
+
+/********* Start of inlined file: juce_MD5.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+MD5::MD5()
+{
+ zeromem (result, sizeof (result));
+}
+
+MD5::MD5 (const MD5& other)
+{
+ memcpy (result, other.result, sizeof (result));
+}
+
+const MD5& MD5::operator= (const MD5& other)
+{
+ memcpy (result, other.result, sizeof (result));
+ return *this;
+}
+
+MD5::MD5 (const MemoryBlock& data)
+{
+ ProcessContext context;
+ context.processBlock ((const uint8*) data.getData(), data.getSize());
+ context.finish (result);
+}
+
+MD5::MD5 (const char* data, const int numBytes)
+{
+ ProcessContext context;
+ context.processBlock ((const uint8*) data, numBytes);
+ context.finish (result);
+}
+
+MD5::MD5 (const String& text)
+{
+ ProcessContext context;
+
+ const int len = text.length();
+ const juce_wchar* const t = text;
+
+ for (int i = 0; i < len; ++i)
+ {
+ // force the string into integer-sized unicode characters, to try to make it
+ // get the same results on all platforms + compilers.
+ uint32 unicodeChar = (uint32) t[i];
+ swapIfBigEndian (unicodeChar);
+
+ context.processBlock ((const uint8*) &unicodeChar,
+ sizeof (unicodeChar));
+ }
+
+ context.finish (result);
+}
+
+void MD5::processStream (InputStream& input, int numBytesToRead)
+{
+ ProcessContext context;
+
+ if (numBytesToRead < 0)
+ numBytesToRead = INT_MAX;
+
+ while (numBytesToRead > 0)
+ {
+ char tempBuffer [512];
+ const int bytesRead = input.read (tempBuffer, jmin (numBytesToRead, sizeof (tempBuffer)));
+
+ if (bytesRead <= 0)
+ break;
+
+ numBytesToRead -= bytesRead;
+
+ context.processBlock ((const uint8*) tempBuffer, bytesRead);
+ }
+
+ context.finish (result);
+}
+
+MD5::MD5 (InputStream& input, int numBytesToRead)
+{
+ processStream (input, numBytesToRead);
+}
+
+MD5::MD5 (const File& file)
+{
+ FileInputStream* const fin = file.createInputStream();
+
+ if (fin != 0)
+ {
+ processStream (*fin, -1);
+ delete fin;
+ }
+ else
+ {
+ zeromem (result, sizeof (result));
+ }
+}
+
+MD5::~MD5()
+{
+}
+
+MD5::ProcessContext::ProcessContext()
+{
+ state[0] = 0x67452301;
+ state[1] = 0xefcdab89;
+ state[2] = 0x98badcfe;
+ state[3] = 0x10325476;
+
+ count[0] = 0;
+ count[1] = 0;
+}
+
+void MD5::ProcessContext::processBlock (const uint8* const data, int dataSize)
+{
+ int bufferPos = ((count[0] >> 3) & 0x3F);
+
+ count[0] += (dataSize << 3);
+
+ if (count[0] < ((uint32) dataSize << 3))
+ count[1]++;
+
+ count[1] += (dataSize >> 29);
+
+ const int spaceLeft = 64 - bufferPos;
+
+ int i = 0;
+
+ if (dataSize >= spaceLeft)
+ {
+ memcpy (buffer + bufferPos, data, spaceLeft);
+
+ transform (buffer);
+
+ i = spaceLeft;
+
+ while (i < dataSize - 63)
+ {
+ transform (data + i);
+ i += 64;
+ }
+
+ bufferPos = 0;
+ }
+
+ memcpy (buffer + bufferPos, data + i, dataSize - i);
+}
+
+static void encode (uint8* const output,
+ const uint32* const input,
+ const int numBytes)
+{
+ uint32* const o = (uint32*) output;
+
+ for (int i = 0; i < (numBytes >> 2); ++i)
+ o[i] = swapIfBigEndian (input [i]);
+}
+
+static void decode (uint32* const output,
+ const uint8* const input,
+ const int numBytes)
+{
+ for (int i = 0; i < (numBytes >> 2); ++i)
+ output[i] = littleEndianInt ((const char*) input + (i << 2));
+}
+
+void MD5::ProcessContext::finish (uint8* const result)
+{
+ unsigned char encodedLength[8];
+ encode (encodedLength, count, 8);
+
+ // Pad out to 56 mod 64.
+ const int index = (uint32) ((count[0] >> 3) & 0x3f);
+
+ const int paddingLength = (index < 56) ? (56 - index)
+ : (120 - index);
+
+ uint8 paddingBuffer [64];
+ zeromem (paddingBuffer, paddingLength);
+ paddingBuffer [0] = 0x80;
+ processBlock (paddingBuffer, paddingLength);
+
+ processBlock (encodedLength, 8);
+
+ encode (result, state, 16);
+
+ zeromem (buffer, sizeof (buffer));
+}
+
+#define S11 7
+#define S12 12
+#define S13 17
+#define S14 22
+#define S21 5
+#define S22 9
+#define S23 14
+#define S24 20
+#define S31 4
+#define S32 11
+#define S33 16
+#define S34 23
+#define S41 6
+#define S42 10
+#define S43 15
+#define S44 21
+
+static inline uint32 F (const uint32 x, const uint32 y, const uint32 z) { return (x & y) | (~x & z); }
+static inline uint32 G (const uint32 x, const uint32 y, const uint32 z) { return (x & z) | (y & ~z); }
+static inline uint32 H (const uint32 x, const uint32 y, const uint32 z) { return x ^ y ^ z; }
+static inline uint32 I (const uint32 x, const uint32 y, const uint32 z) { return y ^ (x | ~z); }
+
+static inline uint32 rotateLeft (const uint32 x, const uint32 n) { return (x << n) | (x >> (32 - n)); }
+
+static inline void FF (uint32& a, const uint32 b, const uint32 c, const uint32 d, const uint32 x, const uint32 s, const uint32 ac)
+{
+ a += F (b, c, d) + x + ac;
+ a = rotateLeft (a, s) + b;
+}
+
+static inline void GG (uint32& a, const uint32 b, const uint32 c, const uint32 d, const uint32 x, const uint32 s, const uint32 ac)
+{
+ a += G (b, c, d) + x + ac;
+ a = rotateLeft (a, s) + b;
+}
+
+static inline void HH (uint32& a, const uint32 b, const uint32 c, const uint32 d, const uint32 x, const uint32 s, const uint32 ac)
+{
+ a += H (b, c, d) + x + ac;
+ a = rotateLeft (a, s) + b;
+}
+
+static inline void II (uint32& a, const uint32 b, const uint32 c, const uint32 d, const uint32 x, const uint32 s, const uint32 ac)
+{
+ a += I (b, c, d) + x + ac;
+ a = rotateLeft (a, s) + b;
+}
+
+void MD5::ProcessContext::transform (const uint8* const buffer)
+{
+ uint32 a = state[0];
+ uint32 b = state[1];
+ uint32 c = state[2];
+ uint32 d = state[3];
+ uint32 x[16];
+
+ decode (x, buffer, 64);
+
+ FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
+ FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
+ FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
+ FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
+ FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
+ FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
+ FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
+ FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
+ FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
+ FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
+ FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
+ FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
+ FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
+ FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
+ FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
+ FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
+
+ GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
+ GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
+ GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
+ GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
+ GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
+ GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
+ GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
+ GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
+ GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
+ GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
+ GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
+ GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
+ GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
+ GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
+ GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
+ GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
+
+ HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
+ HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
+ HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
+ HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
+ HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
+ HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
+ HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
+ HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
+ HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
+ HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
+ HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
+ HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
+ HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
+ HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
+ HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
+ HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
+
+ II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
+ II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
+ II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
+ II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
+ II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
+ II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
+ II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
+ II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
+ II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
+ II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
+ II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
+ II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
+ II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
+ II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
+ II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
+ II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
+
+ state[0] += a;
+ state[1] += b;
+ state[2] += c;
+ state[3] += d;
+
+ zeromem (x, sizeof (x));
+}
+
+const MemoryBlock MD5::getRawChecksumData() const
+{
+ return MemoryBlock (result, 16);
+}
+
+const String MD5::toHexString() const
+{
+ return String::toHexString (result, 16, 0);
+}
+
+bool MD5::operator== (const MD5& other) const
+{
+ return memcmp (result, other.result, 16) == 0;
+}
+
+bool MD5::operator!= (const MD5& other) const
+{
+ return ! operator== (other);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_MD5.cpp *********/
+
+/********* Start of inlined file: juce_Primes.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+static void createSmallSieve (const int numBits, BitArray& result) throw()
+{
+ result.setBit (numBits);
+ result.clearBit (numBits); // to enlarge the array
+
+ result.setBit (0);
+ int n = 2;
+
+ do
+ {
+ for (int i = n + n; i < numBits; i += n)
+ result.setBit (i);
+
+ n = result.findNextClearBit (n + 1);
+ }
+ while (n <= (numBits >> 1));
+}
+
+static void bigSieve (const BitArray& base,
+ const int numBits,
+ BitArray& result,
+ const BitArray& smallSieve,
+ const int smallSieveSize) throw()
+{
+ jassert (! base[0]); // must be even!
+
+ result.setBit (numBits);
+ result.clearBit (numBits); // to enlarge the array
+
+ int index = smallSieve.findNextClearBit (0);
+
+ do
+ {
+ const int prime = (index << 1) + 1;
+
+ BitArray r (base);
+ BitArray remainder;
+ r.divideBy (prime, remainder);
+
+ int i = prime - remainder.getBitRangeAsInt (0, 32);
+
+ if (r.isEmpty())
+ i += prime;
+
+ if ((i & 1) == 0)
+ i += prime;
+
+ i = (i - 1) >> 1;
+
+ while (i < numBits)
+ {
+ result.setBit (i);
+ i += prime;
+ }
+
+ index = smallSieve.findNextClearBit (index + 1);
+ }
+ while (index < smallSieveSize);
+}
+
+static bool findCandidate (const BitArray& base,
+ const BitArray& sieve,
+ const int numBits,
+ BitArray& result,
+ const int certainty) throw()
+{
+ for (int i = 0; i < numBits; ++i)
+ {
+ if (! sieve[i])
+ {
+ result = base;
+ result.add (BitArray ((unsigned int) ((i << 1) + 1)));
+
+ if (Primes::isProbablyPrime (result, certainty))
+ return true;
+ }
+ }
+
+ return false;
+}
+
+const BitArray Primes::createProbablePrime (const int bitLength,
+ const int certainty) throw()
+{
+ BitArray smallSieve;
+ const int smallSieveSize = 15000;
+ createSmallSieve (smallSieveSize, smallSieve);
+
+ BitArray p;
+ p.fillBitsRandomly (0, bitLength);
+ p.setBit (bitLength - 1);
+ p.clearBit (0);
+
+ const int searchLen = jmax (1024, (bitLength / 20) * 64);
+
+ while (p.getHighestBit() < bitLength)
+ {
+ p.add (2 * searchLen);
+
+ BitArray sieve;
+ bigSieve (p, searchLen, sieve,
+ smallSieve, smallSieveSize);
+
+ BitArray candidate;
+
+ if (findCandidate (p, sieve, searchLen, candidate, certainty))
+ return candidate;
+ }
+
+ jassertfalse
+ return BitArray();
+}
+
+static bool passesMillerRabin (const BitArray& n, int iterations) throw()
+{
+ const BitArray one (1);
+ const BitArray two (2);
+
+ BitArray nMinusOne (n);
+ nMinusOne.subtract (one);
+
+ BitArray d (nMinusOne);
+ const int s = d.findNextSetBit (0);
+ d.shiftBits (-s);
+
+ BitArray smallPrimes;
+ int numBitsInSmallPrimes = 0;
+
+ for (;;)
+ {
+ numBitsInSmallPrimes += 256;
+ createSmallSieve (numBitsInSmallPrimes, smallPrimes);
+
+ const int numPrimesFound = numBitsInSmallPrimes - smallPrimes.countNumberOfSetBits();
+
+ if (numPrimesFound > iterations + 1)
+ break;
+ }
+
+ int smallPrime = 2;
+
+ while (--iterations >= 0)
+ {
+ smallPrime = smallPrimes.findNextClearBit (smallPrime + 1);
+
+ BitArray r (smallPrime);
+ //r.createRandomNumber (nMinusOne);
+ r.exponentModulo (d, n);
+
+ if (! (r == one || r == nMinusOne))
+ {
+ for (int j = 0; j < s; ++j)
+ {
+ r.exponentModulo (two, n);
+
+ if (r == nMinusOne)
+ break;
+ }
+
+ if (r != nMinusOne)
+ return false;
+ }
+ }
+
+ return true;
+}
+
+bool Primes::isProbablyPrime (const BitArray& number,
+ const int certainty) throw()
+{
+ if (! number[0])
+ return false;
+
+ if (number.getHighestBit() <= 10)
+ {
+ const int num = number.getBitRangeAsInt (0, 10);
+
+ for (int i = num / 2; --i > 1;)
+ if (num % i == 0)
+ return false;
+
+ return true;
+ }
+ else
+ {
+ const BitArray screen (2 * 3 * 5 * 7 * 11 * 13 * 17 * 19 * 23);
+
+ if (number.findGreatestCommonDivisor (screen) != BitArray (1))
+ return false;
+
+ return passesMillerRabin (number, certainty);
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_Primes.cpp *********/
+
+/********* Start of inlined file: juce_RSAKey.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+RSAKey::RSAKey() throw()
+{
+}
+
+RSAKey::RSAKey (const String& s) throw()
+{
+ if (s.containsChar (T(',')))
+ {
+ part1.parseString (s.upToFirstOccurrenceOf (T(","), false, false), 16);
+ part2.parseString (s.fromFirstOccurrenceOf (T(","), false, false), 16);
+ }
+ else
+ {
+ // the string needs to be two hex numbers, comma-separated..
+ jassertfalse;
+ }
+}
+
+RSAKey::~RSAKey() throw()
+{
+}
+
+const String RSAKey::toString() const throw()
+{
+ return part1.toString (16) + T(",") + part2.toString (16);
+}
+
+bool RSAKey::applyToValue (BitArray& value) const throw()
+{
+ if (part1.isEmpty() || part2.isEmpty()
+ || value.compare (0) <= 0)
+ {
+ jassertfalse // using an uninitialised key
+ value.clear();
+ return false;
+ }
+
+ BitArray result;
+
+ while (! value.isEmpty())
+ {
+ result.multiplyBy (part2);
+
+ BitArray remainder;
+ value.divideBy (part2, remainder);
+
+ remainder.exponentModulo (part1, part2);
+
+ result.add (remainder);
+ }
+
+ value = result;
+
+ return true;
+}
+
+static const BitArray findBestCommonDivisor (const BitArray& p,
+ const BitArray& q) throw()
+{
+ const BitArray one (1);
+
+ // try 3, 5, 9, 17, etc first because these only contain 2 bits and so
+ // are fast to divide + multiply
+ for (int i = 2; i <= 65536; i *= 2)
+ {
+ const BitArray e (1 + i);
+
+ if (e.findGreatestCommonDivisor (p) == one
+ && e.findGreatestCommonDivisor (q) == one)
+ {
+ return e;
+ }
+ }
+
+ BitArray e (4);
+
+ while (! (e.findGreatestCommonDivisor (p) == one
+ && e.findGreatestCommonDivisor (q) == one))
+ {
+ e.add (one);
+ }
+
+ return e;
+}
+
+void RSAKey::createKeyPair (RSAKey& publicKey,
+ RSAKey& privateKey,
+ const int numBits) throw()
+{
+ jassert (numBits > 16); // not much point using less than this..
+
+ BitArray p (Primes::createProbablePrime (numBits / 2, 30));
+ BitArray q (Primes::createProbablePrime (numBits - numBits / 2, 30));
+
+ BitArray n (p);
+ n.multiplyBy (q); // n = pq
+
+ const BitArray one (1);
+ p.subtract (one);
+ q.subtract (one);
+
+ BitArray m (p);
+ m.multiplyBy (q); // m = (p - 1)(q - 1)
+
+ const BitArray e (findBestCommonDivisor (p, q));
+
+ BitArray d (e);
+ d.inverseModulo (m);
+
+ publicKey.part1 = e;
+ publicKey.part2 = n;
+
+ privateKey.part1 = d;
+ privateKey.part2 = n;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_RSAKey.cpp *********/
+
+/********* Start of inlined file: juce_InputStream.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+char InputStream::readByte()
+{
+ char temp = 0;
+ read (&temp, 1);
+ return temp;
+}
+
+bool InputStream::readBool()
+{
+ return readByte() != 0;
+}
+
+short InputStream::readShort()
+{
+ char temp [2];
+
+ if (read (temp, 2) == 2)
+ return (short) littleEndianShort (temp);
+ else
+ return 0;
+}
+
+short InputStream::readShortBigEndian()
+{
+ char temp [2];
+
+ if (read (temp, 2) == 2)
+ return (short) bigEndianShort (temp);
+ else
+ return 0;
+}
+
+int InputStream::readInt()
+{
+ char temp [4];
+
+ if (read (temp, 4) == 4)
+ return (int) littleEndianInt (temp);
+ else
+ return 0;
+}
+
+int InputStream::readIntBigEndian()
+{
+ char temp [4];
+
+ if (read (temp, 4) == 4)
+ return (int) bigEndianInt (temp);
+ else
+ return 0;
+}
+
+int InputStream::readCompressedInt()
+{
+ int num = 0;
+
+ if (! isExhausted())
+ {
+ unsigned char numBytes = readByte();
+ const bool negative = (numBytes & 0x80) != 0;
+ numBytes &= 0x7f;
+
+ if (numBytes <= 4)
+ {
+ if (read (&num, numBytes) != numBytes)
+ return 0;
+
+ if (negative)
+ num = -num;
+ }
+ }
+
+ return num;
+}
+
+int64 InputStream::readInt64()
+{
+ char temp [8];
+
+ if (read (temp, 8) == 8)
+ return (int64) swapIfBigEndian (*(uint64*)temp);
+ else
+ return 0;
+}
+
+int64 InputStream::readInt64BigEndian()
+{
+ char temp [8];
+
+ if (read (temp, 8) == 8)
+ return (int64) swapIfLittleEndian (*(uint64*)temp);
+ else
+ return 0;
+}
+
+float InputStream::readFloat()
+{
+ union { int asInt; float asFloat; } n;
+ n.asInt = readInt();
+ return n.asFloat;
+}
+
+float InputStream::readFloatBigEndian()
+{
+ union { int asInt; float asFloat; } n;
+ n.asInt = readIntBigEndian();
+ return n.asFloat;
+}
+
+double InputStream::readDouble()
+{
+ union { int64 asInt; double asDouble; } n;
+ n.asInt = readInt64();
+ return n.asDouble;
+}
+
+double InputStream::readDoubleBigEndian()
+{
+ union { int64 asInt; double asDouble; } n;
+ n.asInt = readInt64BigEndian();
+ return n.asDouble;
+}
+
+const String InputStream::readString()
+{
+ const int tempBufferSize = 256;
+ uint8 temp [tempBufferSize];
+ int i = 0;
+
+ while ((temp [i++] = readByte()) != 0)
+ {
+ if (i == tempBufferSize)
+ {
+ // too big for our quick buffer, so read it in blocks..
+ String result (String::fromUTF8 (temp, i));
+ i = 0;
+
+ for (;;)
+ {
+ if ((temp [i++] = readByte()) == 0)
+ {
+ result += String::fromUTF8 (temp, i - 1);
+ break;
+ }
+ else if (i == tempBufferSize)
+ {
+ result += String::fromUTF8 (temp, i);
+ i = 0;
+ }
+ }
+
+ return result;
+ }
+ }
+
+ return String::fromUTF8 (temp, i - 1);
+}
+
+const String InputStream::readNextLine()
+{
+ String s;
+ const int maxChars = 256;
+ tchar buffer [maxChars];
+ int charsInBuffer = 0;
+
+ while (! isExhausted())
+ {
+ const uint8 c = readByte();
+ const int64 lastPos = getPosition();
+
+ if (c == '\n')
+ {
+ break;
+ }
+ else if (c == '\r')
+ {
+ if (readByte() != '\n')
+ setPosition (lastPos);
+
+ break;
+ }
+
+ buffer [charsInBuffer++] = c;
+
+ if (charsInBuffer == maxChars)
+ {
+ s.append (buffer, maxChars);
+ charsInBuffer = 0;
+ }
+ }
+
+ if (charsInBuffer > 0)
+ s.append (buffer, charsInBuffer);
+
+ return s;
+}
+
+int InputStream::readIntoMemoryBlock (MemoryBlock& block,
+ int numBytes)
+{
+ const int64 totalLength = getTotalLength();
+
+ if (totalLength >= 0)
+ {
+ const int totalBytesRemaining = (int) jmin ((int64) 0x7fffffff,
+ totalLength - getPosition());
+
+ if (numBytes < 0)
+ numBytes = totalBytesRemaining;
+ else if (numBytes > 0)
+ numBytes = jmin (numBytes, totalBytesRemaining);
+ else
+ return 0;
+ }
+
+ const int originalBlockSize = block.getSize();
+ int totalBytesRead = 0;
+
+ if (numBytes > 0)
+ {
+ // know how many bytes we want, so we can resize the block first..
+ block.setSize (originalBlockSize + numBytes, false);
+ totalBytesRead = read (((char*) block.getData()) + originalBlockSize, numBytes);
+ }
+ else
+ {
+ // read until end of stram..
+ const int chunkSize = 32768;
+
+ for (;;)
+ {
+ block.ensureSize (originalBlockSize + totalBytesRead + chunkSize, false);
+
+ const int bytesJustIn = read (((char*) block.getData())
+ + originalBlockSize
+ + totalBytesRead,
+ chunkSize);
+
+ if (bytesJustIn == 0)
+ break;
+
+ totalBytesRead += bytesJustIn;
+ }
+ }
+
+ // trim off any excess left at the end
+ block.setSize (originalBlockSize + totalBytesRead, false);
+ return totalBytesRead;
+}
+
+const String InputStream::readEntireStreamAsString()
+{
+ MemoryBlock mb;
+ const int size = readIntoMemoryBlock (mb);
+
+ return String::createStringFromData ((const char*) mb.getData(), size);
+}
+
+void InputStream::skipNextBytes (int64 numBytesToSkip)
+{
+ if (numBytesToSkip > 0)
+ {
+ const int skipBufferSize = (int) jmin (numBytesToSkip, (int64) 16384);
+ MemoryBlock temp (skipBufferSize);
+
+ while ((numBytesToSkip > 0) && ! isExhausted())
+ {
+ numBytesToSkip -= read (temp.getData(), (int) jmin (numBytesToSkip, (int64) skipBufferSize));
+ }
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_InputStream.cpp *********/
+
+/********* Start of inlined file: juce_OutputStream.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+#if JUCE_DEBUG
+static CriticalSection activeStreamLock;
+static VoidArray activeStreams;
+
+void juce_CheckForDanglingStreams()
+{
+ /*
+ It's always a bad idea to leak any object, but if you're leaking output
+ streams, then there's a good chance that you're failing to flush a file
+ to disk properly, which could result in corrupted data and other similar
+ nastiness..
+ */
+ jassert (activeStreams.size() == 0);
+};
+#endif
+
+OutputStream::OutputStream() throw()
+{
+#if JUCE_DEBUG
+ activeStreamLock.enter();
+ activeStreams.add (this);
+ activeStreamLock.exit();
+#endif
+}
+
+OutputStream::~OutputStream()
+{
+#if JUCE_DEBUG
+ activeStreamLock.enter();
+ activeStreams.removeValue (this);
+ activeStreamLock.exit();
+#endif
+}
+
+void OutputStream::writeBool (bool b)
+{
+ writeByte ((b) ? (char) 1
+ : (char) 0);
+}
+
+void OutputStream::writeByte (char byte)
+{
+ write (&byte, 1);
+}
+
+void OutputStream::writeShort (short value)
+{
+ const unsigned short v = swapIfBigEndian ((unsigned short) value);
+ write (&v, 2);
+}
+
+void OutputStream::writeShortBigEndian (short value)
+{
+ const unsigned short v = swapIfLittleEndian ((unsigned short) value);
+ write (&v, 2);
+}
+
+void OutputStream::writeInt (int value)
+{
+ const unsigned int v = swapIfBigEndian ((unsigned int) value);
+ write (&v, 4);
+}
+
+void OutputStream::writeIntBigEndian (int value)
+{
+ const unsigned int v = swapIfLittleEndian ((unsigned int) value);
+ write (&v, 4);
+}
+
+void OutputStream::writeCompressedInt (int value)
+{
+ unsigned int un = (value < 0) ? (unsigned int) -value
+ : (unsigned int) value;
+ unsigned int tn = un;
+
+ int numSigBytes = 0;
+
+ do
+ {
+ tn >>= 8;
+ numSigBytes++;
+
+ } while (tn & 0xff);
+
+ if (value < 0)
+ numSigBytes |= 0x80;
+
+ writeByte ((char) numSigBytes);
+ write (&un, numSigBytes);
+}
+
+void OutputStream::writeInt64 (int64 value)
+{
+ const uint64 v = swapIfBigEndian ((uint64) value);
+ write (&v, 8);
+}
+
+void OutputStream::writeInt64BigEndian (int64 value)
+{
+ const uint64 v = swapIfLittleEndian ((uint64) value);
+ write (&v, 8);
+}
+
+void OutputStream::writeFloat (float value)
+{
+ union { int asInt; float asFloat; } n;
+ n.asFloat = value;
+ writeInt (n.asInt);
+}
+
+void OutputStream::writeFloatBigEndian (float value)
+{
+ union { int asInt; float asFloat; } n;
+ n.asFloat = value;
+ writeIntBigEndian (n.asInt);
+}
+
+void OutputStream::writeDouble (double value)
+{
+ union { int64 asInt; double asDouble; } n;
+ n.asDouble = value;
+ writeInt64 (n.asInt);
+}
+
+void OutputStream::writeDoubleBigEndian (double value)
+{
+ union { int64 asInt; double asDouble; } n;
+ n.asDouble = value;
+ writeInt64BigEndian (n.asInt);
+}
+
+void OutputStream::writeString (const String& text)
+{
+ const int numBytes = text.copyToUTF8 (0);
+ uint8* const temp = (uint8*) juce_malloc (numBytes);
+
+ text.copyToUTF8 (temp);
+ write (temp, numBytes); // (numBytes includes the terminating null).
+
+ juce_free (temp);
+}
+
+void OutputStream::printf (const char* pf, ...)
+{
+ unsigned int bufSize = 256;
+ char* buf = (char*) juce_malloc (bufSize);
+
+ for (;;)
+ {
+ va_list list;
+ va_start (list, pf);
+
+ const int num = CharacterFunctions::vprintf (buf, bufSize, pf, list);
+
+ if (num > 0)
+ {
+ write (buf, num);
+ break;
+ }
+ else if (num == 0)
+ {
+ break;
+ }
+
+ juce_free (buf);
+ bufSize += 256;
+ buf = (char*) juce_malloc (bufSize);
+ }
+
+ juce_free (buf);
+}
+
+OutputStream& OutputStream::operator<< (const int number)
+{
+ const String s (number);
+ write ((const char*) s, s.length());
+ return *this;
+}
+
+OutputStream& OutputStream::operator<< (const double number)
+{
+ const String s (number);
+ write ((const char*) s, s.length());
+ return *this;
+}
+
+OutputStream& OutputStream::operator<< (const char character)
+{
+ writeByte (character);
+ return *this;
+}
+
+OutputStream& OutputStream::operator<< (const char* const text)
+{
+ write (text, (int) strlen (text));
+ return *this;
+}
+
+OutputStream& OutputStream::operator<< (const juce_wchar* const text)
+{
+ const String s (text);
+ write ((const char*) s, s.length());
+ return *this;
+}
+
+OutputStream& OutputStream::operator<< (const String& text)
+{
+ write ((const char*) text,
+ text.length());
+
+ return *this;
+}
+
+void OutputStream::writeText (const String& text,
+ const bool asUnicode,
+ const bool writeUnicodeHeaderBytes)
+{
+ if (asUnicode)
+ {
+ if (writeUnicodeHeaderBytes)
+ write ("\x0ff\x0fe", 2);
+
+ const juce_wchar* src = (const juce_wchar*) text;
+ bool lastCharWasReturn = false;
+
+ while (*src != 0)
+ {
+ if (*src == L'\n' && ! lastCharWasReturn)
+ writeShort ((short) L'\r');
+
+ lastCharWasReturn = (*src == L'\r');
+ writeShort ((short) *src++);
+ }
+ }
+ else
+ {
+ const char* src = (const char*) text;
+ const char* t = src;
+
+ for (;;)
+ {
+ if (*t == '\n')
+ {
+ if (t > src)
+ write (src, (int) (t - src));
+
+ write ("\r\n", 2);
+ src = t + 1;
+ }
+ else if (*t == '\r')
+ {
+ if (t[1] == '\n')
+ ++t;
+ }
+ else if (*t == 0)
+ {
+ if (t > src)
+ write (src, (int) (t - src));
+
+ break;
+ }
+
+ ++t;
+ }
+ }
+}
+
+int OutputStream::writeFromInputStream (InputStream& source,
+ int numBytesToWrite)
+{
+ if (numBytesToWrite < 0)
+ numBytesToWrite = 0x7fffffff;
+
+ int numWritten = 0;
+
+ while (numBytesToWrite > 0 && ! source.isExhausted())
+ {
+ char buffer [8192];
+
+ const int num = source.read (buffer, jmin (numBytesToWrite, sizeof (buffer)));
+
+ if (num == 0)
+ break;
+
+ write (buffer, num);
+
+ numBytesToWrite -= num;
+ numWritten += num;
+ }
+
+ return numWritten;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_OutputStream.cpp *********/
+
+/********* Start of inlined file: juce_DirectoryIterator.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+void* juce_findFileStart (const String& directory, const String& wildCard, String& firstResultFile,
+ bool* isDirectory, bool* isHidden, int64* fileSize,
+ Time* modTime, Time* creationTime, bool* isReadOnly) throw();
+bool juce_findFileNext (void* handle, String& resultFile,
+ bool* isDirectory, bool* isHidden, int64* fileSize,
+ Time* modTime, Time* creationTime, bool* isReadOnly) throw();
+void juce_findFileClose (void* handle) throw();
+
+DirectoryIterator::DirectoryIterator (const File& directory,
+ bool isRecursive,
+ const String& wc,
+ const int whatToLookFor_) throw()
+ : wildCard (wc),
+ index (-1),
+ whatToLookFor (whatToLookFor_),
+ subIterator (0)
+{
+ // you have to specify the type of files you're looking for!
+ jassert ((whatToLookFor_ & (File::findFiles | File::findDirectories)) != 0);
+ jassert (whatToLookFor_ > 0 && whatToLookFor_ <= 7);
+
+ String path (directory.getFullPathName());
+ if (! path.endsWithChar (File::separator))
+ path += File::separator;
+
+ String filename;
+ bool isDirectory, isHidden;
+
+ void* const handle = juce_findFileStart (path,
+ isRecursive ? T("*") : wc,
+ filename, &isDirectory, &isHidden, 0, 0, 0, 0);
+
+ if (handle != 0)
+ {
+ do
+ {
+ if (! filename.containsOnly (T(".")))
+ {
+ bool addToList = false;
+
+ if (isDirectory)
+ {
+ if (isRecursive
+ && ((whatToLookFor_ & File::ignoreHiddenFiles) == 0
+ || ! isHidden))
+ {
+ dirsFound.add (new File (path + filename, 0));
+ }
+
+ addToList = (whatToLookFor_ & File::findDirectories) != 0;
+ }
+ else
+ {
+ addToList = (whatToLookFor_ & File::findFiles) != 0;
+ }
+
+ // if it's recursive, we're not relying on the OS iterator
+ // to do the wildcard match, so do it now..
+ if (isRecursive && addToList)
+ addToList = filename.matchesWildcard (wc, true);
+
+ if (addToList && (whatToLookFor_ & File::ignoreHiddenFiles) != 0)
+ addToList = ! isHidden;
+
+ if (addToList)
+ filesFound.add (new File (path + filename, 0));
+ }
+
+ } while (juce_findFileNext (handle, filename, &isDirectory, &isHidden, 0, 0, 0, 0));
+
+ juce_findFileClose (handle);
+ }
+}
+
+DirectoryIterator::~DirectoryIterator() throw()
+{
+ if (subIterator != 0)
+ delete subIterator;
+}
+
+bool DirectoryIterator::next() throw()
+{
+ if (subIterator != 0)
+ {
+ if (subIterator->next())
+ return true;
+
+ deleteAndZero (subIterator);
+ }
+
+ if (index >= filesFound.size() + dirsFound.size() - 1)
+ return false;
+
+ ++index;
+
+ if (index >= filesFound.size())
+ {
+ subIterator = new DirectoryIterator (*(dirsFound [index - filesFound.size()]),
+ true, wildCard, whatToLookFor);
+ return next();
+ }
+
+ return true;
+}
+
+const File DirectoryIterator::getFile() const throw()
+{
+ if (subIterator != 0)
+ return subIterator->getFile();
+
+ const File* const f = filesFound [index];
+
+ return (f != 0) ? *f
+ : File::nonexistent;
+}
+
+float DirectoryIterator::getEstimatedProgress() const throw()
+{
+ if (filesFound.size() + dirsFound.size() == 0)
+ {
+ return 0.0f;
+ }
+ else
+ {
+ const float detailedIndex = (subIterator != 0) ? index + subIterator->getEstimatedProgress()
+ : (float) index;
+
+ return detailedIndex / (filesFound.size() + dirsFound.size());
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_DirectoryIterator.cpp *********/
+
+/********* Start of inlined file: juce_File.cpp *********/
+#ifdef _MSC_VER
+ #pragma warning (disable: 4514)
+ #pragma warning (push)
+#endif
+
+#ifndef JUCE_WIN32
+ #include
+#endif
+
+BEGIN_JUCE_NAMESPACE
+
+#ifdef _MSC_VER
+ #pragma warning (pop)
+#endif
+
+void* juce_fileOpen (const String& path, bool forWriting) throw();
+void juce_fileClose (void* handle) throw();
+int juce_fileWrite (void* handle, const void* buffer, int size) throw();
+int64 juce_fileGetPosition (void* handle) throw();
+int64 juce_fileSetPosition (void* handle, int64 pos) throw();
+void juce_fileFlush (void* handle) throw();
+
+bool juce_fileExists (const String& fileName, const bool dontCountDirectories) throw();
+bool juce_isDirectory (const String& fileName) throw();
+int64 juce_getFileSize (const String& fileName) throw();
+bool juce_canWriteToFile (const String& fileName) throw();
+bool juce_setFileReadOnly (const String& fileName, bool isReadOnly) throw();
+
+void juce_getFileTimes (const String& fileName, int64& modificationTime, int64& accessTime, int64& creationTime) throw();
+bool juce_setFileTimes (const String& fileName, int64 modificationTime, int64 accessTime, int64 creationTime) throw();
+
+bool juce_deleteFile (const String& fileName) throw();
+bool juce_copyFile (const String& source, const String& dest) throw();
+bool juce_moveFile (const String& source, const String& dest) throw();
+
+// this must also create all paths involved in the directory.
+void juce_createDirectory (const String& fileName) throw();
+
+bool juce_launchFile (const String& fileName, const String& parameters) throw();
+
+const StringArray juce_getFileSystemRoots() throw();
+const String juce_getVolumeLabel (const String& filenameOnVolume, int& volumeSerialNumber) throw();
+
+// starts a directory search operation with a wildcard, returning a handle for
+// use in calls to juce_findFileNext.
+// juce_firstResultFile gets the name of the file (not the whole pathname) and
+// the other pointers, if non-null, are set based on the properties of the file.
+void* juce_findFileStart (const String& directory, const String& wildCard, String& firstResultFile,
+ bool* isDirectory, bool* isHidden, int64* fileSize, Time* modTime,
+ Time* creationTime, bool* isReadOnly) throw();
+
+// returns false when no more files are found
+bool juce_findFileNext (void* handle, String& resultFile,
+ bool* isDirectory, bool* isHidden, int64* fileSize,
+ Time* modTime, Time* creationTime, bool* isReadOnly) throw();
+
+void juce_findFileClose (void* handle) throw();
+
+static const String parseAbsolutePath (String path) throw()
+{
+ if (path.isEmpty())
+ return String::empty;
+
+#if JUCE_WIN32
+ // Windows..
+ path = path.replaceCharacter (T('/'), T('\\')).unquoted();
+
+ if (path.startsWithChar (File::separator))
+ {
+ if (path[1] != File::separator)
+ {
+ jassertfalse // using a filename that starts with a slash is a bit dodgy on
+ // Windows, because it needs a drive letter, which in this case
+ // we'll take from the CWD.. but this is a bit of an assumption that
+ // could be wrong..
+
+ path = File::getCurrentWorkingDirectory().getFullPathName().substring (0, 2) + path;
+ }
+ }
+ else if (path.indexOfChar (T(':')) < 0)
+ {
+ if (path.isEmpty())
+ return String::empty;
+
+ jassertfalse // using a partial filename is a bad way to initialise a file, because
+ // we don't know what directory to put it in.
+ // Here we'll assume it's in the CWD, but this might not be what was
+ // intended..
+
+ return File::getCurrentWorkingDirectory().getChildFile (path).getFullPathName();
+ }
+#else
+ // Mac or Linux..
+ path = path.replaceCharacter (T('\\'), T('/')).unquoted();
+
+ if (path.startsWithChar (T('~')))
+ {
+ const char* homeDir = 0;
+
+ if (path[1] == File::separator || path[1] == 0)
+ {
+ // expand a name of the form "~/abc"
+ path = File::getSpecialLocation (File::userHomeDirectory).getFullPathName()
+ + path.substring (1);
+ }
+ else
+ {
+ // expand a name of type "~dave/abc"
+ const String userName (path.substring (1)
+ .upToFirstOccurrenceOf (T("/"), false, false));
+
+ struct passwd* const pw = getpwnam (userName);
+ if (pw != 0)
+ {
+ String home (homeDir);
+
+ if (home.endsWithChar (File::separator))
+ home [home.length() - 1] = 0;
+
+ path = String (pw->pw_dir)
+ + path.substring (userName.length());
+ }
+ }
+ }
+ else if (! path.startsWithChar (File::separator))
+ {
+ while (path.startsWith (T("./")))
+ path = path.substring (2);
+
+ if (path.isEmpty())
+ return String::empty;
+
+ jassertfalse // using a partial filename is a bad way to initialise a file, because
+ // we don't know what directory to put it in.
+ // Here we'll assume it's in the CWD, but this might not be what was
+ // intended..
+
+ return File::getCurrentWorkingDirectory().getChildFile (path).getFullPathName();
+ }
+#endif
+
+ int len = path.length();
+ while (--len > 0 && path [len] == File::separator)
+ path [len] = 0;
+
+ return path;
+}
+
+const File File::nonexistent;
+
+File::File (const String& fullPathName) throw()
+ : fullPath (parseAbsolutePath (fullPathName))
+{
+}
+
+File::File (const String& path, int) throw()
+ : fullPath (path)
+{
+}
+
+File::File (const File& other) throw()
+ : fullPath (other.fullPath)
+{
+}
+
+const File& File::operator= (const String& newPath) throw()
+{
+ fullPath = parseAbsolutePath (newPath);
+ return *this;
+}
+
+const File& File::operator= (const File& other) throw()
+{
+ fullPath = other.fullPath;
+ return *this;
+}
+
+#if JUCE_LINUX
+ #define NAMES_ARE_CASE_SENSITIVE 1
+#endif
+
+bool File::areFileNamesCaseSensitive()
+{
+#if NAMES_ARE_CASE_SENSITIVE
+ return true;
+#else
+ return false;
+#endif
+}
+
+bool File::operator== (const File& other) const throw()
+{
+ // case-insensitive on Windows, but not on linux.
+#if NAMES_ARE_CASE_SENSITIVE
+ return fullPath == other.fullPath;
+#else
+ return fullPath.equalsIgnoreCase (other.fullPath);
+#endif
+}
+
+bool File::operator!= (const File& other) const throw()
+{
+ return ! operator== (other);
+}
+
+bool File::exists() const throw()
+{
+ return juce_fileExists (fullPath, false);
+}
+
+bool File::existsAsFile() const throw()
+{
+ return juce_fileExists (fullPath, true);
+}
+
+bool File::isDirectory() const throw()
+{
+ return juce_isDirectory (fullPath);
+}
+
+bool File::hasWriteAccess() const throw()
+{
+ if (exists())
+ return juce_canWriteToFile (fullPath);
+
+#ifndef JUCE_WIN32
+ else if ((! isDirectory()) && fullPath.containsChar (separator))
+ return getParentDirectory().hasWriteAccess();
+ else
+ return false;
+#else
+ // on windows, it seems that even read-only directories can still be written into,
+ // so checking the parent directory's permissions would return the wrong result..
+ else
+ return true;
+#endif
+}
+
+bool File::setReadOnly (const bool shouldBeReadOnly,
+ const bool applyRecursively) const throw()
+{
+ bool worked = true;
+
+ if (applyRecursively && isDirectory())
+ {
+ OwnedArray subFiles;
+ findChildFiles (subFiles, File::findFilesAndDirectories, false);
+
+ for (int i = subFiles.size(); --i >= 0;)
+ worked = subFiles[i]->setReadOnly (shouldBeReadOnly, true) && worked;
+ }
+
+ return juce_setFileReadOnly (fullPath, shouldBeReadOnly) && worked;
+}
+
+bool File::deleteFile() const throw()
+{
+ return (! exists())
+ || juce_deleteFile (fullPath);
+}
+
+bool File::deleteRecursively() const throw()
+{
+ bool worked = true;
+
+ if (isDirectory())
+ {
+ OwnedArray subFiles;
+ findChildFiles (subFiles, File::findFilesAndDirectories, false);
+
+ for (int i = subFiles.size(); --i >= 0;)
+ worked = subFiles[i]->deleteRecursively() && worked;
+ }
+
+ return deleteFile() && worked;
+}
+
+bool File::moveFileTo (const File& newFile) const throw()
+{
+ if (newFile.fullPath == fullPath)
+ return true;
+
+#if ! NAMES_ARE_CASE_SENSITIVE
+ if (*this != newFile)
+#endif
+ if (! newFile.deleteFile())
+ return false;
+
+ return juce_moveFile (fullPath, newFile.fullPath);
+}
+
+bool File::copyFileTo (const File& newFile) const throw()
+{
+ if (*this == newFile)
+ return true;
+
+ if (! newFile.deleteFile())
+ return false;
+
+ return juce_copyFile (fullPath, newFile.fullPath);
+}
+
+bool File::copyDirectoryTo (const File& newDirectory) const throw()
+{
+ if (isDirectory() && newDirectory.createDirectory())
+ {
+ OwnedArray subFiles;
+ findChildFiles (subFiles, File::findFiles, false);
+
+ int i;
+ for (i = 0; i < subFiles.size(); ++i)
+ if (! subFiles[i]->copyFileTo (newDirectory.getChildFile (subFiles[i]->getFileName())))
+ return false;
+
+ subFiles.clear();
+ findChildFiles (subFiles, File::findDirectories, false);
+
+ for (i = 0; i < subFiles.size(); ++i)
+ if (! subFiles[i]->copyDirectoryTo (newDirectory.getChildFile (subFiles[i]->getFileName())))
+ return false;
+
+ return true;
+ }
+
+ return false;
+}
+
+const String File::getPathUpToLastSlash() const throw()
+{
+ const int lastSlash = fullPath.lastIndexOfChar (separator);
+
+ if (lastSlash > 0)
+ return fullPath.substring (0, lastSlash);
+ else if (lastSlash == 0)
+ return separatorString;
+ else
+ return fullPath;
+}
+
+const File File::getParentDirectory() const throw()
+{
+ return File (getPathUpToLastSlash());
+}
+
+const String File::getFileName() const throw()
+{
+ return fullPath.substring (fullPath.lastIndexOfChar (separator) + 1);
+}
+
+int File::hashCode() const throw()
+{
+ return fullPath.hashCode();
+}
+
+int64 File::hashCode64() const throw()
+{
+ return fullPath.hashCode64();
+}
+
+const String File::getFileNameWithoutExtension() const throw()
+{
+ const int lastSlash = fullPath.lastIndexOfChar (separator) + 1;
+ const int lastDot = fullPath.lastIndexOfChar (T('.'));
+
+ if (lastDot > lastSlash)
+ return fullPath.substring (lastSlash, lastDot);
+ else
+ return fullPath.substring (lastSlash);
+}
+
+bool File::isAChildOf (const File& potentialParent) const throw()
+{
+ const String ourPath (getPathUpToLastSlash());
+
+#if NAMES_ARE_CASE_SENSITIVE
+ if (potentialParent.fullPath == ourPath)
+#else
+ if (potentialParent.fullPath.equalsIgnoreCase (ourPath))
+#endif
+ {
+ return true;
+ }
+ else if (potentialParent.fullPath.length() >= ourPath.length())
+ {
+ return false;
+ }
+ else
+ {
+ return getParentDirectory().isAChildOf (potentialParent);
+ }
+}
+
+bool File::isAbsolutePath (const String& path) throw()
+{
+ return path.startsWithChar (T('/')) || path.startsWithChar (T('\\'))
+#if JUCE_WIN32
+ || (path.isNotEmpty() && ((const String&) path)[1] == T(':'));
+#else
+ || path.startsWithChar (T('~'));
+#endif
+}
+
+const File File::getChildFile (String relativePath) const throw()
+{
+ if (isAbsolutePath (relativePath))
+ {
+ // the path is really absolute..
+ return File (relativePath);
+ }
+ else
+ {
+ // it's relative, so remove any ../ or ./ bits at the start.
+ String path (fullPath);
+
+ if (relativePath[0] == T('.'))
+ {
+#if JUCE_WIN32
+ relativePath = relativePath.replaceCharacter (T('/'), T('\\')).trimStart();
+#else
+ relativePath = relativePath.replaceCharacter (T('\\'), T('/')).trimStart();
+#endif
+ while (relativePath[0] == T('.'))
+ {
+ if (relativePath[1] == T('.'))
+ {
+ if (relativePath [2] == 0 || relativePath[2] == separator)
+ {
+ const int lastSlash = path.lastIndexOfChar (separator);
+ if (lastSlash > 0)
+ path = path.substring (0, lastSlash);
+
+ relativePath = relativePath.substring (3);
+ }
+ else
+ {
+ break;
+ }
+ }
+ else if (relativePath[1] == separator)
+ {
+ relativePath = relativePath.substring (2);
+ }
+ else
+ {
+ break;
+ }
+ }
+ }
+
+ if (! path.endsWithChar (separator))
+ path += separator;
+
+ return File (path + relativePath);
+ }
+}
+
+const File File::getSiblingFile (const String& fileName) const throw()
+{
+ return getParentDirectory().getChildFile (fileName);
+}
+
+int64 File::getSize() const throw()
+{
+ return juce_getFileSize (fullPath);
+}
+
+const String File::descriptionOfSizeInBytes (const int64 bytes)
+{
+ if (bytes == 1)
+ {
+ return "1 byte";
+ }
+ else if (bytes < 1024)
+ {
+ return String ((int) bytes) + " bytes";
+ }
+ else if (bytes < 1024 * 1024)
+ {
+ return String (bytes / 1024.0, 1) + " KB";
+ }
+ else if (bytes < 1024 * 1024 * 1024)
+ {
+ return String (bytes / (1024.0 * 1024.0), 1) + " MB";
+ }
+ else
+ {
+ return String (bytes / (1024.0 * 1024.0 * 1024.0), 1) + " GB";
+ }
+}
+
+bool File::create() const throw()
+{
+ if (! exists())
+ {
+ const File parentDir (getParentDirectory());
+
+ if (parentDir == *this || ! parentDir.createDirectory())
+ return false;
+
+ void* const fh = juce_fileOpen (fullPath, true);
+
+ if (fh == 0)
+ return false;
+
+ juce_fileClose (fh);
+ }
+
+ return true;
+}
+
+bool File::createDirectory() const throw()
+{
+ if (! isDirectory())
+ {
+ const File parentDir (getParentDirectory());
+
+ if (parentDir == *this || ! parentDir.createDirectory())
+ return false;
+
+ String dir (fullPath);
+
+ while (dir.endsWithChar (separator))
+ dir [dir.length() - 1] = 0;
+
+ juce_createDirectory (dir);
+
+ return isDirectory();
+ }
+
+ return true;
+}
+
+const Time File::getCreationTime() const throw()
+{
+ int64 m, a, c;
+ juce_getFileTimes (fullPath, m, a, c);
+ return Time (c);
+}
+
+bool File::setCreationTime (const Time& t) const throw()
+{
+ return juce_setFileTimes (fullPath, 0, 0, t.toMilliseconds());
+}
+
+const Time File::getLastModificationTime() const throw()
+{
+ int64 m, a, c;
+ juce_getFileTimes (fullPath, m, a, c);
+ return Time (m);
+}
+
+bool File::setLastModificationTime (const Time& t) const throw()
+{
+ return juce_setFileTimes (fullPath, t.toMilliseconds(), 0, 0);
+}
+
+const Time File::getLastAccessTime() const throw()
+{
+ int64 m, a, c;
+ juce_getFileTimes (fullPath, m, a, c);
+ return Time (a);
+}
+
+bool File::setLastAccessTime (const Time& t) const throw()
+{
+ return juce_setFileTimes (fullPath, 0, t.toMilliseconds(), 0);
+}
+
+bool File::loadFileAsData (MemoryBlock& destBlock) const throw()
+{
+ if (! existsAsFile())
+ return false;
+
+ FileInputStream in (*this);
+ return getSize() == in.readIntoMemoryBlock (destBlock);
+}
+
+const String File::loadFileAsString() const throw()
+{
+ if (! existsAsFile())
+ return String::empty;
+
+ FileInputStream in (*this);
+ return in.readEntireStreamAsString();
+}
+
+static inline bool fileTypeMatches (const int whatToLookFor,
+ const bool isDir,
+ const bool isHidden)
+{
+ return (whatToLookFor & (isDir ? File::findDirectories
+ : File::findFiles)) != 0
+ && ((! isHidden)
+ || (whatToLookFor & File::ignoreHiddenFiles) == 0);
+}
+
+int File::findChildFiles (OwnedArray& results,
+ const int whatToLookFor,
+ const bool searchRecursively,
+ const String& wildCardPattern) const throw()
+{
+ // you have to specify the type of files you're looking for!
+ jassert ((whatToLookFor & (findFiles | findDirectories)) != 0);
+
+ int total = 0;
+
+ // find child files or directories in this directory first..
+ if (isDirectory())
+ {
+ String path (fullPath);
+ if (! path.endsWithChar (separator))
+ path += separator;
+
+ String filename;
+ bool isDirectory, isHidden;
+
+ void* const handle = juce_findFileStart (path,
+ wildCardPattern,
+ filename,
+ &isDirectory, &isHidden,
+ 0, 0, 0, 0);
+
+ if (handle != 0)
+ {
+ do
+ {
+ if (fileTypeMatches (whatToLookFor, isDirectory, isHidden)
+ && ! filename.containsOnly (T(".")))
+ {
+ results.add (new File (path + filename, 0));
+ ++total;
+ }
+
+ } while (juce_findFileNext (handle, filename, &isDirectory, &isHidden, 0, 0, 0, 0));
+
+ juce_findFileClose (handle);
+ }
+ }
+ else
+ {
+ // trying to search for files inside a non-directory?
+ //jassertfalse
+ }
+
+ // and recurse down if required.
+ if (searchRecursively)
+ {
+ OwnedArray subDirectories;
+ findChildFiles (subDirectories, File::findDirectories, false);
+
+ for (int i = 0; i < subDirectories.size(); ++i)
+ {
+ total += subDirectories.getUnchecked(i)
+ ->findChildFiles (results,
+ whatToLookFor,
+ true,
+ wildCardPattern);
+ }
+ }
+
+ return total;
+}
+
+int File::getNumberOfChildFiles (const int whatToLookFor,
+ const String& wildCardPattern) const throw()
+{
+ // you have to specify the type of files you're looking for!
+ jassert (whatToLookFor > 0 && whatToLookFor <= 3);
+
+ int count = 0;
+
+ if (isDirectory())
+ {
+ String filename;
+ bool isDirectory, isHidden;
+
+ void* const handle = juce_findFileStart (fullPath,
+ wildCardPattern,
+ filename,
+ &isDirectory, &isHidden,
+ 0, 0, 0, 0);
+
+ if (handle != 0)
+ {
+ do
+ {
+ if (fileTypeMatches (whatToLookFor, isDirectory, isHidden)
+ && ! filename.containsOnly (T(".")))
+ {
+ ++count;
+ }
+
+ } while (juce_findFileNext (handle, filename, &isDirectory, &isHidden, 0, 0, 0, 0));
+
+ juce_findFileClose (handle);
+ }
+ }
+ else
+ {
+ // trying to search for files inside a non-directory?
+ jassertfalse
+ }
+
+ return count;
+}
+
+const File File::getNonexistentChildFile (const String& prefix_,
+ const String& suffix,
+ bool putNumbersInBrackets) const throw()
+{
+ File f (getChildFile (prefix_ + suffix));
+
+ if (f.exists())
+ {
+ int num = 2;
+ String prefix (prefix_);
+
+ // remove any bracketed numbers that may already be on the end..
+ if (prefix.trim().endsWithChar (T(')')))
+ {
+ putNumbersInBrackets = true;
+
+ const int openBracks = prefix.lastIndexOfChar (T('('));
+ const int closeBracks = prefix.lastIndexOfChar (T(')'));
+
+ if (openBracks > 0
+ && closeBracks > openBracks
+ && prefix.substring (openBracks + 1, closeBracks).containsOnly (T("0123456789")))
+ {
+ num = prefix.substring (openBracks + 1, closeBracks).getIntValue() + 1;
+ prefix = prefix.substring (0, openBracks);
+ }
+ }
+
+ // also use brackets if it ends in a digit.
+ putNumbersInBrackets = putNumbersInBrackets
+ || CharacterFunctions::isDigit (prefix.getLastCharacter());
+
+ do
+ {
+ if (putNumbersInBrackets)
+ f = getChildFile (prefix + T('(') + String (num++) + T(')') + suffix);
+ else
+ f = getChildFile (prefix + String (num++) + suffix);
+
+ } while (f.exists());
+ }
+
+ return f;
+}
+
+const File File::getNonexistentSibling (const bool putNumbersInBrackets) const throw()
+{
+ if (exists())
+ {
+ return getParentDirectory()
+ .getNonexistentChildFile (getFileNameWithoutExtension(),
+ getFileExtension(),
+ putNumbersInBrackets);
+ }
+ else
+ {
+ return *this;
+ }
+}
+
+const String File::getFileExtension() const throw()
+{
+ String ext;
+
+ if (! isDirectory())
+ {
+ const int indexOfDot = fullPath.lastIndexOfChar (T('.'));
+
+ if (indexOfDot > fullPath.lastIndexOfChar (separator))
+ ext = fullPath.substring (indexOfDot);
+ }
+
+ return ext;
+}
+
+bool File::hasFileExtension (const String& possibleSuffix) const throw()
+{
+ if (possibleSuffix.isEmpty())
+ return fullPath.lastIndexOfChar (T('.')) <= fullPath.lastIndexOfChar (separator);
+
+ if (fullPath.endsWithIgnoreCase (possibleSuffix))
+ {
+ if (possibleSuffix.startsWithChar (T('.')))
+ return true;
+
+ const int dotPos = fullPath.length() - possibleSuffix.length() - 1;
+
+ if (dotPos >= 0)
+ return fullPath [dotPos] == T('.');
+ }
+
+ return false;
+}
+
+const File File::withFileExtension (const String& newExtension) const throw()
+{
+ if (fullPath.isEmpty())
+ return File::nonexistent;
+
+ String filePart (getFileName());
+
+ int i = filePart.lastIndexOfChar (T('.'));
+ if (i < 0)
+ i = filePart.length();
+
+ String newExt (newExtension);
+
+ if (newExt.isNotEmpty() && ! newExt.startsWithChar (T('.')))
+ newExt = T(".") + newExt;
+
+ return getSiblingFile (filePart.substring (0, i) + newExt);
+}
+
+bool File::startAsProcess (const String& parameters) const throw()
+{
+ return exists()
+ && juce_launchFile (fullPath, parameters);
+}
+
+FileInputStream* File::createInputStream() const throw()
+{
+ if (existsAsFile())
+ return new FileInputStream (*this);
+ else
+ return 0;
+}
+
+FileOutputStream* File::createOutputStream (const int bufferSize) const throw()
+{
+ FileOutputStream* const out = new FileOutputStream (*this, bufferSize);
+
+ if (out->failedToOpen())
+ {
+ delete out;
+ return 0;
+ }
+ else
+ {
+ return out;
+ }
+}
+
+bool File::appendData (const void* const dataToAppend,
+ const int numberOfBytes) const throw()
+{
+ if (numberOfBytes > 0)
+ {
+ FileOutputStream* const out = createOutputStream();
+
+ if (out == 0)
+ return false;
+
+ out->write (dataToAppend, numberOfBytes);
+ delete out;
+ }
+
+ return true;
+}
+
+bool File::replaceWithData (const void* const dataToWrite,
+ const int numberOfBytes) const throw()
+{
+ jassert (numberOfBytes >= 0); // a negative number of bytes??
+
+ if (numberOfBytes <= 0)
+ return deleteFile();
+
+ const File tempFile (getSiblingFile (T(".") + getFileName()).getNonexistentSibling (false));
+
+ if (tempFile.appendData (dataToWrite, numberOfBytes)
+ && tempFile.moveFileTo (*this))
+ {
+ return true;
+ }
+
+ tempFile.deleteFile();
+ return false;
+}
+
+bool File::appendText (const String& text,
+ const bool asUnicode,
+ const bool writeUnicodeHeaderBytes) const throw()
+{
+ FileOutputStream* const out = createOutputStream();
+
+ if (out != 0)
+ {
+ out->writeText (text, asUnicode, writeUnicodeHeaderBytes);
+ delete out;
+
+ return true;
+ }
+
+ return false;
+}
+
+bool File::printf (const tchar* pf, ...) const throw()
+{
+ va_list list;
+ va_start (list, pf);
+
+ String text;
+ text.vprintf (pf, list);
+
+ return appendData ((const char*) text, text.length());
+}
+
+bool File::replaceWithText (const String& textToWrite,
+ const bool asUnicode,
+ const bool writeUnicodeHeaderBytes) const throw()
+{
+ const File tempFile (getSiblingFile (T(".") + getFileName()).getNonexistentSibling (false));
+
+ if (tempFile.appendText (textToWrite, asUnicode, writeUnicodeHeaderBytes)
+ && tempFile.moveFileTo (*this))
+ {
+ return true;
+ }
+
+ tempFile.deleteFile();
+ return false;
+}
+
+const String File::createLegalPathName (const String& original) throw()
+{
+ String s (original);
+ String start;
+
+ if (s[1] == T(':'))
+ {
+ start = s.substring (0, 2);
+ s = s.substring (2);
+ }
+
+ return start + s.removeCharacters (T("\"#@,;:<>*^|?"))
+ .substring (0, 1024);
+}
+
+const String File::createLegalFileName (const String& original) throw()
+{
+ String s (original.removeCharacters (T("\"#@,;:<>*^|?\\/")));
+
+ const int maxLength = 128; // only the length of the filename, not the whole path
+ const int len = s.length();
+
+ if (len > maxLength)
+ {
+ const int lastDot = s.lastIndexOfChar (T('.'));
+
+ if (lastDot > jmax (0, len - 12))
+ {
+ s = s.substring (0, maxLength - (len - lastDot))
+ + s.substring (lastDot);
+ }
+ else
+ {
+ s = s.substring (0, maxLength);
+ }
+ }
+
+ return s;
+}
+
+const String File::getRelativePathFrom (const File& dir) const throw()
+{
+ String thisPath (fullPath);
+
+ {
+ int len = thisPath.length();
+ while (--len >= 0 && thisPath [len] == File::separator)
+ thisPath [len] = 0;
+ }
+
+ String dirPath ((dir.existsAsFile()) ? dir.getParentDirectory().getFullPathName()
+ : dir.fullPath);
+
+ if (! dirPath.endsWithChar (separator))
+ dirPath += separator;
+
+ const int len = jmin (thisPath.length(), dirPath.length());
+ int commonBitLength = 0;
+
+ for (int i = 0; i < len; ++i)
+ {
+#if NAMES_ARE_CASE_SENSITIVE
+ if (thisPath[i] != dirPath[i])
+#else
+ if (CharacterFunctions::toLowerCase (thisPath[i])
+ != CharacterFunctions::toLowerCase (dirPath[i]))
+#endif
+ {
+ break;
+ }
+
+ ++commonBitLength;
+ }
+
+ while (commonBitLength > 0 && thisPath [commonBitLength - 1] != File::separator)
+ --commonBitLength;
+
+ // if the only common bit is the root, then just return the full path..
+#if JUCE_WIN32
+ if (commonBitLength <= 0
+ || (commonBitLength == 1 && thisPath [1] == File::separator)
+ || (commonBitLength <= 3 && thisPath [1] == T(':')))
+#else
+ if (commonBitLength <= 0
+ || (commonBitLength == 1 && thisPath [1] == File::separator))
+#endif
+ return fullPath;
+
+ thisPath = thisPath.substring (commonBitLength);
+ dirPath = dirPath.substring (commonBitLength);
+
+ while (dirPath.isNotEmpty())
+ {
+#if JUCE_WIN32
+ thisPath = T("..\\") + thisPath;
+#else
+ thisPath = T("../") + thisPath;
+#endif
+
+ const int sep = dirPath.indexOfChar (separator);
+
+ if (sep >= 0)
+ dirPath = dirPath.substring (sep + 1);
+ else
+ dirPath = String::empty;
+ }
+
+ return thisPath;
+}
+
+void File::findFileSystemRoots (OwnedArray& destArray) throw()
+{
+ const StringArray roots (juce_getFileSystemRoots());
+
+ for (int i = 0; i < roots.size(); ++i)
+ destArray.add (new File (roots[i]));
+}
+
+const String File::getVolumeLabel() const throw()
+{
+ int serialNum;
+ return juce_getVolumeLabel (fullPath, serialNum);
+}
+
+int File::getVolumeSerialNumber() const throw()
+{
+ int serialNum;
+ juce_getVolumeLabel (fullPath, serialNum);
+
+ return serialNum;
+}
+
+const File File::createTempFile (const String& fileNameEnding) throw()
+{
+ String tempName (T("temp"));
+ static int tempNum = 0;
+ tempName << tempNum++ << fileNameEnding;
+
+ const File tempFile (getSpecialLocation (tempDirectory)
+ .getChildFile (tempName));
+
+ if (tempFile.exists())
+ return createTempFile (fileNameEnding);
+ else
+ return tempFile;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_File.cpp *********/
+
+/********* Start of inlined file: juce_FileInputStream.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+void* juce_fileOpen (const String& path, bool forWriting) throw();
+void juce_fileClose (void* handle) throw();
+int juce_fileRead (void* handle, void* buffer, int size) throw();
+int64 juce_fileSetPosition (void* handle, int64 pos) throw();
+
+FileInputStream::FileInputStream (const File& f)
+ : file (f),
+ currentPosition (0),
+ needToSeek (true)
+{
+ totalSize = f.getSize();
+
+ fileHandle = juce_fileOpen (f.getFullPathName(), false);
+}
+
+FileInputStream::~FileInputStream()
+{
+ juce_fileClose (fileHandle);
+}
+
+int64 FileInputStream::getTotalLength()
+{
+ return totalSize;
+}
+
+int FileInputStream::read (void* buffer, int bytesToRead)
+{
+ int num = 0;
+
+ if (needToSeek)
+ {
+ if (juce_fileSetPosition (fileHandle, currentPosition) < 0)
+ return 0;
+
+ needToSeek = false;
+ }
+
+ num = juce_fileRead (fileHandle, buffer, bytesToRead);
+ currentPosition += num;
+
+ return num;
+}
+
+bool FileInputStream::isExhausted()
+{
+ return currentPosition >= totalSize;
+}
+
+int64 FileInputStream::getPosition()
+{
+ return currentPosition;
+}
+
+bool FileInputStream::setPosition (int64 pos)
+{
+ pos = jlimit ((int64) 0, totalSize, pos);
+
+ needToSeek |= (currentPosition != pos);
+ currentPosition = pos;
+
+ return true;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_FileInputStream.cpp *********/
+
+/********* Start of inlined file: juce_FileOutputStream.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+void* juce_fileOpen (const String& path, bool forWriting) throw();
+void juce_fileClose (void* handle) throw();
+int juce_fileWrite (void* handle, const void* buffer, int size) throw();
+void juce_fileFlush (void* handle) throw();
+int64 juce_fileGetPosition (void* handle) throw();
+int64 juce_fileSetPosition (void* handle, int64 pos) throw();
+
+FileOutputStream::FileOutputStream (const File& f,
+ const int bufferSize_)
+ : file (f),
+ bufferSize (bufferSize_),
+ bytesInBuffer (0)
+{
+ fileHandle = juce_fileOpen (f.getFullPathName(), true);
+
+ if (fileHandle != 0)
+ {
+ currentPosition = juce_fileGetPosition (fileHandle);
+
+ if (currentPosition < 0)
+ {
+ jassertfalse
+ juce_fileClose (fileHandle);
+ fileHandle = 0;
+ }
+ }
+
+ buffer = (char*) juce_malloc (jmax (bufferSize_, 16));
+}
+
+FileOutputStream::~FileOutputStream()
+{
+ flush();
+
+ juce_fileClose (fileHandle);
+ juce_free (buffer);
+}
+
+int64 FileOutputStream::getPosition()
+{
+ return currentPosition;
+}
+
+bool FileOutputStream::setPosition (int64 newPosition)
+{
+ if (newPosition != currentPosition)
+ {
+ flush();
+ currentPosition = juce_fileSetPosition (fileHandle, newPosition);
+ }
+
+ return newPosition == currentPosition;
+}
+
+void FileOutputStream::flush()
+{
+ if (bytesInBuffer > 0)
+ {
+ juce_fileWrite (fileHandle, buffer, bytesInBuffer);
+ bytesInBuffer = 0;
+ }
+
+ juce_fileFlush (fileHandle);
+}
+
+bool FileOutputStream::write (const void* const src, const int numBytes)
+{
+ if (bytesInBuffer + numBytes < bufferSize)
+ {
+ memcpy (buffer + bytesInBuffer, src, numBytes);
+ bytesInBuffer += numBytes;
+ currentPosition += numBytes;
+ }
+ else
+ {
+ if (bytesInBuffer > 0)
+ {
+ // flush the reservoir
+ const bool wroteOk = (juce_fileWrite (fileHandle, buffer, bytesInBuffer) == bytesInBuffer);
+ bytesInBuffer = 0;
+
+ if (! wroteOk)
+ return false;
+ }
+
+ if (numBytes < bufferSize)
+ {
+ memcpy (buffer + bytesInBuffer, src, numBytes);
+ bytesInBuffer += numBytes;
+ currentPosition += numBytes;
+ }
+ else
+ {
+ const int bytesWritten = juce_fileWrite (fileHandle, src, numBytes);
+ currentPosition += bytesWritten;
+
+ return bytesWritten == numBytes;
+ }
+ }
+
+ return true;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_FileOutputStream.cpp *********/
+
+/********* Start of inlined file: juce_FileSearchPath.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+FileSearchPath::FileSearchPath()
+{
+}
+
+FileSearchPath::FileSearchPath (const String& path)
+{
+ init (path);
+}
+
+FileSearchPath::FileSearchPath (const FileSearchPath& other)
+ : directories (other.directories)
+{
+}
+
+FileSearchPath::~FileSearchPath()
+{
+}
+
+const FileSearchPath& FileSearchPath::operator= (const String& path)
+{
+ init (path);
+ return *this;
+}
+
+void FileSearchPath::init (const String& path)
+{
+ directories.clear();
+ directories.addTokens (path, T(";"), T("\""));
+ directories.trim();
+ directories.removeEmptyStrings();
+
+ for (int i = directories.size(); --i >= 0;)
+ directories.set (i, directories[i].unquoted());
+}
+
+int FileSearchPath::getNumPaths() const
+{
+ return directories.size();
+}
+
+const File FileSearchPath::operator[] (const int index) const
+{
+ return File (directories [index]);
+}
+
+const String FileSearchPath::toString() const
+{
+ StringArray directories2 (directories);
+ for (int i = directories2.size(); --i >= 0;)
+ if (directories2[i].containsChar (T(';')))
+ directories2.set (i, directories2[i].quoted());
+
+ return directories2.joinIntoString (T(";"));
+}
+
+void FileSearchPath::add (const File& dir, const int insertIndex)
+{
+ directories.insert (insertIndex, dir.getFullPathName());
+}
+
+void FileSearchPath::addIfNotAlreadyThere (const File& dir)
+{
+ for (int i = 0; i < directories.size(); ++i)
+ if (File (directories[i]) == dir)
+ return;
+
+ add (dir);
+}
+
+void FileSearchPath::remove (const int index)
+{
+ directories.remove (index);
+}
+
+void FileSearchPath::addPath (const FileSearchPath& other)
+{
+ for (int i = 0; i < other.getNumPaths(); ++i)
+ addIfNotAlreadyThere (other[i]);
+}
+
+void FileSearchPath::removeRedundantPaths()
+{
+ for (int i = directories.size(); --i >= 0;)
+ {
+ const File d1 (directories[i]);
+
+ for (int j = directories.size(); --j >= 0;)
+ {
+ const File d2 (directories[j]);
+
+ if ((i != j) && (d1.isAChildOf (d2) || d1 == d2))
+ {
+ directories.remove (i);
+ break;
+ }
+ }
+ }
+}
+
+void FileSearchPath::removeNonExistentPaths()
+{
+ for (int i = directories.size(); --i >= 0;)
+ if (! File (directories[i]).isDirectory())
+ directories.remove (i);
+}
+
+int FileSearchPath::findChildFiles (OwnedArray& results,
+ const int whatToLookFor,
+ const bool searchRecursively,
+ const String& wildCardPattern) const
+{
+ int total = 0;
+
+ for (int i = 0; i < directories.size(); ++i)
+ total += operator[] (i).findChildFiles (results,
+ whatToLookFor,
+ searchRecursively,
+ wildCardPattern);
+
+ return total;
+}
+
+bool FileSearchPath::isFileInPath (const File& fileToCheck,
+ const bool checkRecursively) const
+{
+ for (int i = directories.size(); --i >= 0;)
+ {
+ const File d (directories[i]);
+
+ if (checkRecursively)
+ {
+ if (fileToCheck.isAChildOf (d))
+ return true;
+ }
+ else
+ {
+ if (fileToCheck.getParentDirectory() == d)
+ return true;
+ }
+ }
+
+ return false;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_FileSearchPath.cpp *********/
+
+/********* Start of inlined file: juce_NamedPipe.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+NamedPipe::NamedPipe()
+ : internal (0)
+{
+}
+
+NamedPipe::~NamedPipe()
+{
+ close();
+}
+
+bool NamedPipe::openExisting (const String& pipeName)
+{
+ currentPipeName = pipeName;
+ return openInternal (pipeName, false);
+}
+
+bool NamedPipe::createNewPipe (const String& pipeName)
+{
+ currentPipeName = pipeName;
+ return openInternal (pipeName, true);
+}
+
+bool NamedPipe::isOpen() const throw()
+{
+ return internal != 0;
+}
+
+const String NamedPipe::getName() const throw()
+{
+ return currentPipeName;
+}
+
+// other methods for this class are implemented in the platform-specific files
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_NamedPipe.cpp *********/
+
+/********* Start of inlined file: juce_Socket.cpp *********/
+#ifdef _WIN32
+
+ #include
+
+ #ifdef _MSC_VER
+ #pragma warning (disable : 4127 4389 4018)
+ #endif
+
+#else
+ #ifndef LINUX
+ #include
+ #endif
+
+ #include
+ #include
+ #include
+ #include
+ #include
+ #include
+ #include
+ #include
+ #include
+#endif
+
+BEGIN_JUCE_NAMESPACE
+
+#if JUCE_WIN32
+
+typedef int (__stdcall juce_CloseWin32SocketLibCall) (void);
+juce_CloseWin32SocketLibCall* juce_CloseWin32SocketLib = 0;
+
+static void initWin32Sockets()
+{
+ static CriticalSection lock;
+ const ScopedLock sl (lock);
+
+ if (juce_CloseWin32SocketLib == 0)
+ {
+ WSADATA wsaData;
+ const WORD wVersionRequested = MAKEWORD (1, 1);
+ WSAStartup (wVersionRequested, &wsaData);
+
+ juce_CloseWin32SocketLib = &WSACleanup;
+ }
+}
+
+#endif
+
+static bool resetSocketOptions (const int handle, const bool isDatagram) throw()
+{
+ if (handle <= 0)
+ return false;
+
+ const int sndBufSize = 65536;
+ const int rcvBufSize = 65536;
+ const int one = 1;
+
+ return setsockopt (handle, SOL_SOCKET, SO_RCVBUF, (const char*) &rcvBufSize, sizeof (int)) == 0
+ && setsockopt (handle, SOL_SOCKET, SO_SNDBUF, (const char*) &sndBufSize, sizeof (int)) == 0
+ && (isDatagram || (setsockopt (handle, IPPROTO_TCP, TCP_NODELAY, (const char*) &one, sizeof (int)) == 0));
+}
+
+static bool bindSocketToPort (const int handle, const int port) throw()
+{
+ if (handle == 0 || port <= 0)
+ return false;
+
+ struct sockaddr_in servTmpAddr;
+ zerostruct (servTmpAddr);
+ servTmpAddr.sin_family = PF_INET;
+ servTmpAddr.sin_addr.s_addr = htonl (INADDR_ANY);
+ servTmpAddr.sin_port = htons ((uint16) port);
+
+ return bind (handle, (struct sockaddr*) &servTmpAddr, sizeof (struct sockaddr_in)) >= 0;
+}
+
+static int readSocket (const int handle,
+ void* const destBuffer, const int maxBytesToRead,
+ bool volatile& connected) throw()
+{
+ int bytesRead = 0;
+
+ while (bytesRead < maxBytesToRead)
+ {
+ int bytesThisTime;
+
+#if JUCE_WIN32
+ bytesThisTime = recv (handle, ((char*) destBuffer) + bytesRead, maxBytesToRead - bytesRead, 0);
+#else
+ while ((bytesThisTime = ::read (handle, ((char*) destBuffer) + bytesRead, maxBytesToRead - bytesRead)) < 0
+ && errno == EINTR
+ && connected)
+ {
+ }
+#endif
+
+ if (bytesThisTime <= 0 || ! connected)
+ {
+ if (bytesRead == 0)
+ bytesRead = -1;
+
+ break;
+ }
+
+ bytesRead += bytesThisTime;
+ }
+
+ return bytesRead;
+}
+
+static int waitForReadiness (const int handle, const bool forReading,
+ const int timeoutMsecs) throw()
+{
+ struct timeval timeout;
+ struct timeval* timeoutp;
+
+ if (timeoutMsecs >= 0)
+ {
+ timeout.tv_sec = timeoutMsecs / 1000;
+ timeout.tv_usec = (timeoutMsecs % 1000) * 1000;
+ timeoutp = &timeout;
+ }
+ else
+ {
+ timeoutp = 0;
+ }
+
+ fd_set rset, wset;
+ FD_ZERO (&rset);
+ FD_SET (handle, &rset);
+ FD_ZERO (&wset);
+ FD_SET (handle, &wset);
+
+ fd_set* const prset = forReading ? &rset : 0;
+ fd_set* const pwset = forReading ? 0 : &wset;
+
+#if JUCE_WIN32
+ if (select (handle + 1, prset, pwset, 0, timeoutp) < 0)
+ return -1;
+#else
+ {
+ int result;
+ while ((result = select (handle + 1, prset, pwset, 0, timeoutp)) < 0
+ && errno == EINTR)
+ {
+ }
+
+ if (result < 0)
+ return -1;
+ }
+#endif
+
+ {
+ int opt;
+
+#if defined (JUCE_LINUX) || (defined (JUCE_MAC) && ! MACOS_10_2_OR_EARLIER)
+ socklen_t len = sizeof (opt);
+#else
+ int len = sizeof (opt);
+#endif
+
+ if (getsockopt (handle, SOL_SOCKET, SO_ERROR, (char*) &opt, &len) < 0
+ || opt != 0)
+ return -1;
+ }
+
+ if ((forReading && FD_ISSET (handle, &rset))
+ || ((! forReading) && FD_ISSET (handle, &wset)))
+ return 1;
+
+ return 0;
+}
+
+static bool setSocketBlockingState (const int handle, const bool shouldBlock) throw()
+{
+#if JUCE_WIN32
+ u_long nonBlocking = shouldBlock ? 0 : 1;
+
+ if (ioctlsocket (handle, FIONBIO, &nonBlocking) != 0)
+ return false;
+#else
+ int socketFlags = fcntl (handle, F_GETFL, 0);
+
+ if (socketFlags == -1)
+ return false;
+
+ if (shouldBlock)
+ socketFlags &= ~O_NONBLOCK;
+ else
+ socketFlags |= O_NONBLOCK;
+
+ if (fcntl (handle, F_SETFL, socketFlags) != 0)
+ return false;
+#endif
+
+ return true;
+}
+
+static bool connectSocket (int volatile& handle,
+ const bool isDatagram,
+ void** serverAddress,
+ const String& hostName,
+ const int portNumber,
+ const int timeOutMillisecs) throw()
+{
+ struct hostent* const hostEnt = gethostbyname (hostName);
+
+ if (hostEnt == 0)
+ return false;
+
+ struct in_addr targetAddress;
+ memcpy (&targetAddress.s_addr,
+ *(hostEnt->h_addr_list),
+ sizeof (targetAddress.s_addr));
+
+ struct sockaddr_in servTmpAddr;
+ zerostruct (servTmpAddr);
+ servTmpAddr.sin_family = PF_INET;
+ servTmpAddr.sin_addr = targetAddress;
+ servTmpAddr.sin_port = htons ((uint16) portNumber);
+
+ if (handle < 0)
+ handle = (int) socket (AF_INET, isDatagram ? SOCK_DGRAM : SOCK_STREAM, 0);
+
+ if (handle < 0)
+ return false;
+
+ if (isDatagram)
+ {
+ *serverAddress = new struct sockaddr_in();
+ *((struct sockaddr_in*) *serverAddress) = servTmpAddr;
+
+ return true;
+ }
+
+ setSocketBlockingState (handle, false);
+
+ const int result = ::connect (handle, (struct sockaddr*) &servTmpAddr, sizeof (struct sockaddr_in));
+
+ if (result < 0)
+ {
+#if JUCE_WIN32
+ if (result == SOCKET_ERROR && WSAGetLastError() == WSAEWOULDBLOCK)
+#else
+ if (errno == EINPROGRESS)
+#endif
+ {
+ if (waitForReadiness (handle, false, timeOutMillisecs) != 1)
+ {
+ setSocketBlockingState (handle, true);
+ return false;
+ }
+ }
+ }
+
+ setSocketBlockingState (handle, true);
+ resetSocketOptions (handle, false);
+
+ return true;
+}
+
+StreamingSocket::StreamingSocket()
+ : portNumber (0),
+ handle (-1),
+ connected (false),
+ isListener (false)
+{
+#if JUCE_WIN32
+ initWin32Sockets();
+#endif
+}
+
+StreamingSocket::StreamingSocket (const String& hostName_,
+ const int portNumber_,
+ const int handle_)
+ : hostName (hostName_),
+ portNumber (portNumber_),
+ handle (handle_),
+ connected (true),
+ isListener (false)
+{
+#if JUCE_WIN32
+ initWin32Sockets();
+#endif
+
+ resetSocketOptions (handle_, false);
+}
+
+StreamingSocket::~StreamingSocket()
+{
+ close();
+}
+
+int StreamingSocket::read (void* destBuffer, const int maxBytesToRead)
+{
+ return (connected && ! isListener) ? readSocket (handle, destBuffer, maxBytesToRead, connected)
+ : -1;
+}
+
+int StreamingSocket::write (const void* sourceBuffer, const int numBytesToWrite)
+{
+ if (isListener || ! connected)
+ return -1;
+
+#if JUCE_WIN32
+ return send (handle, (const char*) sourceBuffer, numBytesToWrite, 0);
+#else
+ int result;
+
+ while ((result = ::write (handle, sourceBuffer, numBytesToWrite)) < 0
+ && errno == EINTR)
+ {
+ }
+
+ return result;
+#endif
+}
+
+int StreamingSocket::waitUntilReady (const bool readyForReading,
+ const int timeoutMsecs) const
+{
+ return connected ? waitForReadiness (handle, readyForReading, timeoutMsecs)
+ : -1;
+}
+
+bool StreamingSocket::bindToPort (const int port)
+{
+ return bindSocketToPort (handle, port);
+}
+
+bool StreamingSocket::connect (const String& remoteHostName,
+ const int remotePortNumber,
+ const int timeOutMillisecs)
+{
+ if (isListener)
+ {
+ jassertfalse // a listener socket can't connect to another one!
+ return false;
+ }
+
+ if (connected)
+ close();
+
+ hostName = remoteHostName;
+ portNumber = remotePortNumber;
+ isListener = false;
+
+ connected = connectSocket (handle, false, 0, remoteHostName,
+ remotePortNumber, timeOutMillisecs);
+
+ if (! (connected && resetSocketOptions (handle, false)))
+ {
+ close();
+ return false;
+ }
+
+ return true;
+}
+
+void StreamingSocket::close()
+{
+#if JUCE_WIN32
+ closesocket (handle);
+ connected = false;
+#else
+ if (connected)
+ {
+ connected = false;
+
+ if (isListener)
+ {
+ // need to do this to interrupt the accept() function..
+ StreamingSocket temp;
+ temp.connect ("localhost", portNumber, 1000);
+ }
+ }
+
+ ::close (handle);
+#endif
+
+ hostName = String::empty;
+ portNumber = 0;
+ handle = -1;
+ isListener = false;
+}
+
+bool StreamingSocket::createListener (const int newPortNumber)
+{
+ if (connected)
+ close();
+
+ hostName = "listener";
+ portNumber = newPortNumber;
+ isListener = true;
+
+ struct sockaddr_in servTmpAddr;
+ zerostruct (servTmpAddr);
+ servTmpAddr.sin_family = PF_INET;
+ servTmpAddr.sin_addr.s_addr = htonl (INADDR_ANY);
+ servTmpAddr.sin_port = htons ((uint16) portNumber);
+
+ handle = (int) socket (AF_INET, SOCK_STREAM, 0);
+
+ if (handle < 0)
+ return false;
+
+ const int reuse = 1;
+ setsockopt (handle, SOL_SOCKET, SO_REUSEADDR, (const char*) &reuse, sizeof (reuse));
+
+ if (bind (handle, (struct sockaddr*) &servTmpAddr, sizeof (struct sockaddr_in)) < 0
+ || listen (handle, SOMAXCONN) < 0)
+ {
+ close();
+ return false;
+ }
+
+ connected = true;
+ return true;
+}
+
+StreamingSocket* StreamingSocket::waitForNextConnection() const
+{
+ jassert (isListener || ! connected); // to call this method, you first have to use createListener() to
+ // prepare this socket as a listener.
+
+ if (connected && isListener)
+ {
+ struct sockaddr address;
+
+#if defined (JUCE_LINUX) || (defined (JUCE_MAC) && ! MACOS_10_2_OR_EARLIER)
+ socklen_t len = sizeof (sockaddr);
+#else
+ int len = sizeof (sockaddr);
+#endif
+ const int newSocket = (int) accept (handle, &address, &len);
+
+ if (newSocket >= 0 && connected)
+ return new StreamingSocket (inet_ntoa (((struct sockaddr_in*) &address)->sin_addr),
+ portNumber, newSocket);
+ }
+
+ return 0;
+}
+
+bool StreamingSocket::isLocal() const throw()
+{
+ return hostName == T("127.0.0.1");
+}
+
+DatagramSocket::DatagramSocket (const int localPortNumber)
+ : portNumber (0),
+ handle (-1),
+ connected (false),
+ serverAddress (0)
+{
+#if JUCE_WIN32
+ initWin32Sockets();
+#endif
+
+ handle = (int) socket (AF_INET, SOCK_DGRAM, 0);
+ bindToPort (localPortNumber);
+}
+
+DatagramSocket::DatagramSocket (const String& hostName_, const int portNumber_,
+ const int handle_, const int localPortNumber)
+ : hostName (hostName_),
+ portNumber (portNumber_),
+ handle (handle_),
+ connected (true),
+ serverAddress (0)
+{
+#if JUCE_WIN32
+ initWin32Sockets();
+#endif
+
+ resetSocketOptions (handle_, true);
+ bindToPort (localPortNumber);
+}
+
+DatagramSocket::~DatagramSocket()
+{
+ close();
+
+ delete ((struct sockaddr_in*) serverAddress);
+ serverAddress = 0;
+}
+
+void DatagramSocket::close()
+{
+#if JUCE_WIN32
+ closesocket (handle);
+ connected = false;
+#else
+ connected = false;
+ ::close (handle);
+#endif
+
+ hostName = String::empty;
+ portNumber = 0;
+ handle = -1;
+}
+
+bool DatagramSocket::bindToPort (const int port)
+{
+ return bindSocketToPort (handle, port);
+}
+
+bool DatagramSocket::connect (const String& remoteHostName,
+ const int remotePortNumber,
+ const int timeOutMillisecs)
+{
+ if (connected)
+ close();
+
+ hostName = remoteHostName;
+ portNumber = remotePortNumber;
+
+ connected = connectSocket (handle, true, &serverAddress,
+ remoteHostName, remotePortNumber,
+ timeOutMillisecs);
+
+ if (! (connected && resetSocketOptions (handle, true)))
+ {
+ close();
+ return false;
+ }
+
+ return true;
+}
+
+DatagramSocket* DatagramSocket::waitForNextConnection() const
+{
+ struct sockaddr address;
+
+#if defined (JUCE_LINUX) || (defined (JUCE_MAC) && ! MACOS_10_2_OR_EARLIER)
+ socklen_t len = sizeof (sockaddr);
+#else
+ int len = sizeof (sockaddr);
+#endif
+
+ while (waitUntilReady (true, -1) == 1)
+ {
+ char buf[1];
+
+ if (recvfrom (handle, buf, 0, 0, &address, &len) > 0)
+ {
+ return new DatagramSocket (inet_ntoa (((struct sockaddr_in*) &address)->sin_addr),
+ ntohs (((struct sockaddr_in*) &address)->sin_port),
+ -1, -1);
+ }
+ }
+
+ return 0;
+}
+
+int DatagramSocket::waitUntilReady (const bool readyForReading,
+ const int timeoutMsecs) const
+{
+ return connected ? waitForReadiness (handle, readyForReading, timeoutMsecs)
+ : -1;
+}
+
+int DatagramSocket::read (void* destBuffer, const int maxBytesToRead)
+{
+ return connected ? readSocket (handle, destBuffer, maxBytesToRead, connected)
+ : -1;
+}
+
+int DatagramSocket::write (const void* sourceBuffer, const int numBytesToWrite)
+{
+ // You need to call connect() first to set the server address..
+ jassert (serverAddress != 0 && connected);
+
+ return connected ? sendto (handle, (const char*) sourceBuffer,
+ numBytesToWrite, 0,
+ (const struct sockaddr*) serverAddress,
+ sizeof (struct sockaddr_in))
+ : -1;
+}
+
+bool DatagramSocket::isLocal() const throw()
+{
+ return hostName == T("127.0.0.1");
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_Socket.cpp *********/
+
+/********* Start of inlined file: juce_URL.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+URL::URL() throw()
+{
+}
+
+URL::URL (const String& url_)
+ : url (url_)
+{
+ int i = url.indexOfChar (T('?'));
+
+ if (i >= 0)
+ {
+ do
+ {
+ const int nextAmp = url.indexOfChar (i + 1, T('&'));
+ const int equalsPos = url.indexOfChar (i + 1, T('='));
+
+ if (equalsPos > i + 1)
+ {
+ if (nextAmp < 0)
+ {
+ parameters.set (removeEscapeChars (url.substring (i + 1, equalsPos)),
+ removeEscapeChars (url.substring (equalsPos + 1)));
+ }
+ else if (nextAmp > 0 && equalsPos < nextAmp)
+ {
+ parameters.set (removeEscapeChars (url.substring (i + 1, equalsPos)),
+ removeEscapeChars (url.substring (equalsPos + 1, nextAmp)));
+ }
+ }
+
+ i = nextAmp;
+ }
+ while (i >= 0);
+
+ url = url.upToFirstOccurrenceOf (T("?"), false, false);
+ }
+}
+
+URL::URL (const URL& other)
+ : url (other.url),
+ parameters (other.parameters),
+ filesToUpload (other.filesToUpload),
+ mimeTypes (other.mimeTypes)
+{
+}
+
+const URL& URL::operator= (const URL& other)
+{
+ url = other.url;
+ parameters = other.parameters;
+ filesToUpload = other.filesToUpload;
+ mimeTypes = other.mimeTypes;
+
+ return *this;
+}
+
+URL::~URL() throw()
+{
+}
+
+static const String getMangledParameters (const StringPairArray& parameters)
+{
+ String p;
+
+ for (int i = 0; i < parameters.size(); ++i)
+ {
+ if (i > 0)
+ p += T("&");
+
+ p << URL::addEscapeChars (parameters.getAllKeys() [i])
+ << T("=")
+ << URL::addEscapeChars (parameters.getAllValues() [i]);
+ }
+
+ return p;
+}
+
+const String URL::toString (const bool includeGetParameters) const
+{
+ if (includeGetParameters && parameters.size() > 0)
+ return url + T("?") + getMangledParameters (parameters);
+ else
+ return url;
+}
+
+bool URL::isWellFormed() const
+{
+ //xxx TODO
+ return url.isNotEmpty();
+}
+
+bool URL::isProbablyAWebsiteURL (const String& possibleURL)
+{
+ return (possibleURL.containsChar (T('.'))
+ && (! possibleURL.containsChar (T('@')))
+ && (! possibleURL.endsWithChar (T('.')))
+ && (possibleURL.startsWithIgnoreCase (T("www."))
+ || possibleURL.startsWithIgnoreCase (T("http:"))
+ || possibleURL.startsWithIgnoreCase (T("ftp:"))
+ || possibleURL.endsWithIgnoreCase (T(".com"))
+ || possibleURL.endsWithIgnoreCase (T(".net"))
+ || possibleURL.endsWithIgnoreCase (T(".org"))
+ || possibleURL.endsWithIgnoreCase (T(".co.uk")))
+ || possibleURL.startsWithIgnoreCase (T("file:")));
+}
+
+bool URL::isProbablyAnEmailAddress (const String& possibleEmailAddress)
+{
+ const int atSign = possibleEmailAddress.indexOfChar (T('@'));
+
+ return atSign > 0
+ && possibleEmailAddress.lastIndexOfChar (T('.')) > (atSign + 1)
+ && (! possibleEmailAddress.endsWithChar (T('.')));
+}
+
+void* juce_openInternetFile (const String& url,
+ const String& headers,
+ const MemoryBlock& optionalPostData,
+ const bool isPost,
+ URL::OpenStreamProgressCallback* callback,
+ void* callbackContext);
+
+void juce_closeInternetFile (void* handle);
+int juce_readFromInternetFile (void* handle, void* dest, int bytesToRead);
+int juce_seekInInternetFile (void* handle, int newPosition);
+
+class WebInputStream : public InputStream
+{
+public:
+
+ WebInputStream (const URL& url,
+ const bool isPost_,
+ URL::OpenStreamProgressCallback* const progressCallback_,
+ void* const progressCallbackContext_)
+ : position (0),
+ finished (false),
+ isPost (isPost_),
+ progressCallback (progressCallback_),
+ progressCallbackContext (progressCallbackContext_)
+ {
+ server = url.toString (! isPost);
+
+ if (isPost_)
+ createHeadersAndPostData (url);
+
+ handle = juce_openInternetFile (server, headers, postData, isPost,
+ progressCallback_, progressCallbackContext_);
+ }
+
+ ~WebInputStream()
+ {
+ juce_closeInternetFile (handle);
+ }
+
+ bool isError() const throw()
+ {
+ return handle == 0;
+ }
+
+ int64 getTotalLength()
+ {
+ return -1;
+ }
+
+ bool isExhausted()
+ {
+ return finished;
+ }
+
+ int read (void* dest, int bytes)
+ {
+ if (finished || isError())
+ {
+ return 0;
+ }
+ else
+ {
+ const int bytesRead = juce_readFromInternetFile (handle, dest, bytes);
+ position += bytesRead;
+
+ if (bytesRead == 0)
+ finished = true;
+
+ return bytesRead;
+ }
+ }
+
+ int64 getPosition()
+ {
+ return position;
+ }
+
+ bool setPosition (int64 wantedPos)
+ {
+ if (wantedPos != position)
+ {
+ finished = false;
+
+ const int actualPos = juce_seekInInternetFile (handle, (int) wantedPos);
+
+ if (actualPos == wantedPos)
+ {
+ position = wantedPos;
+ }
+ else
+ {
+ if (wantedPos < position)
+ {
+ juce_closeInternetFile (handle);
+
+ position = 0;
+ finished = false;
+
+ handle = juce_openInternetFile (server, headers, postData, isPost,
+ progressCallback, progressCallbackContext);
+ }
+
+ skipNextBytes (wantedPos - position);
+ }
+ }
+
+ return true;
+ }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ String server, headers;
+ MemoryBlock postData;
+ int64 position;
+ bool finished;
+ const bool isPost;
+ void* handle;
+ URL::OpenStreamProgressCallback* const progressCallback;
+ void* const progressCallbackContext;
+
+ void createHeadersAndPostData (const URL& url)
+ {
+ if (url.getFilesToUpload().size() > 0)
+ {
+ // need to upload some files, so do it as multi-part...
+ String boundary (String::toHexString (Random::getSystemRandom().nextInt64()));
+
+ headers << "Content-Type: multipart/form-data; boundary=" << boundary << "\r\n";
+
+ appendUTF8ToPostData ("--" + boundary);
+
+ int i;
+ for (i = 0; i < url.getParameters().size(); ++i)
+ {
+ String s;
+ s << "\r\nContent-Disposition: form-data; name=\""
+ << url.getParameters().getAllKeys() [i]
+ << "\"\r\n\r\n"
+ << url.getParameters().getAllValues() [i]
+ << "\r\n--"
+ << boundary;
+
+ appendUTF8ToPostData (s);
+ }
+
+ for (i = 0; i < url.getFilesToUpload().size(); ++i)
+ {
+ const File f (url.getFilesToUpload().getAllValues() [i]);
+ const String paramName (url.getFilesToUpload().getAllKeys() [i]);
+
+ String s;
+ s << "\r\nContent-Disposition: form-data; name=\""
+ << paramName
+ << "\"; filename=\""
+ << f.getFileName()
+ << "\"\r\n";
+
+ const String mimeType (url.getMimeTypesOfUploadFiles()
+ .getValue (paramName, String::empty));
+
+ if (mimeType.isNotEmpty())
+ s << "Content-Type: " << mimeType << "\r\n";
+
+ s << "Content-Transfer-Encoding: binary\r\n\r\n";
+
+ appendUTF8ToPostData (s);
+
+ f.loadFileAsData (postData);
+
+ s = "\r\n--" + boundary;
+
+ appendUTF8ToPostData (s);
+ }
+
+ appendUTF8ToPostData ("--\r\n");
+ }
+ else
+ {
+ // just a short text attachment, so use simple url encoding..
+ const String params (getMangledParameters (url.getParameters()));
+
+ headers = "Content-Type: application/x-www-form-urlencoded\r\nContent-length: "
+ + String ((int) strlen (params.toUTF8()))
+ + "\r\n";
+
+ appendUTF8ToPostData (params);
+ }
+ }
+
+ void appendUTF8ToPostData (const String& text) throw()
+ {
+ postData.append (text.toUTF8(),
+ (int) strlen (text.toUTF8()));
+ }
+
+ WebInputStream (const WebInputStream&);
+ const WebInputStream& operator= (const WebInputStream&);
+};
+
+InputStream* URL::createInputStream (const bool usePostCommand,
+ OpenStreamProgressCallback* const progressCallback,
+ void* const progressCallbackContext) const
+{
+ WebInputStream* wi = new WebInputStream (*this, usePostCommand,
+ progressCallback, progressCallbackContext);
+
+ if (wi->isError())
+ {
+ delete wi;
+ wi = 0;
+ }
+
+ return wi;
+}
+
+bool URL::readEntireBinaryStream (MemoryBlock& destData,
+ const bool usePostCommand) const
+{
+ InputStream* const in = createInputStream (usePostCommand);
+
+ if (in != 0)
+ {
+ in->readIntoMemoryBlock (destData, -1);
+ delete in;
+
+ return true;
+ }
+
+ return false;
+}
+
+const String URL::readEntireTextStream (const bool usePostCommand) const
+{
+ String result;
+ InputStream* const in = createInputStream (usePostCommand);
+
+ if (in != 0)
+ {
+ result = in->readEntireStreamAsString();
+ delete in;
+ }
+
+ return result;
+}
+
+XmlElement* URL::readEntireXmlStream (const bool usePostCommand) const
+{
+ XmlDocument doc (readEntireTextStream (usePostCommand));
+ return doc.getDocumentElement();
+}
+
+const URL URL::withParameter (const String& parameterName,
+ const String& parameterValue) const
+{
+ URL u (*this);
+ u.parameters.set (parameterName, parameterValue);
+ return u;
+}
+
+const URL URL::withFileToUpload (const String& parameterName,
+ const File& fileToUpload,
+ const String& mimeType) const
+{
+ URL u (*this);
+ u.filesToUpload.set (parameterName, fileToUpload.getFullPathName());
+ u.mimeTypes.set (parameterName, mimeType);
+ return u;
+}
+
+const StringPairArray& URL::getParameters() const throw()
+{
+ return parameters;
+}
+
+const StringPairArray& URL::getFilesToUpload() const throw()
+{
+ return filesToUpload;
+}
+
+const StringPairArray& URL::getMimeTypesOfUploadFiles() const throw()
+{
+ return mimeTypes;
+}
+
+const String URL::removeEscapeChars (const String& s)
+{
+ const int len = s.length();
+ uint8* const resultUTF8 = (uint8*) juce_calloc (len * 4);
+ uint8* r = resultUTF8;
+
+ for (int i = 0; i < len; ++i)
+ {
+ char c = (char) s[i];
+ if (c == 0)
+ break;
+
+ if (c == '+')
+ {
+ c = ' ';
+ }
+ else if (c == '%')
+ {
+ c = (char) s.substring (i + 1, i + 3).getHexValue32();
+ i += 2;
+ }
+
+ *r++ = c;
+ }
+
+ const String stringResult (String::fromUTF8 (resultUTF8));
+ juce_free (resultUTF8);
+ return stringResult;
+}
+
+const String URL::addEscapeChars (const String& s)
+{
+ String result;
+ result.preallocateStorage (s.length() + 8);
+ const char* utf8 = s.toUTF8();
+
+ while (*utf8 != 0)
+ {
+ const char c = *utf8++;
+
+ if (c == ' ')
+ {
+ result += T('+');
+ }
+ else if (CharacterFunctions::isLetterOrDigit (c)
+ || CharacterFunctions::indexOfChar ("_-$.*!'(),", c, false) >= 0)
+ {
+ result << c;
+ }
+ else
+ {
+ const int v = (int) (uint8) c;
+
+ if (v < 0x10)
+ result << T("%0");
+ else
+ result << T('%');
+
+ result << String::toHexString (v);
+ }
+ }
+
+ return result;
+}
+
+extern bool juce_launchFile (const String& fileName,
+ const String& parameters) throw();
+
+bool URL::launchInDefaultBrowser() const
+{
+ String u (toString (true));
+
+ if (u.contains (T("@")) && ! u.contains (T(":")))
+ u = "mailto:" + u;
+
+ return juce_launchFile (u, String::empty);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_URL.cpp *********/
+
+/********* Start of inlined file: juce_BufferedInputStream.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+BufferedInputStream::BufferedInputStream (InputStream* const source_,
+ const int bufferSize_,
+ const bool deleteSourceWhenDestroyed_) throw()
+ : source (source_),
+ deleteSourceWhenDestroyed (deleteSourceWhenDestroyed_),
+ bufferSize (jmax (256, bufferSize_)),
+ position (source_->getPosition()),
+ lastReadPos (0),
+ bufferOverlap (128)
+{
+ const int sourceSize = (int) source_->getTotalLength();
+ if (sourceSize >= 0)
+ bufferSize = jmin (jmax (32, sourceSize), bufferSize);
+
+ bufferStart = position;
+ buffer = (char*) juce_malloc (bufferSize);
+}
+
+BufferedInputStream::~BufferedInputStream() throw()
+{
+ if (deleteSourceWhenDestroyed)
+ delete source;
+
+ juce_free (buffer);
+}
+
+int64 BufferedInputStream::getTotalLength()
+{
+ return source->getTotalLength();
+}
+
+int64 BufferedInputStream::getPosition()
+{
+ return position;
+}
+
+bool BufferedInputStream::setPosition (int64 newPosition)
+{
+ position = jmax ((int64) 0, newPosition);
+ return true;
+}
+
+bool BufferedInputStream::isExhausted()
+{
+ return (position >= lastReadPos)
+ && source->isExhausted();
+}
+
+void BufferedInputStream::ensureBuffered()
+{
+ const int64 bufferEndOverlap = lastReadPos - bufferOverlap;
+
+ if (position < bufferStart || position >= bufferEndOverlap)
+ {
+ int bytesRead;
+
+ if (position < lastReadPos
+ && position >= bufferEndOverlap
+ && position >= bufferStart)
+ {
+ const int bytesToKeep = (int) (lastReadPos - position);
+ memmove (buffer, buffer + position - bufferStart, bytesToKeep);
+
+ bufferStart = position;
+
+ bytesRead = source->read (buffer + bytesToKeep,
+ bufferSize - bytesToKeep);
+
+ lastReadPos += bytesRead;
+ bytesRead += bytesToKeep;
+ }
+ else
+ {
+ bufferStart = position;
+ source->setPosition (bufferStart);
+ bytesRead = source->read (buffer, bufferSize);
+ lastReadPos = bufferStart + bytesRead;
+ }
+
+ while (bytesRead < bufferSize)
+ buffer [bytesRead++] = 0;
+ }
+}
+
+int BufferedInputStream::read (void* destBuffer, int maxBytesToRead)
+{
+ if (position >= bufferStart
+ && position + maxBytesToRead < lastReadPos)
+ {
+ memcpy (destBuffer, buffer + (position - bufferStart), maxBytesToRead);
+ position += maxBytesToRead;
+
+ return maxBytesToRead;
+ }
+ else
+ {
+ int bytesRead = 0;
+
+ while (maxBytesToRead > 0)
+ {
+ ensureBuffered();
+
+ if (isExhausted())
+ break;
+
+ const int bytesAvailable = jmin (maxBytesToRead, (int) (lastReadPos - position));
+ memcpy (destBuffer, buffer + (position - bufferStart), bytesAvailable);
+ maxBytesToRead -= bytesAvailable;
+ bytesRead += bytesAvailable;
+ position += bytesAvailable;
+ destBuffer = (void*) (((char*) destBuffer) + bytesAvailable);
+ }
+
+ return bytesRead;
+ }
+}
+
+const String BufferedInputStream::readString()
+{
+ if (position >= bufferStart
+ && position < lastReadPos)
+ {
+ const int maxChars = (int) (lastReadPos - position);
+
+ const char* const src = buffer + (position - bufferStart);
+
+ for (int i = 0; i < maxChars; ++i)
+ {
+ if (src[i] == 0)
+ {
+ position += i + 1;
+
+ return String::fromUTF8 ((const uint8*) src, i);
+ }
+ }
+ }
+
+ return InputStream::readString();
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_BufferedInputStream.cpp *********/
+
+/********* Start of inlined file: juce_FileInputSource.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+FileInputSource::FileInputSource (const File& file_) throw()
+ : file (file_)
+{
+}
+
+FileInputSource::~FileInputSource()
+{
+}
+
+InputStream* FileInputSource::createInputStream()
+{
+ return file.createInputStream();
+}
+
+InputStream* FileInputSource::createInputStreamFor (const String& relatedItemPath)
+{
+ return file.getSiblingFile (relatedItemPath).createInputStream();
+}
+
+int64 FileInputSource::hashCode() const
+{
+ return file.hashCode();
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_FileInputSource.cpp *********/
+
+/********* Start of inlined file: juce_MemoryInputStream.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+MemoryInputStream::MemoryInputStream (const void* const sourceData,
+ const int sourceDataSize,
+ const bool keepInternalCopy) throw()
+ : data ((const char*) sourceData),
+ dataSize (sourceDataSize),
+ position (0)
+{
+ if (keepInternalCopy)
+ {
+ internalCopy.append (data, sourceDataSize);
+ data = (const char*) internalCopy.getData();
+ }
+}
+
+MemoryInputStream::~MemoryInputStream() throw()
+{
+}
+
+int64 MemoryInputStream::getTotalLength()
+{
+ return dataSize;
+}
+
+int MemoryInputStream::read (void* buffer, int howMany)
+{
+ const int num = jmin (howMany, dataSize - position);
+ memcpy (buffer, data + position, num);
+ position += num;
+ return num;
+}
+
+bool MemoryInputStream::isExhausted()
+{
+ return (position >= dataSize);
+}
+
+bool MemoryInputStream::setPosition (int64 pos)
+{
+ position = (int) jlimit ((int64) 0, (int64) dataSize, pos);
+
+ return true;
+}
+
+int64 MemoryInputStream::getPosition()
+{
+ return position;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_MemoryInputStream.cpp *********/
+
+/********* Start of inlined file: juce_MemoryOutputStream.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+MemoryOutputStream::MemoryOutputStream (const int initialSize,
+ const int blockSizeToIncreaseBy,
+ MemoryBlock* const memoryBlockToWriteTo) throw()
+ : data (memoryBlockToWriteTo),
+ position (0),
+ size (0),
+ blockSize (jmax (16, blockSizeToIncreaseBy)),
+ ownsMemoryBlock (memoryBlockToWriteTo == 0)
+{
+ if (memoryBlockToWriteTo == 0)
+ data = new MemoryBlock (initialSize);
+ else
+ memoryBlockToWriteTo->setSize (initialSize, false);
+}
+
+MemoryOutputStream::~MemoryOutputStream() throw()
+{
+ if (ownsMemoryBlock)
+ delete data;
+ else
+ flush();
+}
+
+void MemoryOutputStream::flush()
+{
+ if (! ownsMemoryBlock)
+ data->setSize (size, false);
+}
+
+void MemoryOutputStream::reset() throw()
+{
+ position = 0;
+ size = 0;
+}
+
+bool MemoryOutputStream::write (const void* buffer, int howMany)
+{
+ int storageNeeded = position + howMany + 1;
+ storageNeeded = storageNeeded - (storageNeeded % blockSize) + blockSize;
+
+ data->ensureSize (storageNeeded);
+ data->copyFrom (buffer, position, howMany);
+ position += howMany;
+ size = jmax (size, position);
+
+ return true;
+}
+
+const char* MemoryOutputStream::getData() throw()
+{
+ if (data->getSize() > size)
+ ((char*) data->getData()) [size] = 0;
+
+ return (const char*) data->getData();
+}
+
+int MemoryOutputStream::getDataSize() const throw()
+{
+ return size;
+}
+
+int64 MemoryOutputStream::getPosition()
+{
+ return position;
+}
+
+bool MemoryOutputStream::setPosition (int64 newPosition)
+{
+ if (newPosition <= size)
+ {
+ // ok to seek backwards
+ position = jlimit (0, size, (int) newPosition);
+ return true;
+ }
+ else
+ {
+ // trying to make it bigger isn't a good thing to do..
+ return false;
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_MemoryOutputStream.cpp *********/
+
+/********* Start of inlined file: juce_SubregionStream.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+SubregionStream::SubregionStream (InputStream* const sourceStream,
+ const int64 startPositionInSourceStream_,
+ const int64 lengthOfSourceStream_,
+ const bool deleteSourceWhenDestroyed_) throw()
+ : source (sourceStream),
+ deleteSourceWhenDestroyed (deleteSourceWhenDestroyed_),
+ startPositionInSourceStream (startPositionInSourceStream_),
+ lengthOfSourceStream (lengthOfSourceStream_)
+{
+ setPosition (0);
+}
+
+SubregionStream::~SubregionStream() throw()
+{
+ if (deleteSourceWhenDestroyed)
+ delete source;
+}
+
+int64 SubregionStream::getTotalLength()
+{
+ const int64 srcLen = source->getTotalLength() - startPositionInSourceStream;
+
+ return (lengthOfSourceStream >= 0) ? jmin (lengthOfSourceStream, srcLen)
+ : srcLen;
+}
+
+int64 SubregionStream::getPosition()
+{
+ return source->getPosition() - startPositionInSourceStream;
+}
+
+bool SubregionStream::setPosition (int64 newPosition)
+{
+ return source->setPosition (jmax ((int64) 0, newPosition + startPositionInSourceStream));
+}
+
+int SubregionStream::read (void* destBuffer, int maxBytesToRead)
+{
+ if (lengthOfSourceStream < 0)
+ {
+ return source->read (destBuffer, maxBytesToRead);
+ }
+ else
+ {
+ maxBytesToRead = (int) jmin ((int64) maxBytesToRead, lengthOfSourceStream - getPosition());
+
+ if (maxBytesToRead <= 0)
+ return 0;
+
+ return source->read (destBuffer, maxBytesToRead);
+ }
+}
+
+bool SubregionStream::isExhausted()
+{
+ if (lengthOfSourceStream >= 0)
+ return (getPosition() >= lengthOfSourceStream) || source->isExhausted();
+ else
+ return source->isExhausted();
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_SubregionStream.cpp *********/
+
+/********* Start of inlined file: juce_PerformanceCounter.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+PerformanceCounter::PerformanceCounter (const String& name_,
+ int runsPerPrintout,
+ const File& loggingFile)
+ : name (name_),
+ numRuns (0),
+ runsPerPrint (runsPerPrintout),
+ totalTime (0),
+ outputFile (loggingFile)
+{
+ if (outputFile != File::nonexistent)
+ {
+ String s ("**** Counter for \"");
+ s << name_ << "\" started at: "
+ << Time::getCurrentTime().toString (true, true)
+ << "\r\n";
+
+ outputFile.appendText (s, false, false);
+ }
+}
+
+PerformanceCounter::~PerformanceCounter()
+{
+ printStatistics();
+}
+
+void PerformanceCounter::start()
+{
+ started = Time::getHighResolutionTicks();
+}
+
+void PerformanceCounter::stop()
+{
+ const int64 now = Time::getHighResolutionTicks();
+
+ totalTime += 1000.0 * Time::highResolutionTicksToSeconds (now - started);
+
+ if (++numRuns == runsPerPrint)
+ printStatistics();
+}
+
+void PerformanceCounter::printStatistics()
+{
+ if (numRuns > 0)
+ {
+ String s ("Performance count for \"");
+ s << name << "\" - average over " << numRuns << " run(s) = ";
+
+ const int micros = (int) (totalTime * (1000.0 / numRuns));
+
+ if (micros > 10000)
+ s << (micros/1000) << " millisecs";
+ else
+ s << micros << " microsecs";
+
+ s << ", total = " << String (totalTime / 1000, 5) << " seconds";
+
+ Logger::outputDebugString (s);
+
+ s << "\r\n";
+
+ if (outputFile != File::nonexistent)
+ outputFile.appendText (s, false, false);
+
+ numRuns = 0;
+ totalTime = 0;
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_PerformanceCounter.cpp *********/
+
+/********* Start of inlined file: juce_Uuid.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+Uuid::Uuid()
+{
+ // do some serious mixing up of our MAC addresses and different types of time info,
+ // plus a couple of passes of pseudo-random numbers over the whole thing.
+ SystemStats::getMACAddresses (value.asInt64, 2);
+
+ int i;
+ for (i = 16; --i >= 0;)
+ {
+ Random r (Time::getHighResolutionTicks()
+ + Random::getSystemRandom().nextInt()
+ + value.asInt [i & 3]);
+
+ value.asBytes[i] ^= (uint8) r.nextInt();
+ }
+
+ value.asInt64 [0] ^= Time::getHighResolutionTicks();
+ value.asInt64 [1] ^= Time::currentTimeMillis();
+
+ for (i = 4; --i >= 0;)
+ {
+ Random r (Time::getHighResolutionTicks() ^ value.asInt[i]);
+ value.asInt[i] ^= r.nextInt();
+ }
+}
+
+Uuid::~Uuid() throw()
+{
+}
+
+Uuid::Uuid (const Uuid& other)
+ : value (other.value)
+{
+}
+
+Uuid& Uuid::operator= (const Uuid& other)
+{
+ if (this != &other)
+ value = other.value;
+
+ return *this;
+}
+
+bool Uuid::operator== (const Uuid& other) const
+{
+ return memcmp (value.asBytes, other.value.asBytes, 16) == 0;
+}
+
+bool Uuid::operator!= (const Uuid& other) const
+{
+ return ! operator== (other);
+}
+
+bool Uuid::isNull() const throw()
+{
+ return (value.asInt64 [0] == 0) && (value.asInt64 [1] == 0);
+}
+
+const String Uuid::toString() const
+{
+ return String::toHexString (value.asBytes, 16, 0);
+}
+
+Uuid::Uuid (const String& uuidString)
+{
+ operator= (uuidString);
+}
+
+Uuid& Uuid::operator= (const String& uuidString)
+{
+ int destIndex = 0;
+ int i = 0;
+
+ for (;;)
+ {
+ int byte = 0;
+
+ for (int loop = 2; --loop >= 0;)
+ {
+ byte <<= 4;
+
+ for (;;)
+ {
+ const tchar c = uuidString [i++];
+
+ if (c >= T('0') && c <= T('9'))
+ {
+ byte |= c - T('0');
+ break;
+ }
+ else if (c >= T('a') && c <= T('z'))
+ {
+ byte |= c - (T('a') - 10);
+ break;
+ }
+ else if (c >= T('A') && c <= T('Z'))
+ {
+ byte |= c - (T('A') - 10);
+ break;
+ }
+ else if (c == 0)
+ {
+ while (destIndex < 16)
+ value.asBytes [destIndex++] = 0;
+
+ return *this;
+ }
+ }
+ }
+
+ value.asBytes [destIndex++] = (uint8) byte;
+ }
+}
+
+Uuid::Uuid (const uint8* const rawData)
+{
+ operator= (rawData);
+}
+
+Uuid& Uuid::operator= (const uint8* const rawData)
+{
+ if (rawData != 0)
+ memcpy (value.asBytes, rawData, 16);
+ else
+ zeromem (value.asBytes, 16);
+
+ return *this;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_Uuid.cpp *********/
+
+/********* Start of inlined file: juce_ZipFile.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+struct ZipEntryInfo
+{
+ ZipFile::ZipEntry entry;
+ int streamOffset;
+ int compressedSize;
+ bool compressed;
+};
+
+class ZipInputStream : public InputStream
+{
+public:
+
+ ZipInputStream (ZipFile& file_,
+ ZipEntryInfo& zei) throw()
+ : file (file_),
+ zipEntryInfo (zei),
+ pos (0),
+ headerSize (0)
+ {
+ char buffer [30];
+
+ if (file.source->setPosition (zei.streamOffset)
+ && file.source->read (buffer, 30) == 30
+ && littleEndianInt (buffer) == 0x04034b50)
+ {
+ headerSize = 30 + littleEndianShort (buffer + 26)
+ + littleEndianShort (buffer + 28);
+ }
+
+ if (! file_.isFromCustomStream)
+ {
+ source = file_.sourceFile.createInputStream();
+ }
+ else
+ {
+ source = 0;
+#ifdef JUCE_DEBUG
+ file_.numOpenStreams++;
+#endif
+ }
+ }
+
+ ~ZipInputStream() throw()
+ {
+#ifdef JUCE_DEBUG
+ if (source == 0)
+ file.numOpenStreams--;
+#endif
+
+ delete source;
+ }
+
+ int64 getTotalLength() throw()
+ {
+ return zipEntryInfo.compressedSize;
+ }
+
+ int read (void* buffer, int howMany) throw()
+ {
+ if (headerSize <= 0)
+ return 0;
+
+ howMany = (int) jmin ((int64) howMany, zipEntryInfo.compressedSize - pos);
+ int num;
+
+ if (source != 0)
+ {
+ source->setPosition (pos + zipEntryInfo.streamOffset + headerSize);
+ num = source->read (buffer, howMany);
+ }
+ else
+ {
+ const ScopedLock sl (file.lock);
+
+ file.source->setPosition (pos + zipEntryInfo.streamOffset + headerSize);
+ num = file.source->read (buffer, howMany);
+ }
+
+ pos += num;
+ return num;
+ }
+
+ bool isExhausted() throw()
+ {
+ return pos >= zipEntryInfo.compressedSize;
+ }
+
+ int64 getPosition() throw()
+ {
+ return pos;
+ }
+
+ bool setPosition (int64 newPos) throw()
+ {
+ pos = jlimit ((int64) 0, (int64) zipEntryInfo.compressedSize, newPos);
+ return true;
+ }
+
+private:
+
+ ZipFile& file;
+ ZipEntryInfo zipEntryInfo;
+ int64 pos;
+ int headerSize;
+ InputStream* source;
+
+ ZipInputStream (const ZipInputStream&);
+ const ZipInputStream& operator= (const ZipInputStream&);
+};
+
+ZipFile::ZipFile (InputStream* const source_,
+ const bool deleteStreamWhenDestroyed_) throw()
+ : source (source_),
+ isFromCustomStream (true),
+ deleteStreamWhenDestroyed (deleteStreamWhenDestroyed_)
+#ifdef JUCE_DEBUG
+ , numOpenStreams (0)
+#endif
+{
+ init();
+}
+
+ZipFile::ZipFile (const File& file)
+ : sourceFile (file),
+ isFromCustomStream (false),
+ deleteStreamWhenDestroyed (true)
+#ifdef JUCE_DEBUG
+ , numOpenStreams (0)
+#endif
+{
+ source = file.createInputStream();
+ init();
+}
+
+ZipFile::~ZipFile() throw()
+{
+ for (int i = entries.size(); --i >= 0;)
+ {
+ ZipEntryInfo* const zei = (ZipEntryInfo*) entries [i];
+ delete zei;
+ }
+
+ if (deleteStreamWhenDestroyed && (source != 0))
+ delete source;
+
+#ifdef JUCE_DEBUG
+ // If you hit this assertion, it means you've created a stream to read
+ // one of the items in the zipfile, but you've forgotten to delete that
+ // stream object before deleting the file.. Streams can't be kept open
+ // after the file is deleted because they need to share the input
+ // stream that the file uses to read itself.
+ jassert (numOpenStreams == 0);
+#endif
+}
+
+int ZipFile::getNumEntries() const throw()
+{
+ return entries.size();
+}
+
+const ZipFile::ZipEntry* ZipFile::getEntry (const int index) const throw()
+{
+ ZipEntryInfo* const zei = (ZipEntryInfo*) entries [index];
+
+ return (zei != 0) ? &(zei->entry)
+ : 0;
+}
+
+int ZipFile::getIndexOfFileName (const String& fileName) const throw()
+{
+ for (int i = 0; i < entries.size(); ++i)
+ if (((ZipEntryInfo*) entries.getUnchecked (i))->entry.filename == fileName)
+ return i;
+
+ return -1;
+}
+
+const ZipFile::ZipEntry* ZipFile::getEntry (const String& fileName) const throw()
+{
+ return getEntry (getIndexOfFileName (fileName));
+}
+
+InputStream* ZipFile::createStreamForEntry (const int index)
+{
+ ZipEntryInfo* const zei = (ZipEntryInfo*) entries[index];
+
+ InputStream* stream = 0;
+
+ if (zei != 0)
+ {
+ stream = new ZipInputStream (*this, *zei);
+
+ if (zei->compressed)
+ {
+ stream = new GZIPDecompressorInputStream (stream, true, true,
+ zei->entry.uncompressedSize);
+
+ // (much faster to unzip in big blocks using a buffer..)
+ stream = new BufferedInputStream (stream, 32768, true);
+ }
+ }
+
+ return stream;
+}
+
+class ZipFilenameComparator
+{
+public:
+ static int compareElements (const void* const first, const void* const second) throw()
+ {
+ return ((const ZipEntryInfo*) first)->entry.filename
+ .compare (((const ZipEntryInfo*) second)->entry.filename);
+ }
+};
+
+void ZipFile::sortEntriesByFilename()
+{
+ ZipFilenameComparator sorter;
+ entries.sort (sorter);
+}
+
+void ZipFile::init()
+{
+ if (source != 0)
+ {
+ numEntries = 0;
+ int pos = findEndOfZipEntryTable();
+ int size = (int) (source->getTotalLength() - pos);
+
+ source->setPosition (pos);
+ MemoryBlock headerData;
+
+ if (source->readIntoMemoryBlock (headerData, size) != size)
+ return;
+
+ pos = 0;
+
+ for (int i = 0; i < numEntries; ++i)
+ {
+ if (pos + 46 > size)
+ break;
+
+ const char* const buffer = ((const char*) headerData.getData()) + pos;
+
+ const int fileNameLen = littleEndianShort (buffer + 28);
+
+ if (pos + 46 + fileNameLen > size)
+ break;
+
+ ZipEntryInfo* const zei = new ZipEntryInfo();
+ zei->entry.filename = String (buffer + 46, fileNameLen);
+
+ const int time = littleEndianShort (buffer + 12);
+ const int date = littleEndianShort (buffer + 14);
+
+ const int year = 1980 + (date >> 9);
+ const int month = ((date >> 5) & 15) - 1;
+ const int day = date & 31;
+ const int hours = time >> 11;
+ const int minutes = (time >> 5) & 63;
+ const int seconds = (time & 31) << 1;
+
+ zei->entry.fileTime = Time (year, month, day, hours, minutes, seconds);
+
+ zei->compressed = littleEndianShort (buffer + 10) != 0;
+ zei->compressedSize = littleEndianInt (buffer + 20);
+ zei->entry.uncompressedSize = littleEndianInt (buffer + 24);
+
+ zei->streamOffset = littleEndianInt (buffer + 42);
+ entries.add (zei);
+
+ pos += 46 + fileNameLen
+ + littleEndianShort (buffer + 30)
+ + littleEndianShort (buffer + 32);
+ }
+ }
+}
+
+int ZipFile::findEndOfZipEntryTable()
+{
+ BufferedInputStream in (source, 8192, false);
+
+ in.setPosition (in.getTotalLength());
+ int64 pos = in.getPosition();
+
+ char buffer [32];
+ zeromem (buffer, sizeof (buffer));
+
+ while (pos > 0)
+ {
+ in.setPosition (pos - 22);
+ pos = in.getPosition();
+ memcpy (buffer + 22, buffer, 4);
+
+ if (in.read (buffer, 22) != 22)
+ return 0;
+
+ for (int i = 0; i < 22; ++i)
+ {
+ if (littleEndianInt (buffer + i) == 0x06054b50)
+ {
+ in.setPosition (pos + i);
+ in.read (buffer, 22);
+ numEntries = littleEndianShort (buffer + 10);
+
+ return littleEndianInt (buffer + 16);
+ }
+ }
+ }
+
+ return 0;
+}
+
+void ZipFile::uncompressTo (const File& targetDirectory,
+ const bool shouldOverwriteFiles)
+{
+ for (int i = 0; i < entries.size(); ++i)
+ {
+ const ZipEntryInfo& zei = *(ZipEntryInfo*) entries[i];
+
+ const File targetFile (targetDirectory.getChildFile (zei.entry.filename));
+
+ if (zei.entry.filename.endsWithChar (T('/')))
+ {
+ targetFile.createDirectory(); // (entry is a directory, not a file)
+ }
+ else
+ {
+ InputStream* const in = createStreamForEntry (i);
+
+ if (in != 0)
+ {
+ if (shouldOverwriteFiles)
+ targetFile.deleteFile();
+
+ if ((! targetFile.exists())
+ && targetFile.getParentDirectory().createDirectory())
+ {
+ FileOutputStream* const out = targetFile.createOutputStream();
+
+ if (out != 0)
+ {
+ out->writeFromInputStream (*in, -1);
+ delete out;
+
+ targetFile.setCreationTime (zei.entry.fileTime);
+ targetFile.setLastModificationTime (zei.entry.fileTime);
+ targetFile.setLastAccessTime (zei.entry.fileTime);
+ }
+ }
+
+ delete in;
+ }
+ }
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ZipFile.cpp *********/
+
+/********* Start of inlined file: juce_CharacterFunctions.cpp *********/
+#ifdef _MSC_VER
+ #pragma warning (disable: 4514 4996)
+ #pragma warning (push)
+#endif
+
+#include
+#include
+#include
+
+#ifdef _MSC_VER
+ #pragma warning (pop)
+#endif
+
+BEGIN_JUCE_NAMESPACE
+
+int CharacterFunctions::length (const char* const s) throw()
+{
+ return (int) strlen (s);
+}
+
+int CharacterFunctions::length (const juce_wchar* const s) throw()
+{
+#if MACOS_10_2_OR_EARLIER
+ int n = 0;
+ while (s[n] != 0)
+ ++n;
+
+ return n;
+#else
+ return (int) wcslen (s);
+#endif
+}
+
+void CharacterFunctions::copy (char* dest, const char* src, const int maxChars) throw()
+{
+ strncpy (dest, src, maxChars);
+}
+
+void CharacterFunctions::copy (juce_wchar* dest, const juce_wchar* src, int maxChars) throw()
+{
+#if MACOS_10_2_OR_EARLIER
+ while (--maxChars >= 0 && *src != 0)
+ *dest++ = *src++;
+
+ *dest = 0;
+#else
+ wcsncpy (dest, src, maxChars);
+#endif
+}
+
+void CharacterFunctions::copy (juce_wchar* dest, const char* src, const int maxChars) throw()
+{
+ mbstowcs (dest, src, maxChars);
+}
+
+void CharacterFunctions::copy (char* dest, const juce_wchar* src, const int maxChars) throw()
+{
+ wcstombs (dest, src, maxChars);
+}
+
+void CharacterFunctions::append (char* dest, const char* src) throw()
+{
+ strcat (dest, src);
+}
+
+void CharacterFunctions::append (juce_wchar* dest, const juce_wchar* src) throw()
+{
+#if MACOS_10_2_OR_EARLIER
+ while (*dest != 0)
+ ++dest;
+
+ while (*src != 0)
+ *dest++ = *src++;
+
+ *dest = 0;
+#else
+ wcscat (dest, src);
+#endif
+}
+
+int CharacterFunctions::compare (const char* const s1, const char* const s2) throw()
+{
+ return strcmp (s1, s2);
+}
+
+int CharacterFunctions::compare (const juce_wchar* s1, const juce_wchar* s2) throw()
+{
+ jassert (s1 != 0 && s2 != 0);
+
+#if MACOS_10_2_OR_EARLIER
+ for (;;)
+ {
+ if (*s1 != *s2)
+ {
+ const int diff = *s1 - *s2;
+
+ if (diff != 0)
+ return diff < 0 ? -1 : 1;
+ }
+ else if (*s1 == 0)
+ break;
+
+ ++s1;
+ ++s2;
+ }
+
+ return 0;
+#else
+ return wcscmp (s1, s2);
+#endif
+}
+
+int CharacterFunctions::compare (const char* const s1, const char* const s2, const int maxChars) throw()
+{
+ jassert (s1 != 0 && s2 != 0);
+
+ return strncmp (s1, s2, maxChars);
+}
+
+int CharacterFunctions::compare (const juce_wchar* s1, const juce_wchar* s2, int maxChars) throw()
+{
+ jassert (s1 != 0 && s2 != 0);
+
+#if MACOS_10_2_OR_EARLIER
+ while (--maxChars >= 0)
+ {
+ if (*s1 != *s2)
+ return (*s1 < *s2) ? -1 : 1;
+ else if (*s1 == 0)
+ break;
+
+ ++s1;
+ ++s2;
+ }
+
+ return 0;
+#else
+ return wcsncmp (s1, s2, maxChars);
+#endif
+}
+
+int CharacterFunctions::compareIgnoreCase (const char* const s1, const char* const s2) throw()
+{
+ jassert (s1 != 0 && s2 != 0);
+
+#if JUCE_WIN32
+ return stricmp (s1, s2);
+#else
+ return strcasecmp (s1, s2);
+#endif
+}
+
+int CharacterFunctions::compareIgnoreCase (const juce_wchar* s1, const juce_wchar* s2) throw()
+{
+ jassert (s1 != 0 && s2 != 0);
+
+#if JUCE_WIN32
+ return _wcsicmp (s1, s2);
+#else
+ for (;;)
+ {
+ if (*s1 != *s2)
+ {
+ const int diff = toUpperCase (*s1) - toUpperCase (*s2);
+
+ if (diff != 0)
+ return diff < 0 ? -1 : 1;
+ }
+ else if (*s1 == 0)
+ break;
+
+ ++s1;
+ ++s2;
+ }
+
+ return 0;
+#endif
+}
+
+int CharacterFunctions::compareIgnoreCase (const char* const s1, const char* const s2, const int maxChars) throw()
+{
+ jassert (s1 != 0 && s2 != 0);
+
+#if JUCE_WIN32
+ return strnicmp (s1, s2, maxChars);
+#else
+ return strncasecmp (s1, s2, maxChars);
+#endif
+}
+
+int CharacterFunctions::compareIgnoreCase (const juce_wchar* s1, const juce_wchar* s2, int maxChars) throw()
+{
+ jassert (s1 != 0 && s2 != 0);
+
+#if JUCE_WIN32
+ return _wcsnicmp (s1, s2, maxChars);
+#else
+ while (--maxChars >= 0)
+ {
+ if (*s1 != *s2)
+ {
+ const int diff = toUpperCase (*s1) - toUpperCase (*s2);
+
+ if (diff != 0)
+ return diff < 0 ? -1 : 1;
+ }
+ else if (*s1 == 0)
+ break;
+
+ ++s1;
+ ++s2;
+ }
+
+ return 0;
+#endif
+}
+
+const char* CharacterFunctions::find (const char* const haystack, const char* const needle) throw()
+{
+ return strstr (haystack, needle);
+}
+
+const juce_wchar* CharacterFunctions::find (const juce_wchar* haystack, const juce_wchar* const needle) throw()
+{
+#if MACOS_10_2_OR_EARLIER
+ while (*haystack != 0)
+ {
+ const juce_wchar* s1 = haystack;
+ const juce_wchar* s2 = needle;
+
+ for (;;)
+ {
+ if (*s2 == 0)
+ return haystack;
+
+ if (*s1 != *s2 || *s2 == 0)
+ break;
+
+ ++s1;
+ ++s2;
+ }
+
+ ++haystack;
+ }
+
+ return 0;
+#else
+ return wcsstr (haystack, needle);
+#endif
+}
+
+int CharacterFunctions::indexOfChar (const char* const haystack, const char needle, const bool ignoreCase) throw()
+{
+ if (haystack != 0)
+ {
+ int i = 0;
+
+ if (ignoreCase)
+ {
+ const char n1 = toLowerCase (needle);
+ const char n2 = toUpperCase (needle);
+
+ if (n1 != n2) // if the char is the same in upper/lower case, fall through to the normal search
+ {
+ while (haystack[i] != 0)
+ {
+ if (haystack[i] == n1 || haystack[i] == n2)
+ return i;
+
+ ++i;
+ }
+
+ return -1;
+ }
+
+ jassert (n1 == needle);
+ }
+
+ while (haystack[i] != 0)
+ {
+ if (haystack[i] == needle)
+ return i;
+
+ ++i;
+ }
+ }
+
+ return -1;
+}
+
+int CharacterFunctions::indexOfChar (const juce_wchar* const haystack, const juce_wchar needle, const bool ignoreCase) throw()
+{
+ if (haystack != 0)
+ {
+ int i = 0;
+
+ if (ignoreCase)
+ {
+ const juce_wchar n1 = toLowerCase (needle);
+ const juce_wchar n2 = toUpperCase (needle);
+
+ if (n1 != n2) // if the char is the same in upper/lower case, fall through to the normal search
+ {
+ while (haystack[i] != 0)
+ {
+ if (haystack[i] == n1 || haystack[i] == n2)
+ return i;
+
+ ++i;
+ }
+
+ return -1;
+ }
+
+ jassert (n1 == needle);
+ }
+
+ while (haystack[i] != 0)
+ {
+ if (haystack[i] == needle)
+ return i;
+
+ ++i;
+ }
+ }
+
+ return -1;
+}
+
+int CharacterFunctions::indexOfCharFast (const char* const haystack, const char needle) throw()
+{
+ jassert (haystack != 0);
+
+ int i = 0;
+ while (haystack[i] != 0)
+ {
+ if (haystack[i] == needle)
+ return i;
+
+ ++i;
+ }
+
+ return -1;
+}
+
+int CharacterFunctions::indexOfCharFast (const juce_wchar* const haystack, const juce_wchar needle) throw()
+{
+ jassert (haystack != 0);
+
+ int i = 0;
+ while (haystack[i] != 0)
+ {
+ if (haystack[i] == needle)
+ return i;
+
+ ++i;
+ }
+
+ return -1;
+}
+
+int CharacterFunctions::getIntialSectionContainingOnly (const char* const text, const char* const allowedChars) throw()
+{
+ return allowedChars == 0 ? 0 : (int) strspn (text, allowedChars);
+}
+
+int CharacterFunctions::getIntialSectionContainingOnly (const juce_wchar* const text, const juce_wchar* const allowedChars) throw()
+{
+ if (allowedChars == 0)
+ return 0;
+
+ int i = 0;
+
+ for (;;)
+ {
+ if (indexOfCharFast (allowedChars, text[i]) < 0)
+ break;
+
+ ++i;
+ }
+
+ return i;
+}
+
+int CharacterFunctions::ftime (char* const dest, const int maxChars, const char* const format, const struct tm* const tm) throw()
+{
+ return (int) strftime (dest, maxChars, format, tm);
+}
+
+int CharacterFunctions::ftime (juce_wchar* const dest, const int maxChars, const juce_wchar* const format, const struct tm* const tm) throw()
+{
+#if MACOS_10_2_OR_EARLIER
+ const String formatTemp (format);
+ size_t num = strftime ((char*) dest, maxChars, (const char*) formatTemp, tm);
+ String temp ((char*) dest);
+ temp.copyToBuffer (dest, num);
+ dest [num] = 0;
+ return (int) num;
+#else
+ return (int) wcsftime (dest, maxChars, format, tm);
+#endif
+}
+
+int CharacterFunctions::getIntValue (const char* const s) throw()
+{
+ return atoi (s);
+}
+
+int CharacterFunctions::getIntValue (const juce_wchar* s) throw()
+{
+#if JUCE_WIN32
+ return _wtoi (s);
+#else
+ int v = 0;
+
+ while (isWhitespace (*s))
+ ++s;
+
+ const bool isNeg = *s == T('-');
+ if (isNeg)
+ ++s;
+
+ for (;;)
+ {
+ const wchar_t c = *s++;
+
+ if (c >= T('0') && c <= T('9'))
+ v = v * 10 + (int) (c - T('0'));
+ else
+ break;
+ }
+
+ return isNeg ? -v : v;
+#endif
+}
+
+int64 CharacterFunctions::getInt64Value (const char* s) throw()
+{
+#if JUCE_LINUX
+ return atoll (s);
+#elif defined (JUCE_WIN32)
+ return _atoi64 (s);
+#else
+ int64 v = 0;
+
+ while (isWhitespace (*s))
+ ++s;
+
+ const bool isNeg = *s == T('-');
+ if (isNeg)
+ ++s;
+
+ for (;;)
+ {
+ const char c = *s++;
+
+ if (c >= '0' && c <= '9')
+ v = v * 10 + (int64) (c - '0');
+ else
+ break;
+ }
+
+ return isNeg ? -v : v;
+#endif
+}
+
+int64 CharacterFunctions::getInt64Value (const juce_wchar* s) throw()
+{
+#if JUCE_WIN32
+ return _wtoi64 (s);
+#else
+ int64 v = 0;
+
+ while (isWhitespace (*s))
+ ++s;
+
+ const bool isNeg = *s == T('-');
+ if (isNeg)
+ ++s;
+
+ for (;;)
+ {
+ const juce_wchar c = *s++;
+
+ if (c >= T('0') && c <= T('9'))
+ v = v * 10 + (int64) (c - T('0'));
+ else
+ break;
+ }
+
+ return isNeg ? -v : v;
+#endif
+}
+
+double CharacterFunctions::getDoubleValue (const char* const s) throw()
+{
+ return atof (s);
+}
+
+double CharacterFunctions::getDoubleValue (const juce_wchar* const s) throw()
+{
+#if MACOS_10_2_OR_EARLIER
+ String temp (s);
+ return atof ((const char*) temp);
+#else
+ wchar_t* endChar;
+ return wcstod (s, &endChar);
+#endif
+}
+
+char CharacterFunctions::toUpperCase (const char character) throw()
+{
+ return (char) toupper (character);
+}
+
+juce_wchar CharacterFunctions::toUpperCase (const juce_wchar character) throw()
+{
+#if MACOS_10_2_OR_EARLIER
+ return toupper ((char) character);
+#else
+ return towupper (character);
+#endif
+}
+
+void CharacterFunctions::toUpperCase (char* s) throw()
+{
+#if JUCE_WIN32
+ strupr (s);
+#else
+ while (*s != 0)
+ {
+ *s = toUpperCase (*s);
+ ++s;
+ }
+#endif
+}
+
+void CharacterFunctions::toUpperCase (juce_wchar* s) throw()
+{
+#if JUCE_WIN32
+ _wcsupr (s);
+#else
+ while (*s != 0)
+ {
+ *s = toUpperCase (*s);
+ ++s;
+ }
+#endif
+}
+
+bool CharacterFunctions::isUpperCase (const char character) throw()
+{
+ return isupper (character) != 0;
+}
+
+bool CharacterFunctions::isUpperCase (const juce_wchar character) throw()
+{
+#if JUCE_WIN32
+ return iswupper (character) != 0;
+#else
+ return toLowerCase (character) != character;
+#endif
+}
+
+char CharacterFunctions::toLowerCase (const char character) throw()
+{
+ return (char) tolower (character);
+}
+
+juce_wchar CharacterFunctions::toLowerCase (const juce_wchar character) throw()
+{
+#if MACOS_10_2_OR_EARLIER
+ return tolower ((char) character);
+#else
+ return towlower (character);
+#endif
+}
+
+void CharacterFunctions::toLowerCase (char* s) throw()
+{
+#if JUCE_WIN32
+ strlwr (s);
+#else
+ while (*s != 0)
+ {
+ *s = toLowerCase (*s);
+ ++s;
+ }
+#endif
+}
+
+void CharacterFunctions::toLowerCase (juce_wchar* s) throw()
+{
+#if JUCE_WIN32
+ _wcslwr (s);
+#else
+ while (*s != 0)
+ {
+ *s = toLowerCase (*s);
+ ++s;
+ }
+#endif
+}
+
+bool CharacterFunctions::isLowerCase (const char character) throw()
+{
+ return islower (character) != 0;
+}
+
+bool CharacterFunctions::isLowerCase (const juce_wchar character) throw()
+{
+#if JUCE_WIN32
+ return iswlower (character) != 0;
+#else
+ return toUpperCase (character) != character;
+#endif
+}
+
+bool CharacterFunctions::isWhitespace (const char character) throw()
+{
+ return character == T(' ') || (character <= 13 && character >= 9);
+}
+
+bool CharacterFunctions::isWhitespace (const juce_wchar character) throw()
+{
+#if MACOS_10_2_OR_EARLIER
+ return isWhitespace ((char) character);
+#else
+ return iswspace (character) != 0;
+#endif
+}
+
+bool CharacterFunctions::isDigit (const char character) throw()
+{
+ return (character >= '0' && character <= '9');
+}
+
+bool CharacterFunctions::isDigit (const juce_wchar character) throw()
+{
+#if MACOS_10_2_OR_EARLIER
+ return isdigit ((char) character) != 0;
+#else
+ return iswdigit (character) != 0;
+#endif
+}
+
+bool CharacterFunctions::isLetter (const char character) throw()
+{
+ return (character >= 'a' && character <= 'z')
+ || (character >= 'A' && character <= 'Z');
+}
+
+bool CharacterFunctions::isLetter (const juce_wchar character) throw()
+{
+#if MACOS_10_2_OR_EARLIER
+ return isLetter ((char) character);
+#else
+ return iswalpha (character) != 0;
+#endif
+}
+
+bool CharacterFunctions::isLetterOrDigit (const char character) throw()
+{
+ return (character >= 'a' && character <= 'z')
+ || (character >= 'A' && character <= 'Z')
+ || (character >= '0' && character <= '9');
+}
+
+bool CharacterFunctions::isLetterOrDigit (const juce_wchar character) throw()
+{
+#if MACOS_10_2_OR_EARLIER
+ return isLetterOrDigit ((char) character);
+#else
+ return iswalnum (character) != 0;
+#endif
+}
+
+int CharacterFunctions::getHexDigitValue (const tchar digit) throw()
+{
+ if (digit >= T('0') && digit <= T('9'))
+ return digit - T('0');
+ else if (digit >= T('a') && digit <= T('f'))
+ return digit - (T('a') - 10);
+ else if (digit >= T('A') && digit <= T('F'))
+ return digit - (T('A') - 10);
+
+ return -1;
+}
+
+int CharacterFunctions::printf (char* const dest, const int maxLength, const char* const format, ...) throw()
+{
+ va_list list;
+ va_start (list, format);
+ return vprintf (dest, maxLength, format, list);
+}
+
+int CharacterFunctions::printf (juce_wchar* const dest, const int maxLength, const juce_wchar* const format, ...) throw()
+{
+ va_list list;
+ va_start (list, format);
+ return vprintf (dest, maxLength, format, list);
+}
+
+int CharacterFunctions::vprintf (char* const dest, const int maxLength, const char* const format, va_list& args) throw()
+{
+#if JUCE_WIN32
+ return (int) _vsnprintf (dest, maxLength, format, args);
+#else
+ return (int) vsnprintf (dest, maxLength, format, args);
+#endif
+}
+
+int CharacterFunctions::vprintf (juce_wchar* const dest, const int maxLength, const juce_wchar* const format, va_list& args) throw()
+{
+#if MACOS_10_3_OR_EARLIER
+ const String formatTemp (format);
+ size_t num = vprintf ((char*) dest, maxLength, formatTemp, args);
+ String temp ((char*) dest);
+ temp.copyToBuffer (dest, num);
+ dest [num] = 0;
+ return (int) num;
+#elif defined (JUCE_WIN32)
+ return (int) _vsnwprintf (dest, maxLength, format, args);
+#else
+ return (int) vswprintf (dest, maxLength, format, args);
+#endif
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_CharacterFunctions.cpp *********/
+
+/********* Start of inlined file: juce_LocalisedStrings.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+LocalisedStrings::LocalisedStrings (const String& fileContents) throw()
+{
+ loadFromText (fileContents);
+}
+
+LocalisedStrings::LocalisedStrings (const File& fileToLoad) throw()
+{
+ loadFromText (fileToLoad.loadFileAsString());
+}
+
+LocalisedStrings::~LocalisedStrings() throw()
+{
+}
+
+const String LocalisedStrings::translate (const String& text) const throw()
+{
+ return translations.getValue (text, text);
+}
+
+static int findCloseQuote (const String& text, int startPos) throw()
+{
+ tchar lastChar = 0;
+
+ for (;;)
+ {
+ const tchar c = text [startPos];
+
+ if (c == 0 || (c == T('"') && lastChar != T('\\')))
+ break;
+
+ lastChar = c;
+ ++startPos;
+ }
+
+ return startPos;
+}
+
+static const String unescapeString (const String& s) throw()
+{
+ return s.replace (T("\\\""), T("\""))
+ .replace (T("\\\'"), T("\'"))
+ .replace (T("\\t"), T("\t"))
+ .replace (T("\\r"), T("\r"))
+ .replace (T("\\n"), T("\n"));
+}
+
+void LocalisedStrings::loadFromText (const String& fileContents) throw()
+{
+ StringArray lines;
+ lines.addLines (fileContents);
+
+ for (int i = 0; i < lines.size(); ++i)
+ {
+ String line (lines[i].trim());
+
+ if (line.startsWithChar (T('"')))
+ {
+ int closeQuote = findCloseQuote (line, 1);
+
+ const String originalText (unescapeString (line.substring (1, closeQuote)));
+
+ if (originalText.isNotEmpty())
+ {
+ const int openingQuote = findCloseQuote (line, closeQuote + 1);
+ closeQuote = findCloseQuote (line, openingQuote + 1);
+
+ const String newText (unescapeString (line.substring (openingQuote + 1, closeQuote)));
+
+ if (newText.isNotEmpty())
+ translations.set (originalText, newText);
+ }
+ }
+ else if (line.startsWithIgnoreCase (T("language:")))
+ {
+ languageName = line.substring (9).trim();
+ }
+ else if (line.startsWithIgnoreCase (T("countries:")))
+ {
+ countryCodes.addTokens (line.substring (10).trim(), true);
+ countryCodes.trim();
+ countryCodes.removeEmptyStrings();
+ }
+ }
+}
+
+static CriticalSection currentMappingsLock;
+static LocalisedStrings* currentMappings = 0;
+
+void LocalisedStrings::setCurrentMappings (LocalisedStrings* newTranslations) throw()
+{
+ const ScopedLock sl (currentMappingsLock);
+
+ delete currentMappings;
+ currentMappings = newTranslations;
+}
+
+LocalisedStrings* LocalisedStrings::getCurrentMappings() throw()
+{
+ return currentMappings;
+}
+
+const String LocalisedStrings::translateWithCurrentMappings (const String& text) throw()
+{
+ const ScopedLock sl (currentMappingsLock);
+
+ if (currentMappings != 0)
+ return currentMappings->translate (text);
+
+ return text;
+}
+
+const String LocalisedStrings::translateWithCurrentMappings (const char* text) throw()
+{
+ return translateWithCurrentMappings (String (text));
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_LocalisedStrings.cpp *********/
+
+/********* Start of inlined file: juce_String.cpp *********/
+#ifdef _MSC_VER
+ #pragma warning (disable: 4514)
+ #pragma warning (push)
+#endif
+#include
+
+#if JUCE_MSVC
+ #include
+#endif
+
+BEGIN_JUCE_NAMESPACE
+
+#ifdef _MSC_VER
+ #pragma warning (pop)
+#endif
+
+static const char* const emptyCharString = "\0\0\0\0JUCE";
+static const int safeEmptyStringRefCount = 0x3fffffff;
+String::InternalRefCountedStringHolder String::emptyString = { safeEmptyStringRefCount, 0, { 0 } };
+static tchar decimalPoint = T('.');
+
+void juce_initialiseStrings()
+{
+ decimalPoint = String::fromUTF8 ((const uint8*) localeconv()->decimal_point) [0];
+}
+
+void String::deleteInternal() throw()
+{
+ if (atomicDecrementAndReturn (text->refCount) == 0)
+ juce_free (text);
+}
+
+void String::createInternal (const int numChars) throw()
+{
+ jassert (numChars > 0);
+
+ text = (InternalRefCountedStringHolder*) juce_malloc (sizeof (InternalRefCountedStringHolder)
+ + numChars * sizeof (tchar));
+ text->refCount = 1;
+ text->allocatedNumChars = numChars;
+ text->text[0] = 0;
+}
+
+void String::createInternal (const tchar* const t, const tchar* const textEnd) throw()
+{
+ jassert (*(textEnd - 1) == 0); // must have a null terminator
+
+ const int numChars = (int) (textEnd - t);
+ createInternal (numChars - 1);
+ memcpy (text->text, t, numChars * sizeof (tchar));
+}
+
+void String::appendInternal (const tchar* const newText,
+ const int numExtraChars) throw()
+{
+ if (numExtraChars > 0)
+ {
+ const int oldLen = CharacterFunctions::length (text->text);
+ const int newTotalLen = oldLen + numExtraChars;
+
+ if (text->refCount > 1)
+ {
+ // it's in use by other strings as well, so we need to make a private copy before messing with it..
+ InternalRefCountedStringHolder* const newTextHolder
+ = (InternalRefCountedStringHolder*) juce_malloc (sizeof (InternalRefCountedStringHolder)
+ + newTotalLen * sizeof (tchar));
+ newTextHolder->refCount = 1;
+ newTextHolder->allocatedNumChars = newTotalLen;
+
+ memcpy (newTextHolder->text, text->text, oldLen * sizeof (tchar));
+ memcpy (newTextHolder->text + oldLen, newText, numExtraChars * sizeof (tchar));
+
+ InternalRefCountedStringHolder* const old = text;
+ text = newTextHolder;
+
+ if (atomicDecrementAndReturn (old->refCount) == 0)
+ juce_free (old);
+ }
+ else
+ {
+ // no other strings using it, so just expand it if needed..
+ if (newTotalLen > text->allocatedNumChars)
+ {
+ text = (InternalRefCountedStringHolder*)
+ juce_realloc (text, sizeof (InternalRefCountedStringHolder)
+ + newTotalLen * sizeof (tchar));
+
+ text->allocatedNumChars = newTotalLen;
+ }
+
+ memcpy (text->text + oldLen, newText, numExtraChars * sizeof (tchar));
+ }
+
+ text->text [newTotalLen] = 0;
+ }
+}
+
+void String::dupeInternalIfMultiplyReferenced() throw()
+{
+ if (text->refCount > 1)
+ {
+ InternalRefCountedStringHolder* const old = text;
+ const int len = old->allocatedNumChars;
+
+ InternalRefCountedStringHolder* const newTextHolder
+ = (InternalRefCountedStringHolder*) juce_malloc (sizeof (InternalRefCountedStringHolder)
+ + len * sizeof (tchar));
+
+ newTextHolder->refCount = 1;
+ newTextHolder->allocatedNumChars = len;
+
+ memcpy (newTextHolder->text, old->text, (len + 1) * sizeof (tchar));
+
+ text = newTextHolder;
+
+ if (atomicDecrementAndReturn (old->refCount) == 0)
+ juce_free (old);
+ }
+}
+
+const String String::empty;
+
+String::String() throw()
+ : text (&emptyString)
+{
+}
+
+String::String (const String& other) throw()
+ : text (other.text)
+{
+ atomicIncrement (text->refCount);
+}
+
+String::String (const int numChars,
+ const int /*dummyVariable*/) throw()
+{
+ createInternal (numChars);
+}
+
+String::String (const char* const t) throw()
+{
+ if (t != 0 && *t != 0)
+ {
+ const int len = CharacterFunctions::length (t);
+ createInternal (len);
+
+#if JUCE_STRINGS_ARE_UNICODE
+ CharacterFunctions::copy (text->text, t, len + 1);
+#else
+ memcpy (text->text, t, len + 1);
+#endif
+ }
+ else
+ {
+ text = &emptyString;
+ emptyString.refCount = safeEmptyStringRefCount;
+ }
+}
+
+String::String (const juce_wchar* const t) throw()
+{
+ if (t != 0 && *t != 0)
+ {
+ const int len = CharacterFunctions::length (t);
+ createInternal (len);
+
+#if JUCE_STRINGS_ARE_UNICODE
+ memcpy (text->text, t, (len + 1) * sizeof (tchar));
+#else
+ CharacterFunctions::copy (text->text, t, len + 1);
+#endif
+ }
+ else
+ {
+ text = &emptyString;
+ emptyString.refCount = safeEmptyStringRefCount;
+ }
+}
+
+String::String (const char* const t,
+ const int maxChars) throw()
+{
+ int i;
+ for (i = 0; i < maxChars; ++i)
+ if (t[i] == 0)
+ break;
+
+ if (i > 0)
+ {
+ createInternal (i);
+
+#if JUCE_STRINGS_ARE_UNICODE
+ CharacterFunctions::copy (text->text, t, i);
+#else
+ memcpy (text->text, t, i);
+#endif
+
+ text->text [i] = 0;
+ }
+ else
+ {
+ text = &emptyString;
+ emptyString.refCount = safeEmptyStringRefCount;
+ }
+}
+
+String::String (const juce_wchar* const t,
+ const int maxChars) throw()
+{
+ int i;
+ for (i = 0; i < maxChars; ++i)
+ if (t[i] == 0)
+ break;
+
+ if (i > 0)
+ {
+ createInternal (i);
+
+#if JUCE_STRINGS_ARE_UNICODE
+ memcpy (text->text, t, i * sizeof (tchar));
+#else
+ CharacterFunctions::copy (text->text, t, i);
+#endif
+ text->text [i] = 0;
+ }
+ else
+ {
+ text = &emptyString;
+ emptyString.refCount = safeEmptyStringRefCount;
+ }
+}
+
+const String String::charToString (const tchar character) throw()
+{
+ tchar temp[2];
+ temp[0] = character;
+ temp[1] = 0;
+
+ return String (temp);
+}
+
+// pass in a pointer to the END of a buffer..
+static tchar* int64ToCharString (tchar* t, const int64 n) throw()
+{
+ *--t = 0;
+ int64 v = (n >= 0) ? n : -n;
+
+ do
+ {
+ *--t = (tchar) (T('0') + (int) (v % 10));
+ v /= 10;
+
+ } while (v > 0);
+
+ if (n < 0)
+ *--t = T('-');
+
+ return t;
+}
+
+static tchar* intToCharString (tchar* t, const int n) throw()
+{
+ if (n == (int) 0x80000000) // (would cause an overflow)
+ return int64ToCharString (t, n);
+
+ *--t = 0;
+ int v = abs (n);
+
+ do
+ {
+ *--t = (tchar) (T('0') + (v % 10));
+ v /= 10;
+
+ } while (v > 0);
+
+ if (n < 0)
+ *--t = T('-');
+
+ return t;
+}
+
+static tchar* uintToCharString (tchar* t, unsigned int v) throw()
+{
+ *--t = 0;
+
+ do
+ {
+ *--t = (tchar) (T('0') + (v % 10));
+ v /= 10;
+
+ } while (v > 0);
+
+ return t;
+}
+
+String::String (const int number) throw()
+{
+ tchar buffer [16];
+ tchar* const end = buffer + 16;
+
+ createInternal (intToCharString (end, number), end);
+}
+
+String::String (const unsigned int number) throw()
+{
+ tchar buffer [16];
+ tchar* const end = buffer + 16;
+
+ createInternal (uintToCharString (end, number), end);
+}
+
+String::String (const short number) throw()
+{
+ tchar buffer [16];
+ tchar* const end = buffer + 16;
+
+ createInternal (intToCharString (end, (int) number), end);
+}
+
+String::String (const unsigned short number) throw()
+{
+ tchar buffer [16];
+ tchar* const end = buffer + 16;
+
+ createInternal (uintToCharString (end, (unsigned int) number), end);
+}
+
+String::String (const int64 number) throw()
+{
+ tchar buffer [32];
+ tchar* const end = buffer + 32;
+
+ createInternal (int64ToCharString (end, number), end);
+}
+
+String::String (const uint64 number) throw()
+{
+ tchar buffer [32];
+ tchar* const end = buffer + 32;
+ tchar* t = end;
+
+ *--t = 0;
+ int64 v = number;
+
+ do
+ {
+ *--t = (tchar) (T('0') + (int) (v % 10));
+ v /= 10;
+
+ } while (v > 0);
+
+ createInternal (t, end);
+}
+
+// a double-to-string routine that actually uses the number of dec. places you asked for
+// without resorting to exponent notation if the number's too big or small (which is what printf does).
+void String::doubleToStringWithDecPlaces (double n, int numDecPlaces) throw()
+{
+ const int bufSize = 80;
+ tchar buffer [bufSize];
+ int len;
+ tchar* t;
+
+ if (numDecPlaces > 0 && n > -1.0e20 && n < 1.0e20)
+ {
+ int64 v = (int64) (pow (10.0, numDecPlaces) * fabs (n) + 0.5);
+
+ t = buffer + bufSize;
+ *--t = (tchar) 0;
+
+ while (numDecPlaces >= 0 || v > 0)
+ {
+ if (numDecPlaces == 0)
+ *--t = decimalPoint;
+
+ *--t = (tchar) (T('0') + (v % 10));
+
+ v /= 10;
+ --numDecPlaces;
+ }
+
+ if (n < 0)
+ *--t = T('-');
+
+ len = (int) ((buffer + bufSize) - t);
+ }
+ else
+ {
+ len = CharacterFunctions::printf (buffer, bufSize, T("%.9g"), n) + 1;
+ t = buffer;
+ }
+
+ if (len > 1)
+ {
+ jassert (len < numElementsInArray (buffer));
+
+ createInternal (len - 1);
+ memcpy (text->text, t, len * sizeof (tchar));
+ }
+ else
+ {
+ jassert (*t == 0);
+ text = &emptyString;
+ emptyString.refCount = safeEmptyStringRefCount;
+ }
+}
+
+String::String (const float number,
+ const int numberOfDecimalPlaces) throw()
+{
+ doubleToStringWithDecPlaces ((double) number,
+ numberOfDecimalPlaces);
+}
+
+String::String (const double number,
+ const int numberOfDecimalPlaces) throw()
+{
+ doubleToStringWithDecPlaces (number,
+ numberOfDecimalPlaces);
+}
+
+String::~String() throw()
+{
+ if (atomicDecrementAndReturn (text->refCount) == 0)
+ juce_free (text);
+}
+
+void String::preallocateStorage (const int numChars) throw()
+{
+ if (numChars > text->allocatedNumChars)
+ {
+ dupeInternalIfMultiplyReferenced();
+
+ text = (InternalRefCountedStringHolder*) juce_realloc (text, sizeof (InternalRefCountedStringHolder)
+ + numChars * sizeof (tchar));
+ text->allocatedNumChars = numChars;
+ }
+}
+
+#if JUCE_STRINGS_ARE_UNICODE
+String::operator const char*() const throw()
+{
+ if (isEmpty())
+ {
+ return (const char*) emptyCharString;
+ }
+ else
+ {
+ String* const mutableThis = const_cast (this);
+
+ mutableThis->dupeInternalIfMultiplyReferenced();
+ int len = CharacterFunctions::length (text->text) + 1;
+ mutableThis->text = (InternalRefCountedStringHolder*)
+ juce_realloc (text, sizeof (InternalRefCountedStringHolder)
+ + (len * sizeof (juce_wchar) + len));
+ char* otherCopy = (char*) (text->text + len);
+ --len;
+
+ CharacterFunctions::copy (otherCopy, text->text, len);
+ otherCopy [len] = 0;
+ return otherCopy;
+ }
+}
+
+#else
+
+String::operator const juce_wchar*() const throw()
+{
+ if (isEmpty())
+ {
+ return (const juce_wchar*) emptyCharString;
+ }
+ else
+ {
+ String* const mutableThis = const_cast (this);
+
+ mutableThis->dupeInternalIfMultiplyReferenced();
+ int len = CharacterFunctions::length (text->text) + 1;
+ mutableThis->text = (InternalRefCountedStringHolder*)
+ juce_realloc (text, sizeof (InternalRefCountedStringHolder)
+ + (len * sizeof (juce_wchar) + len));
+
+ juce_wchar* otherCopy = (juce_wchar*) (text->text + len);
+ --len;
+
+ CharacterFunctions::copy (otherCopy, text->text, len);
+ otherCopy [len] = 0;
+ return otherCopy;
+ }
+}
+
+#endif
+
+void String::copyToBuffer (char* const destBuffer,
+ const int maxCharsToCopy) const throw()
+{
+ const int len = jmin (maxCharsToCopy, length());
+
+#if JUCE_STRINGS_ARE_UNICODE
+ CharacterFunctions::copy (destBuffer, text->text, len);
+#else
+ memcpy (destBuffer, text->text, len * sizeof (tchar));
+#endif
+
+ destBuffer [len] = 0;
+}
+
+void String::copyToBuffer (juce_wchar* const destBuffer,
+ const int maxCharsToCopy) const throw()
+{
+ const int len = jmin (maxCharsToCopy, length());
+
+#if JUCE_STRINGS_ARE_UNICODE
+ memcpy (destBuffer, text->text, len * sizeof (juce_wchar));
+#else
+ CharacterFunctions::copy (destBuffer, text->text, len);
+#endif
+
+ destBuffer [len] = 0;
+}
+
+int String::length() const throw()
+{
+ return CharacterFunctions::length (text->text);
+}
+
+int String::hashCode() const throw()
+{
+ const tchar* t = text->text;
+ int result = 0;
+
+ while (*t != (tchar) 0)
+ result = 31 * result + *t++;
+
+ return result;
+}
+
+int64 String::hashCode64() const throw()
+{
+ const tchar* t = text->text;
+ int64 result = 0;
+
+ while (*t != (tchar) 0)
+ result = 101 * result + *t++;
+
+ return result;
+}
+
+const String& String::operator= (const tchar* const otherText) throw()
+{
+ if (otherText != 0 && *otherText != 0)
+ {
+ const int otherLen = CharacterFunctions::length (otherText);
+
+ if (otherLen > 0)
+ {
+ // avoid resizing the memory block if the string is
+ // shrinking..
+ if (text->refCount > 1
+ || otherLen > text->allocatedNumChars
+ || otherLen <= (text->allocatedNumChars >> 1))
+ {
+ deleteInternal();
+ createInternal (otherLen);
+ }
+
+ memcpy (text->text, otherText, (otherLen + 1) * sizeof (tchar));
+
+ return *this;
+ }
+ }
+
+ deleteInternal();
+ text = &emptyString;
+ emptyString.refCount = safeEmptyStringRefCount;
+
+ return *this;
+}
+
+const String& String::operator= (const String& other) throw()
+{
+ if (this != &other)
+ {
+ atomicIncrement (other.text->refCount);
+
+ if (atomicDecrementAndReturn (text->refCount) == 0)
+ juce_free (text);
+
+ text = other.text;
+ }
+
+ return *this;
+}
+
+bool String::operator== (const String& other) const throw()
+{
+ return text == other.text
+ || CharacterFunctions::compare (text->text, other.text->text) == 0;
+}
+
+bool String::operator== (const tchar* const t) const throw()
+{
+ return t != 0 ? CharacterFunctions::compare (text->text, t) == 0
+ : isEmpty();
+}
+
+bool String::equalsIgnoreCase (const tchar* t) const throw()
+{
+ return t != 0 ? CharacterFunctions::compareIgnoreCase (text->text, t) == 0
+ : isEmpty();
+}
+
+bool String::equalsIgnoreCase (const String& other) const throw()
+{
+ return text == other.text
+ || CharacterFunctions::compareIgnoreCase (text->text, other.text->text) == 0;
+}
+
+bool String::operator!= (const String& other) const throw()
+{
+ return text != other.text
+ && CharacterFunctions::compare (text->text, other.text->text) != 0;
+}
+
+bool String::operator!= (const tchar* const t) const throw()
+{
+ return t != 0 ? (CharacterFunctions::compare (text->text, t) != 0)
+ : isNotEmpty();
+}
+
+bool String::operator> (const String& other) const throw()
+{
+ return compare (other) > 0;
+}
+
+bool String::operator< (const tchar* const other) const throw()
+{
+ return compare (other) < 0;
+}
+
+bool String::operator>= (const String& other) const throw()
+{
+ return compare (other) >= 0;
+}
+
+bool String::operator<= (const tchar* const other) const throw()
+{
+ return compare (other) <= 0;
+}
+
+int String::compare (const tchar* const other) const throw()
+{
+ return other != 0 ? CharacterFunctions::compare (text->text, other)
+ : isEmpty();
+}
+
+int String::compareIgnoreCase (const tchar* const other) const throw()
+{
+ return other != 0 ? CharacterFunctions::compareIgnoreCase (text->text, other)
+ : isEmpty();
+}
+
+int String::compareLexicographically (const tchar* other) const throw()
+{
+ if (other == 0)
+ return isEmpty();
+
+ const tchar* s1 = text->text;
+ while (*s1 != 0 && ! CharacterFunctions::isLetterOrDigit (*s1))
+ ++s1;
+
+ while (*other != 0 && ! CharacterFunctions::isLetterOrDigit (*other))
+ ++other;
+
+ return CharacterFunctions::compareIgnoreCase (s1, other);
+}
+
+const String String::operator+ (const String& other) const throw()
+{
+ if (*(other.text->text) == 0)
+ return *this;
+
+ if (isEmpty())
+ return other;
+
+ const int len = CharacterFunctions::length (text->text);
+ const int otherLen = CharacterFunctions::length (other.text->text);
+
+ String result (len + otherLen, (int) 0);
+ memcpy (result.text->text, text->text, len * sizeof (tchar));
+ memcpy (result.text->text + len, other.text->text, otherLen * sizeof (tchar));
+ result.text->text [len + otherLen] = 0;
+
+ return result;
+}
+
+const String String::operator+ (const tchar* const textToAppend) const throw()
+{
+ if (textToAppend == 0 || *textToAppend == 0)
+ return *this;
+
+ const int len = CharacterFunctions::length (text->text);
+ const int otherLen = CharacterFunctions::length (textToAppend);
+
+ String result (len + otherLen, (int) 0);
+ memcpy (result.text->text, text->text, len * sizeof (tchar));
+ memcpy (result.text->text + len, textToAppend, otherLen * sizeof (tchar));
+ result.text->text [len + otherLen] = 0;
+
+ return result;
+}
+
+const String String::operator+ (const tchar characterToAppend) const throw()
+{
+ if (characterToAppend == 0)
+ return *this;
+
+ const int len = CharacterFunctions::length (text->text);
+ String result ((int) (len + 1), (int) 0);
+
+ memcpy (result.text->text, text->text, len * sizeof (tchar));
+ result.text->text[len] = characterToAppend;
+ result.text->text[len + 1] = 0;
+
+ return result;
+}
+
+const String JUCE_PUBLIC_FUNCTION operator+ (const char* const string1,
+ const String& string2) throw()
+{
+ String s (string1);
+ s += string2;
+ return s;
+}
+
+const String JUCE_PUBLIC_FUNCTION operator+ (const juce_wchar* const string1,
+ const String& string2) throw()
+{
+ String s (string1);
+ s += string2;
+ return s;
+}
+
+const String& String::operator+= (const tchar* const t) throw()
+{
+ if (t != 0)
+ appendInternal (t, CharacterFunctions::length (t));
+
+ return *this;
+}
+
+const String& String::operator+= (const String& other) throw()
+{
+ if (isEmpty())
+ operator= (other);
+ else
+ appendInternal (other.text->text,
+ CharacterFunctions::length (other.text->text));
+
+ return *this;
+}
+
+const String& String::operator+= (const char ch) throw()
+{
+ char asString[2];
+ asString[0] = ch;
+ asString[1] = 0;
+
+#if JUCE_STRINGS_ARE_UNICODE
+ operator+= (String (asString));
+#else
+ appendInternal (asString, 1);
+#endif
+
+ return *this;
+}
+
+const String& String::operator+= (const juce_wchar ch) throw()
+{
+ juce_wchar asString[2];
+ asString[0] = ch;
+ asString[1] = 0;
+
+#if JUCE_STRINGS_ARE_UNICODE
+ appendInternal (asString, 1);
+#else
+ operator+= (String (asString));
+#endif
+
+ return *this;
+}
+
+void String::append (const tchar* const other,
+ const int howMany) throw()
+{
+ if (howMany > 0)
+ {
+ int i;
+ for (i = 0; i < howMany; ++i)
+ if (other[i] == 0)
+ break;
+
+ appendInternal (other, i);
+ }
+}
+
+String& String::operator<< (const int number) throw()
+{
+ tchar buffer [64];
+ tchar* const end = buffer + 64;
+ const tchar* const t = intToCharString (end, number);
+ appendInternal (t, (int) (end - t) - 1);
+
+ return *this;
+}
+
+String& String::operator<< (const unsigned int number) throw()
+{
+ tchar buffer [64];
+ tchar* const end = buffer + 64;
+ const tchar* const t = uintToCharString (end, number);
+ appendInternal (t, (int) (end - t) - 1);
+
+ return *this;
+}
+
+String& String::operator<< (const short number) throw()
+{
+ tchar buffer [64];
+ tchar* const end = buffer + 64;
+ const tchar* const t = intToCharString (end, (int) number);
+ appendInternal (t, (int) (end - t) - 1);
+
+ return *this;
+}
+
+String& String::operator<< (const double number) throw()
+{
+ operator+= (String (number));
+ return *this;
+}
+
+String& String::operator<< (const float number) throw()
+{
+ operator+= (String (number));
+ return *this;
+}
+
+String& String::operator<< (const char character) throw()
+{
+ operator+= (character);
+ return *this;
+}
+
+String& String::operator<< (const juce_wchar character) throw()
+{
+ operator+= (character);
+ return *this;
+}
+
+String& String::operator<< (const char* const t) throw()
+{
+#if JUCE_STRINGS_ARE_UNICODE
+ operator+= (String (t));
+#else
+ operator+= (t);
+#endif
+ return *this;
+}
+
+String& String::operator<< (const juce_wchar* const t) throw()
+{
+#if JUCE_STRINGS_ARE_UNICODE
+ operator+= (t);
+#else
+ operator+= (String (t));
+#endif
+ return *this;
+}
+
+String& String::operator<< (const String& t) throw()
+{
+ operator+= (t);
+ return *this;
+}
+
+int String::indexOfChar (const tchar character) const throw()
+{
+ const tchar* t = text->text;
+
+ for (;;)
+ {
+ if (*t == character)
+ return (int) (t - text->text);
+
+ if (*t++ == 0)
+ return -1;
+ }
+}
+
+int String::lastIndexOfChar (const tchar character) const throw()
+{
+ for (int i = CharacterFunctions::length (text->text); --i >= 0;)
+ if (text->text[i] == character)
+ return i;
+
+ return -1;
+}
+
+int String::indexOf (const tchar* const t) const throw()
+{
+ const tchar* const r = CharacterFunctions::find (text->text, t);
+ return (r == 0) ? -1
+ : (int) (r - text->text);
+}
+
+int String::indexOfChar (const int startIndex,
+ const tchar character) const throw()
+{
+ if (startIndex >= 0 && startIndex >= CharacterFunctions::length (text->text))
+ return -1;
+
+ const tchar* t = text->text + jmax (0, startIndex);
+
+ for (;;)
+ {
+ if (*t == character)
+ return (int) (t - text->text);
+
+ if (*t++ == 0)
+ return -1;
+ }
+}
+
+int String::indexOfAnyOf (const tchar* const charactersToLookFor,
+ const int startIndex,
+ const bool ignoreCase) const throw()
+{
+ if (charactersToLookFor == 0
+ || (startIndex >= 0 && startIndex >= CharacterFunctions::length (text->text)))
+ return -1;
+
+ const tchar* t = text->text + jmax (0, startIndex);
+
+ while (*t != 0)
+ {
+ if (CharacterFunctions::indexOfChar (charactersToLookFor, *t, ignoreCase) >= 0)
+ return (int) (t - text->text);
+
+ ++t;
+ }
+
+ return -1;
+}
+
+int String::indexOf (const int startIndex,
+ const tchar* const other) const throw()
+{
+ if (other == 0 || startIndex >= CharacterFunctions::length (text->text))
+ return -1;
+
+ const tchar* const found = CharacterFunctions::find (text->text + jmax (0, startIndex),
+ other);
+
+ return (found == 0) ? -1
+ : (int) (found - text->text);
+}
+
+int String::indexOfIgnoreCase (const tchar* const other) const throw()
+{
+ if (other != 0 && *other != 0)
+ {
+ const int len = CharacterFunctions::length (other);
+ const int end = CharacterFunctions::length (text->text) - len;
+
+ for (int i = 0; i <= end; ++i)
+ if (CharacterFunctions::compareIgnoreCase (text->text + i, other, len) == 0)
+ return i;
+ }
+
+ return -1;
+}
+
+int String::indexOfIgnoreCase (const int startIndex,
+ const tchar* const other) const throw()
+{
+ if (other != 0 && *other != 0)
+ {
+ const int len = CharacterFunctions::length (other);
+ const int end = length() - len;
+
+ for (int i = jmax (0, startIndex); i <= end; ++i)
+ if (CharacterFunctions::compareIgnoreCase (text->text + i, other, len) == 0)
+ return i;
+ }
+
+ return -1;
+}
+
+int String::lastIndexOf (const tchar* const other) const throw()
+{
+ if (other != 0 && *other != 0)
+ {
+ const int len = CharacterFunctions::length (other);
+ int i = length() - len;
+
+ if (i >= 0)
+ {
+ const tchar* n = text->text + i;
+
+ while (i >= 0)
+ {
+ if (CharacterFunctions::compare (n--, other, len) == 0)
+ return i;
+
+ --i;
+ }
+ }
+ }
+
+ return -1;
+}
+
+int String::lastIndexOfIgnoreCase (const tchar* const other) const throw()
+{
+ if (other != 0 && *other != 0)
+ {
+ const int len = CharacterFunctions::length (other);
+ int i = length() - len;
+
+ if (i >= 0)
+ {
+ const tchar* n = text->text + i;
+
+ while (i >= 0)
+ {
+ if (CharacterFunctions::compareIgnoreCase (n--, other, len) == 0)
+ return i;
+
+ --i;
+ }
+ }
+ }
+
+ return -1;
+}
+
+int String::lastIndexOfAnyOf (const tchar* const charactersToLookFor,
+ const bool ignoreCase) const throw()
+{
+ for (int i = CharacterFunctions::length (text->text); --i >= 0;)
+ if (CharacterFunctions::indexOfChar (charactersToLookFor, text->text [i], ignoreCase) >= 0)
+ return i;
+
+ return -1;
+}
+
+bool String::contains (const tchar* const other) const throw()
+{
+ return indexOf (other) >= 0;
+}
+
+bool String::containsChar (const tchar character) const throw()
+{
+ return indexOfChar (character) >= 0;
+}
+
+bool String::containsIgnoreCase (const tchar* const t) const throw()
+{
+ return indexOfIgnoreCase (t) >= 0;
+}
+
+int String::indexOfWholeWord (const tchar* const word) const throw()
+{
+ if (word != 0 && *word != 0)
+ {
+ const int wordLen = CharacterFunctions::length (word);
+ const int end = length() - wordLen;
+ const tchar* t = text->text;
+
+ for (int i = 0; i <= end; ++i)
+ {
+ if (CharacterFunctions::compare (t, word, wordLen) == 0
+ && (i == 0 || ! CharacterFunctions::isLetterOrDigit (* (t - 1)))
+ && ! CharacterFunctions::isLetterOrDigit (t [wordLen]))
+ {
+ return i;
+ }
+
+ ++t;
+ }
+ }
+
+ return -1;
+}
+
+int String::indexOfWholeWordIgnoreCase (const tchar* const word) const throw()
+{
+ if (word != 0 && *word != 0)
+ {
+ const int wordLen = CharacterFunctions::length (word);
+ const int end = length() - wordLen;
+ const tchar* t = text->text;
+
+ for (int i = 0; i <= end; ++i)
+ {
+ if (CharacterFunctions::compareIgnoreCase (t, word, wordLen) == 0
+ && (i == 0 || ! CharacterFunctions::isLetterOrDigit (* (t - 1)))
+ && ! CharacterFunctions::isLetterOrDigit (t [wordLen]))
+ {
+ return i;
+ }
+
+ ++t;
+ }
+ }
+
+ return -1;
+}
+
+bool String::containsWholeWord (const tchar* const wordToLookFor) const throw()
+{
+ return indexOfWholeWord (wordToLookFor) >= 0;
+}
+
+bool String::containsWholeWordIgnoreCase (const tchar* const wordToLookFor) const throw()
+{
+ return indexOfWholeWordIgnoreCase (wordToLookFor) >= 0;
+}
+
+static int indexOfMatch (const tchar* const wildcard,
+ const tchar* const test,
+ const bool ignoreCase) throw()
+{
+ int start = 0;
+
+ while (test [start] != 0)
+ {
+ int i = 0;
+
+ for (;;)
+ {
+ const tchar wc = wildcard [i];
+ const tchar c = test [i + start];
+
+ if (wc == c
+ || (ignoreCase && CharacterFunctions::toLowerCase (wc) == CharacterFunctions::toLowerCase (c))
+ || (wc == T('?') && c != 0))
+ {
+ if (wc == 0)
+ return start;
+
+ ++i;
+ }
+ else
+ {
+ if (wc == T('*') && (wildcard [i + 1] == 0
+ || indexOfMatch (wildcard + i + 1,
+ test + start + i,
+ ignoreCase) >= 0))
+ {
+ return start;
+ }
+
+ break;
+ }
+ }
+
+ ++start;
+ }
+
+ return -1;
+}
+
+bool String::matchesWildcard (const tchar* wildcard, const bool ignoreCase) const throw()
+{
+ int i = 0;
+
+ for (;;)
+ {
+ const tchar wc = wildcard [i];
+ const tchar c = text->text [i];
+
+ if (wc == c
+ || (ignoreCase && CharacterFunctions::toLowerCase (wc) == CharacterFunctions::toLowerCase (c))
+ || (wc == T('?') && c != 0))
+ {
+ if (wc == 0)
+ return true;
+
+ ++i;
+ }
+ else
+ {
+ return wc == T('*') && (wildcard [i + 1] == 0
+ || indexOfMatch (wildcard + i + 1,
+ text->text + i,
+ ignoreCase) >= 0);
+ }
+ }
+}
+
+void String::printf (const tchar* const pf, ...) throw()
+{
+ va_list list;
+ va_start (list, pf);
+
+ vprintf (pf, list);
+}
+
+const String String::formatted (const tchar* const pf, ...) throw()
+{
+ va_list list;
+ va_start (list, pf);
+
+ String result;
+ result.vprintf (pf, list);
+ return result;
+}
+
+void String::vprintf (const tchar* const pf, va_list& args) throw()
+{
+ tchar stackBuf [256];
+ unsigned int bufSize = 256;
+ tchar* buf = stackBuf;
+
+ deleteInternal();
+
+ do
+ {
+#if JUCE_LINUX && JUCE_64BIT
+ va_list tempArgs;
+ va_copy (tempArgs, args);
+ const int num = CharacterFunctions::vprintf (buf, bufSize - 1, pf, tempArgs);
+ va_end (tempArgs);
+#else
+ const int num = CharacterFunctions::vprintf (buf, bufSize - 1, pf, args);
+#endif
+
+ if (num > 0)
+ {
+ createInternal (num);
+ memcpy (text->text, buf, (num + 1) * sizeof (tchar));
+ break;
+ }
+ else if (num == 0)
+ {
+ text = &emptyString;
+ emptyString.refCount = safeEmptyStringRefCount;
+ break;
+ }
+
+ if (buf != stackBuf)
+ juce_free (buf);
+
+ bufSize += 256;
+ buf = (tchar*) juce_malloc (bufSize * sizeof (tchar));
+ }
+ while (bufSize < 65536); // this is a sanity check to avoid situations where vprintf repeatedly
+ // returns -1 because of an error rather than because it needs more space.
+
+ if (buf != stackBuf)
+ juce_free (buf);
+}
+
+const String String::repeatedString (const tchar* const stringToRepeat,
+ int numberOfTimesToRepeat) throw()
+{
+ const int len = CharacterFunctions::length (stringToRepeat);
+ String result ((int) (len * numberOfTimesToRepeat + 1), (int) 0);
+
+ tchar* n = result.text->text;
+ n[0] = 0;
+
+ while (--numberOfTimesToRepeat >= 0)
+ {
+ CharacterFunctions::append (n, stringToRepeat);
+ n += len;
+ }
+
+ return result;
+}
+
+const String String::replaceSection (int index,
+ int numCharsToReplace,
+ const tchar* const stringToInsert) const throw()
+{
+ if (index < 0)
+ {
+ // a negative index to replace from?
+ jassertfalse
+ index = 0;
+ }
+
+ if (numCharsToReplace < 0)
+ {
+ // replacing a negative number of characters?
+ numCharsToReplace = 0;
+ jassertfalse;
+ }
+
+ const int len = length();
+
+ if (index + numCharsToReplace > len)
+ {
+ if (index > len)
+ {
+ // replacing beyond the end of the string?
+ index = len;
+ jassertfalse
+ }
+
+ numCharsToReplace = len - index;
+ }
+
+ const int newStringLen = (stringToInsert != 0) ? CharacterFunctions::length (stringToInsert) : 0;
+ const int newTotalLen = len + newStringLen - numCharsToReplace;
+
+ String result (newTotalLen, (int) 0);
+
+ memcpy (result.text->text,
+ text->text,
+ index * sizeof (tchar));
+
+ if (newStringLen > 0)
+ memcpy (result.text->text + index,
+ stringToInsert,
+ newStringLen * sizeof (tchar));
+
+ const int endStringLen = newTotalLen - (index + newStringLen);
+
+ if (endStringLen > 0)
+ memcpy (result.text->text + (index + newStringLen),
+ text->text + (index + numCharsToReplace),
+ endStringLen * sizeof (tchar));
+
+ result.text->text [newTotalLen] = 0;
+
+ return result;
+}
+
+const String String::replace (const tchar* const stringToReplace,
+ const tchar* const stringToInsert,
+ const bool ignoreCase) const throw()
+{
+ const int stringToReplaceLen = CharacterFunctions::length (stringToReplace);
+ const int stringToInsertLen = CharacterFunctions::length (stringToInsert);
+
+ int i = 0;
+ String result (*this);
+
+ while ((i = (ignoreCase ? result.indexOfIgnoreCase (i, stringToReplace)
+ : result.indexOf (i, stringToReplace))) >= 0)
+ {
+ result = result.replaceSection (i, stringToReplaceLen, stringToInsert);
+ i += stringToInsertLen;
+ }
+
+ return result;
+}
+
+const String String::replaceCharacter (const tchar charToReplace,
+ const tchar charToInsert) const throw()
+{
+ const int index = indexOfChar (charToReplace);
+
+ if (index < 0)
+ return *this;
+
+ String result (*this);
+ result.dupeInternalIfMultiplyReferenced();
+
+ tchar* t = result.text->text + index;
+
+ while (*t != 0)
+ {
+ if (*t == charToReplace)
+ *t = charToInsert;
+
+ ++t;
+ }
+
+ return result;
+}
+
+const String String::replaceCharacters (const String& charactersToReplace,
+ const tchar* const charactersToInsertInstead) const throw()
+{
+ String result (*this);
+ result.dupeInternalIfMultiplyReferenced();
+
+ tchar* t = result.text->text;
+ const int len2 = CharacterFunctions::length (charactersToInsertInstead);
+
+ // the two strings passed in are supposed to be the same length!
+ jassert (len2 == charactersToReplace.length());
+
+ while (*t != 0)
+ {
+ const int index = charactersToReplace.indexOfChar (*t);
+
+ if (((unsigned int) index) < (unsigned int) len2)
+ *t = charactersToInsertInstead [index];
+
+ ++t;
+ }
+
+ return result;
+}
+
+bool String::startsWith (const tchar* const other) const throw()
+{
+ return other != 0
+ && CharacterFunctions::compare (text->text, other, CharacterFunctions::length (other)) == 0;
+}
+
+bool String::startsWithIgnoreCase (const tchar* const other) const throw()
+{
+ return other != 0
+ && CharacterFunctions::compareIgnoreCase (text->text, other, CharacterFunctions::length (other)) == 0;
+}
+
+bool String::startsWithChar (const tchar character) const throw()
+{
+ return text->text[0] == character;
+}
+
+bool String::endsWithChar (const tchar character) const throw()
+{
+ return text->text[0] != 0
+ && text->text [length() - 1] == character;
+}
+
+bool String::endsWith (const tchar* const other) const throw()
+{
+ if (other == 0)
+ return false;
+
+ const int thisLen = length();
+ const int otherLen = CharacterFunctions::length (other);
+
+ return thisLen >= otherLen
+ && CharacterFunctions::compare (text->text + thisLen - otherLen, other) == 0;
+}
+
+bool String::endsWithIgnoreCase (const tchar* const other) const throw()
+{
+ if (other == 0)
+ return false;
+
+ const int thisLen = length();
+ const int otherLen = CharacterFunctions::length (other);
+
+ return thisLen >= otherLen
+ && CharacterFunctions::compareIgnoreCase (text->text + thisLen - otherLen, other) == 0;
+}
+
+const String String::toUpperCase() const throw()
+{
+ String result (*this);
+ result.dupeInternalIfMultiplyReferenced();
+ CharacterFunctions::toUpperCase (result.text->text);
+ return result;
+}
+
+const String String::toLowerCase() const throw()
+{
+ String result (*this);
+ result.dupeInternalIfMultiplyReferenced();
+ CharacterFunctions::toLowerCase (result.text->text);
+ return result;
+}
+
+tchar& String::operator[] (const int index) throw()
+{
+ jassert (((unsigned int) index) <= (unsigned int) length());
+
+ dupeInternalIfMultiplyReferenced();
+
+ return text->text [index];
+}
+
+tchar String::getLastCharacter() const throw()
+{
+ return (isEmpty()) ? ((tchar) 0)
+ : text->text [CharacterFunctions::length (text->text) - 1];
+}
+
+const String String::substring (int start, int end) const throw()
+{
+ if (start < 0)
+ start = 0;
+ else if (end <= start)
+ return empty;
+
+ int len = 0;
+ const tchar* const t = text->text;
+
+ while (len <= end && t [len] != 0)
+ ++len;
+
+ if (end >= len)
+ {
+ if (start == 0)
+ return *this;
+
+ end = len;
+ }
+
+ return String (text->text + start,
+ end - start);
+}
+
+const String String::substring (const int start) const throw()
+{
+ if (start <= 0)
+ return *this;
+
+ const int len = CharacterFunctions::length (text->text);
+
+ if (start >= len)
+ return empty;
+ else
+ return String (text->text + start,
+ len - start);
+}
+
+const String String::dropLastCharacters (const int numberToDrop) const throw()
+{
+ return String (text->text,
+ jmax (0, CharacterFunctions::length (text->text) - numberToDrop));
+}
+
+const String String::fromFirstOccurrenceOf (const tchar* const sub,
+ const bool includeSubString,
+ const bool ignoreCase) const throw()
+{
+ const int i = ignoreCase ? indexOf (sub)
+ : indexOfIgnoreCase (sub);
+
+ if (i < 0)
+ return empty;
+ else
+ return substring ((includeSubString) ? i : i + CharacterFunctions::length (sub));
+}
+
+const String String::fromLastOccurrenceOf (const tchar* const sub,
+ const bool includeSubString,
+ const bool ignoreCase) const throw()
+{
+ const int i = ignoreCase ? lastIndexOf (sub)
+ : lastIndexOfIgnoreCase (sub);
+
+ if (i < 0)
+ return *this;
+ else
+ return substring ((includeSubString) ? i : i + CharacterFunctions::length (sub));
+}
+
+const String String::upToFirstOccurrenceOf (const tchar* const sub,
+ const bool includeSubString,
+ const bool ignoreCase) const throw()
+{
+ const int i = ignoreCase ? indexOfIgnoreCase (sub)
+ : indexOf (sub);
+
+ if (i < 0)
+ return *this;
+ else
+ return substring (0, (includeSubString) ? i + CharacterFunctions::length (sub) : i);
+}
+
+const String String::upToLastOccurrenceOf (const tchar* const sub,
+ const bool includeSubString,
+ const bool ignoreCase) const throw()
+{
+ const int i = ignoreCase ? lastIndexOfIgnoreCase (sub)
+ : lastIndexOf (sub);
+ if (i < 0)
+ return *this;
+
+ return substring (0, (includeSubString) ? i + CharacterFunctions::length (sub) : i);
+}
+
+bool String::isQuotedString() const throw()
+{
+ const String trimmed (trimStart());
+
+ return trimmed[0] == T('"')
+ || trimmed[0] == T('\'');
+}
+
+const String String::unquoted() const throw()
+{
+ String s (*this);
+
+ if (s[0] == T('"') || s[0] == T('\''))
+ s = s.substring (1);
+
+ const int lastCharIndex = s.length() - 1;
+
+ if (lastCharIndex >= 0
+ && (s [lastCharIndex] == T('"') || s[lastCharIndex] == T('\'')))
+ s [lastCharIndex] = 0;
+
+ return s;
+}
+
+const String String::quoted (const tchar quoteCharacter) const throw()
+{
+ if (isEmpty())
+ return charToString (quoteCharacter) + quoteCharacter;
+
+ String t (*this);
+
+ if (! t.startsWithChar (quoteCharacter))
+ t = charToString (quoteCharacter) + t;
+
+ if (! t.endsWithChar (quoteCharacter))
+ t += quoteCharacter;
+
+ return t;
+}
+
+const String String::trim() const throw()
+{
+ if (isEmpty())
+ return empty;
+
+ int start = 0;
+
+ while (CharacterFunctions::isWhitespace (text->text [start]))
+ ++start;
+
+ const int len = CharacterFunctions::length (text->text);
+ int end = len - 1;
+
+ while ((end >= start) && CharacterFunctions::isWhitespace (text->text [end]))
+ --end;
+
+ ++end;
+
+ if (end <= start)
+ return empty;
+ else if (start > 0 || end < len)
+ return String (text->text + start, end - start);
+ else
+ return *this;
+}
+
+const String String::trimStart() const throw()
+{
+ if (isEmpty())
+ return empty;
+
+ const tchar* t = text->text;
+
+ while (CharacterFunctions::isWhitespace (*t))
+ ++t;
+
+ if (t == text->text)
+ return *this;
+ else
+ return String (t);
+}
+
+const String String::trimEnd() const throw()
+{
+ if (isEmpty())
+ return empty;
+
+ const tchar* endT = text->text + (CharacterFunctions::length (text->text) - 1);
+
+ while ((endT >= text->text) && CharacterFunctions::isWhitespace (*endT))
+ --endT;
+
+ return String (text->text, (int) (++endT - text->text));
+}
+
+const String String::retainCharacters (const tchar* const charactersToRetain) const throw()
+{
+ jassert (charactersToRetain != 0);
+
+ if (isEmpty())
+ return empty;
+
+ String result (text->allocatedNumChars, (int) 0);
+ tchar* dst = result.text->text;
+ const tchar* src = text->text;
+
+ while (*src != 0)
+ {
+ if (CharacterFunctions::indexOfCharFast (charactersToRetain, *src) >= 0)
+ *dst++ = *src;
+
+ ++src;
+ }
+
+ *dst = 0;
+ return result;
+}
+
+const String String::removeCharacters (const tchar* const charactersToRemove) const throw()
+{
+ jassert (charactersToRemove != 0);
+
+ if (isEmpty())
+ return empty;
+
+ String result (text->allocatedNumChars, (int) 0);
+ tchar* dst = result.text->text;
+ const tchar* src = text->text;
+
+ while (*src != 0)
+ {
+ if (CharacterFunctions::indexOfCharFast (charactersToRemove, *src) < 0)
+ *dst++ = *src;
+
+ ++src;
+ }
+
+ *dst = 0;
+ return result;
+}
+
+const String String::initialSectionContainingOnly (const tchar* const permittedCharacters) const throw()
+{
+ return substring (0, CharacterFunctions::getIntialSectionContainingOnly (text->text, permittedCharacters));
+}
+
+const String String::initialSectionNotContaining (const tchar* const charactersToStopAt) const throw()
+{
+ jassert (charactersToStopAt != 0);
+
+ const tchar* const t = text->text;
+ int i = 0;
+
+ while (t[i] != 0)
+ {
+ if (CharacterFunctions::indexOfCharFast (charactersToStopAt, t[i]) >= 0)
+ return String (text->text, i);
+
+ ++i;
+ }
+
+ return empty;
+}
+
+bool String::containsOnly (const tchar* const chars) const throw()
+{
+ jassert (chars != 0);
+
+ const tchar* t = text->text;
+
+ while (*t != 0)
+ if (CharacterFunctions::indexOfCharFast (chars, *t++) < 0)
+ return false;
+
+ return true;
+}
+
+bool String::containsAnyOf (const tchar* const chars) const throw()
+{
+ jassert (chars != 0);
+
+ const tchar* t = text->text;
+
+ while (*t != 0)
+ if (CharacterFunctions::indexOfCharFast (chars, *t++) >= 0)
+ return true;
+
+ return false;
+}
+
+int String::getIntValue() const throw()
+{
+ return CharacterFunctions::getIntValue (text->text);
+}
+
+int String::getTrailingIntValue() const throw()
+{
+ int n = 0;
+ int mult = 1;
+ const tchar* t = text->text + length();
+
+ while (--t >= text->text)
+ {
+ const tchar c = *t;
+
+ if (! CharacterFunctions::isDigit (c))
+ {
+ if (c == T('-'))
+ n = -n;
+
+ break;
+ }
+
+ n += mult * (c - T('0'));
+ mult *= 10;
+ }
+
+ return n;
+}
+
+int64 String::getLargeIntValue() const throw()
+{
+ return CharacterFunctions::getInt64Value (text->text);
+}
+
+float String::getFloatValue() const throw()
+{
+ return (float) CharacterFunctions::getDoubleValue (text->text);
+}
+
+double String::getDoubleValue() const throw()
+{
+ return CharacterFunctions::getDoubleValue (text->text);
+}
+
+static const tchar* const hexDigits = T("0123456789abcdef");
+
+const String String::toHexString (const int number) throw()
+{
+ tchar buffer[32];
+ tchar* const end = buffer + 32;
+ tchar* t = end;
+ *--t = 0;
+ unsigned int v = (unsigned int) number;
+
+ do
+ {
+ *--t = hexDigits [v & 15];
+ v >>= 4;
+
+ } while (v != 0);
+
+ return String (t, (int) (((char*) end) - (char*) t) - 1);
+}
+
+const String String::toHexString (const int64 number) throw()
+{
+ tchar buffer[32];
+ tchar* const end = buffer + 32;
+ tchar* t = end;
+ *--t = 0;
+ uint64 v = (uint64) number;
+
+ do
+ {
+ *--t = hexDigits [(int) (v & 15)];
+ v >>= 4;
+
+ } while (v != 0);
+
+ return String (t, (int) (((char*) end) - (char*) t));
+}
+
+const String String::toHexString (const short number) throw()
+{
+ return toHexString ((int) (unsigned short) number);
+}
+
+const String String::toHexString (const unsigned char* data,
+ const int size,
+ const int groupSize) throw()
+{
+ if (size <= 0)
+ return empty;
+
+ int numChars = (size * 2) + 2;
+ if (groupSize > 0)
+ numChars += size / groupSize;
+
+ String s (numChars, (int) 0);
+
+ tchar* d = s.text->text;
+
+ for (int i = 0; i < size; ++i)
+ {
+ *d++ = hexDigits [(*data) >> 4];
+ *d++ = hexDigits [(*data) & 0xf];
+ ++data;
+
+ if (groupSize > 0 && (i % groupSize) == 0)
+ *d++ = T(' ');
+ }
+
+ if (groupSize > 0)
+ --d;
+
+ *d = 0;
+
+ return s;
+}
+
+int String::getHexValue32() const throw()
+{
+ int result = 0;
+ const tchar* c = text->text;
+
+ for (;;)
+ {
+ const int hexValue = CharacterFunctions::getHexDigitValue (*c);
+
+ if (hexValue >= 0)
+ result = (result << 4) | hexValue;
+ else if (*c == 0)
+ break;
+
+ ++c;
+ }
+
+ return result;
+}
+
+int64 String::getHexValue64() const throw()
+{
+ int64 result = 0;
+ const tchar* c = text->text;
+
+ for (;;)
+ {
+ const int hexValue = CharacterFunctions::getHexDigitValue (*c);
+
+ if (hexValue >= 0)
+ result = (result << 4) | hexValue;
+ else if (*c == 0)
+ break;
+
+ ++c;
+ }
+
+ return result;
+}
+
+const String String::createStringFromData (const void* const data_,
+ const int size) throw()
+{
+ const char* const data = (const char*) data_;
+
+ if (size <= 0 || data == 0)
+ {
+ return empty;
+ }
+ else if (size < 2)
+ {
+ return charToString (data[0]);
+ }
+ else if ((data[0] == (char)-2 && data[1] == (char)-1)
+ || (data[0] == (char)-1 && data[1] == (char)-2))
+ {
+ // assume it's 16-bit unicode
+ const bool bigEndian = (data[0] == (char)-2);
+ const int numChars = size / 2 - 1;
+
+ String result;
+ result.preallocateStorage (numChars + 2);
+
+ const uint16* const src = (const uint16*) (data + 2);
+ tchar* const dst = const_cast ((const tchar*) result);
+
+ if (bigEndian)
+ {
+ for (int i = 0; i < numChars; ++i)
+ dst[i] = (tchar) swapIfLittleEndian (src[i]);
+ }
+ else
+ {
+ for (int i = 0; i < numChars; ++i)
+ dst[i] = (tchar) swapIfBigEndian (src[i]);
+ }
+
+ dst [numChars] = 0;
+ return result;
+ }
+ else
+ {
+#if JUCE_STRINGS_ARE_UNICODE && JUCE_LINUX
+ // (workaround for strange behaviour of mbstowcs)
+ int i;
+ for (i = 0; i < size; ++i)
+ if (data[i] == 0)
+ break;
+
+ String result;
+ result.preallocateStorage (i + 1);
+ tchar* const dst = const_cast ((const tchar*) result);
+
+ for (int j = 0; j < i; ++j)
+ dst[j] = (juce_wchar) (unsigned char) data[j];
+
+ dst[i] = 0;
+
+ return result;
+#else
+ return String (data, size);
+#endif
+ }
+}
+
+const char* String::toUTF8() const throw()
+{
+ if (isEmpty())
+ {
+ return (const char*) emptyCharString;
+ }
+ else
+ {
+ String* const mutableThis = const_cast (this);
+
+ mutableThis->dupeInternalIfMultiplyReferenced();
+
+ const int currentLen = CharacterFunctions::length (text->text) + 1;
+ const int utf8BytesNeeded = copyToUTF8 (0);
+
+ mutableThis->text = (InternalRefCountedStringHolder*)
+ juce_realloc (text, sizeof (InternalRefCountedStringHolder)
+ + (currentLen * sizeof (juce_wchar) + utf8BytesNeeded));
+
+ char* const otherCopy = (char*) (text->text + currentLen);
+ copyToUTF8 ((uint8*) otherCopy);
+
+ return otherCopy;
+ }
+}
+
+int String::copyToUTF8 (uint8* const buffer) const throw()
+{
+#if JUCE_STRINGS_ARE_UNICODE
+ int num = 0, index = 0;
+
+ for (;;)
+ {
+ const uint32 c = (uint32) text->text [index++];
+
+ if (c >= 0x80)
+ {
+ int numExtraBytes = 1;
+
+ if (c >= 0x800)
+ {
+ ++numExtraBytes;
+
+ if (c >= 0x10000)
+ {
+ ++numExtraBytes;
+
+ if (c >= 0x200000)
+ {
+ ++numExtraBytes;
+
+ if (c >= 0x4000000)
+ ++numExtraBytes;
+ }
+ }
+ }
+
+ if (buffer != 0)
+ {
+ buffer [num++] = (uint8) ((0xff << (7 - numExtraBytes)) | (c >> (numExtraBytes * 6)));
+
+ while (--numExtraBytes >= 0)
+ buffer [num++] = (uint8) (0x80 | (0x3f & (c >> (numExtraBytes * 6))));
+ }
+ else
+ {
+ num += numExtraBytes + 1;
+ }
+ }
+ else
+ {
+ if (buffer != 0)
+ buffer [num] = (uint8) c;
+
+ ++num;
+ }
+
+ if (c == 0)
+ break;
+ }
+
+ return num;
+
+#else
+ const int numBytes = length() + 1;
+
+ if (buffer != 0)
+ copyToBuffer ((char*) buffer, numBytes);
+
+ return numBytes;
+#endif
+}
+
+const String String::fromUTF8 (const uint8* const buffer, int bufferSizeBytes) throw()
+{
+ if (buffer == 0)
+ return empty;
+
+ if (bufferSizeBytes < 0)
+ bufferSizeBytes = INT_MAX;
+
+ int numBytes;
+ for (numBytes = 0; numBytes < bufferSizeBytes; ++numBytes)
+ if (buffer [numBytes] == 0)
+ break;
+
+ String result (numBytes + 1, 0);
+ tchar* dest = result.text->text;
+
+ int i = 0;
+ while (i < numBytes)
+ {
+ const uint8 c = buffer [i++];
+
+ if ((c & 0x80) != 0)
+ {
+ int mask = 0x7f;
+ int bit = 0x40;
+ int numExtraValues = 0;
+
+ while (bit != 0 && (c & bit) != 0)
+ {
+ bit >>= 1;
+ mask >>= 1;
+ ++numExtraValues;
+ }
+
+ int n = (c & mask);
+
+ while (--numExtraValues >= 0 && i < bufferSizeBytes)
+ {
+ const uint8 c = buffer[i];
+
+ if ((c & 0xc0) != 0x80)
+ break;
+
+ n <<= 6;
+ n |= (c & 0x3f);
+ ++i;
+ }
+
+ *dest++ = (tchar) n;
+ }
+ else
+ {
+ *dest++ = (tchar) c;
+ }
+ }
+
+ *dest = 0;
+ return result;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_String.cpp *********/
+
+/********* Start of inlined file: juce_StringArray.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+StringArray::StringArray() throw()
+{
+}
+
+StringArray::StringArray (const StringArray& other) throw()
+{
+ addArray (other);
+}
+
+StringArray::StringArray (const juce_wchar** const strings,
+ const int numberOfStrings) throw()
+{
+ for (int i = 0; i < numberOfStrings; ++i)
+ add (strings [i]);
+}
+
+StringArray::StringArray (const char** const strings,
+ const int numberOfStrings) throw()
+{
+ for (int i = 0; i < numberOfStrings; ++i)
+ add (strings [i]);
+}
+
+StringArray::StringArray (const juce_wchar** const strings) throw()
+{
+ int i = 0;
+
+ while (strings[i] != 0)
+ add (strings [i++]);
+}
+
+StringArray::StringArray (const char** const strings) throw()
+{
+ int i = 0;
+
+ while (strings[i] != 0)
+ add (strings [i++]);
+}
+
+const StringArray& StringArray::operator= (const StringArray& other) throw()
+{
+ if (this != &other)
+ {
+ clear();
+ addArray (other);
+ }
+
+ return *this;
+}
+
+StringArray::~StringArray() throw()
+{
+ clear();
+}
+
+bool StringArray::operator== (const StringArray& other) const throw()
+{
+ if (other.size() != size())
+ return false;
+
+ for (int i = size(); --i >= 0;)
+ {
+ if (*(String*) other.strings.getUnchecked(i)
+ != *(String*) strings.getUnchecked(i))
+ {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+bool StringArray::operator!= (const StringArray& other) const throw()
+{
+ return ! operator== (other);
+}
+
+void StringArray::clear() throw()
+{
+ for (int i = size(); --i >= 0;)
+ {
+ String* const s = (String*) strings.getUnchecked(i);
+ delete s;
+ }
+
+ strings.clear();
+}
+
+const String& StringArray::operator[] (const int index) const throw()
+{
+ if (((unsigned int) index) < (unsigned int) strings.size())
+ return *(const String*) (strings.getUnchecked (index));
+
+ return String::empty;
+}
+
+void StringArray::add (const String& newString) throw()
+{
+ strings.add (new String (newString));
+}
+
+void StringArray::insert (const int index,
+ const String& newString) throw()
+{
+ strings.insert (index, new String (newString));
+}
+
+void StringArray::addIfNotAlreadyThere (const String& newString,
+ const bool ignoreCase) throw()
+{
+ if (! contains (newString, ignoreCase))
+ add (newString);
+}
+
+void StringArray::addArray (const StringArray& otherArray,
+ int startIndex,
+ int numElementsToAdd) throw()
+{
+ if (startIndex < 0)
+ {
+ jassertfalse
+ startIndex = 0;
+ }
+
+ if (numElementsToAdd < 0 || startIndex + numElementsToAdd > otherArray.size())
+ numElementsToAdd = otherArray.size() - startIndex;
+
+ while (--numElementsToAdd >= 0)
+ strings.add (new String (*(const String*) otherArray.strings.getUnchecked (startIndex++)));
+}
+
+void StringArray::set (const int index,
+ const String& newString) throw()
+{
+ String* const s = (String*) strings [index];
+
+ if (s != 0)
+ {
+ *s = newString;
+ }
+ else if (index >= 0)
+ {
+ add (newString);
+ }
+}
+
+bool StringArray::contains (const String& stringToLookFor,
+ const bool ignoreCase) const throw()
+{
+ if (ignoreCase)
+ {
+ for (int i = size(); --i >= 0;)
+ if (stringToLookFor.equalsIgnoreCase (*(const String*)(strings.getUnchecked(i))))
+ return true;
+ }
+ else
+ {
+ for (int i = size(); --i >= 0;)
+ if (stringToLookFor == *(const String*)(strings.getUnchecked(i)))
+ return true;
+ }
+
+ return false;
+}
+
+int StringArray::indexOf (const String& stringToLookFor,
+ const bool ignoreCase,
+ int i) const throw()
+{
+ if (i < 0)
+ i = 0;
+
+ const int numElements = size();
+
+ if (ignoreCase)
+ {
+ while (i < numElements)
+ {
+ if (stringToLookFor.equalsIgnoreCase (*(const String*) strings.getUnchecked (i)))
+ return i;
+
+ ++i;
+ }
+ }
+ else
+ {
+ while (i < numElements)
+ {
+ if (stringToLookFor == *(const String*) strings.getUnchecked (i))
+ return i;
+
+ ++i;
+ }
+ }
+
+ return -1;
+}
+
+void StringArray::remove (const int index) throw()
+{
+ String* const s = (String*) strings [index];
+
+ if (s != 0)
+ {
+ strings.remove (index);
+ delete s;
+ }
+}
+
+void StringArray::removeString (const String& stringToRemove,
+ const bool ignoreCase) throw()
+{
+ if (ignoreCase)
+ {
+ for (int i = size(); --i >= 0;)
+ if (stringToRemove.equalsIgnoreCase (*(const String*) strings.getUnchecked (i)))
+ remove (i);
+ }
+ else
+ {
+ for (int i = size(); --i >= 0;)
+ if (stringToRemove == *(const String*) strings.getUnchecked (i))
+ remove (i);
+ }
+}
+
+void StringArray::removeEmptyStrings (const bool removeWhitespaceStrings) throw()
+{
+ if (removeWhitespaceStrings)
+ {
+ for (int i = size(); --i >= 0;)
+ if (((const String*) strings.getUnchecked(i))->trim().isEmpty())
+ remove (i);
+ }
+ else
+ {
+ for (int i = size(); --i >= 0;)
+ if (((const String*) strings.getUnchecked(i))->isEmpty())
+ remove (i);
+ }
+}
+
+void StringArray::trim() throw()
+{
+ for (int i = size(); --i >= 0;)
+ {
+ String& s = *(String*) strings.getUnchecked(i);
+ s = s.trim();
+ }
+}
+
+class InternalStringArrayComparator
+{
+public:
+ static int compareElements (void* const first, void* const second) throw()
+ {
+ return ((const String*) first)->compare (*(const String*) second);
+ }
+};
+
+class InsensitiveInternalStringArrayComparator
+{
+public:
+ static int compareElements (void* const first, void* const second) throw()
+ {
+ return ((const String*) first)->compareIgnoreCase (*(const String*) second);
+ }
+};
+
+void StringArray::sort (const bool ignoreCase) throw()
+{
+ if (ignoreCase)
+ {
+ InsensitiveInternalStringArrayComparator comp;
+ strings.sort (comp);
+ }
+ else
+ {
+ InternalStringArrayComparator comp;
+ strings.sort (comp);
+ }
+}
+
+void StringArray::move (const int currentIndex, int newIndex) throw()
+{
+ strings.move (currentIndex, newIndex);
+}
+
+const String StringArray::joinIntoString (const String& separator,
+ int start,
+ int numberToJoin) const throw()
+{
+ const int last = (numberToJoin < 0) ? size()
+ : jmin (size(), start + numberToJoin);
+
+ if (start < 0)
+ start = 0;
+
+ if (start >= last)
+ return String::empty;
+
+ if (start == last - 1)
+ return *(const String*) strings.getUnchecked (start);
+
+ const int separatorLen = separator.length();
+ int charsNeeded = separatorLen * (last - start - 1);
+
+ for (int i = start; i < last; ++i)
+ charsNeeded += ((const String*) strings.getUnchecked(i))->length();
+
+ String result;
+ result.preallocateStorage (charsNeeded);
+
+ tchar* dest = (tchar*) (const tchar*) result;
+
+ while (start < last)
+ {
+ const String& s = *(const String*) strings.getUnchecked (start);
+ const int len = s.length();
+
+ if (len > 0)
+ {
+ s.copyToBuffer (dest, len);
+ dest += len;
+ }
+
+ if (++start < last && separatorLen > 0)
+ {
+ separator.copyToBuffer (dest, separatorLen);
+ dest += separatorLen;
+ }
+ }
+
+ *dest = 0;
+
+ return result;
+}
+
+int StringArray::addTokens (const tchar* const text,
+ const bool preserveQuotedStrings) throw()
+{
+ return addTokens (text,
+ T(" \n\r\t"),
+ preserveQuotedStrings ? T("\"") : 0);
+}
+
+int StringArray::addTokens (const tchar* const text,
+ const tchar* breakCharacters,
+ const tchar* quoteCharacters) throw()
+{
+ int num = 0;
+
+ if (text != 0 && *text != 0)
+ {
+ if (breakCharacters == 0)
+ breakCharacters = T("");
+
+ if (quoteCharacters == 0)
+ quoteCharacters = T("");
+
+ bool insideQuotes = false;
+ tchar currentQuoteChar = 0;
+
+ int i = 0;
+ int tokenStart = 0;
+
+ for (;;)
+ {
+ const tchar c = text[i];
+
+ bool isBreak = (c == 0);
+
+ if (! (insideQuotes || isBreak))
+ {
+ const tchar* b = breakCharacters;
+ while (*b != 0)
+ {
+ if (*b++ == c)
+ {
+ isBreak = true;
+ break;
+ }
+ }
+ }
+
+ if (! isBreak)
+ {
+ bool isQuote = false;
+ const tchar* q = quoteCharacters;
+ while (*q != 0)
+ {
+ if (*q++ == c)
+ {
+ isQuote = true;
+ break;
+ }
+ }
+
+ if (isQuote)
+ {
+ if (insideQuotes)
+ {
+ // only break out of quotes-mode if we find a matching quote to the
+ // one that we opened with..
+ if (currentQuoteChar == c)
+ insideQuotes = false;
+ }
+ else
+ {
+ insideQuotes = true;
+ currentQuoteChar = c;
+ }
+ }
+ }
+ else
+ {
+ add (String (text + tokenStart, i - tokenStart));
+
+ ++num;
+ tokenStart = i + 1;
+ }
+
+ if (c == 0)
+ break;
+
+ ++i;
+ }
+ }
+
+ return num;
+}
+
+int StringArray::addLines (const tchar* text) throw()
+{
+ int numLines = 0;
+
+ if (text != 0)
+ {
+ while (*text != 0)
+ {
+ const tchar* const startOfLine = text;
+
+ while (*text != 0)
+ {
+ if (*text == T('\r'))
+ {
+ ++text;
+ if (*text == T('\n'))
+ ++text;
+
+ break;
+ }
+
+ if (*text == T('\n'))
+ {
+ ++text;
+ break;
+ }
+
+ ++text;
+ }
+
+ const tchar* endOfLine = text;
+ if (endOfLine > startOfLine && (*(endOfLine - 1) == T('\r') || *(endOfLine - 1) == T('\n')))
+ --endOfLine;
+
+ if (endOfLine > startOfLine && (*(endOfLine - 1) == T('\r') || *(endOfLine - 1) == T('\n')))
+ --endOfLine;
+
+ add (String (startOfLine, jmax (0, (int) (endOfLine - startOfLine))));
+
+ ++numLines;
+ }
+ }
+
+ return numLines;
+}
+
+void StringArray::removeDuplicates (const bool ignoreCase) throw()
+{
+ for (int i = 0; i < size() - 1; ++i)
+ {
+ const String& s = *(String*) strings.getUnchecked(i);
+
+ int nextIndex = i + 1;
+
+ for (;;)
+ {
+ nextIndex = indexOf (s, ignoreCase, nextIndex);
+
+ if (nextIndex < 0)
+ break;
+
+ remove (nextIndex);
+ }
+ }
+}
+
+void StringArray::appendNumbersToDuplicates (const bool ignoreCase,
+ const bool appendNumberToFirstInstance,
+ const tchar* const preNumberString,
+ const tchar* const postNumberString) throw()
+{
+ for (int i = 0; i < size() - 1; ++i)
+ {
+ String& s = *(String*) strings.getUnchecked(i);
+
+ int nextIndex = indexOf (s, ignoreCase, i + 1);
+
+ if (nextIndex >= 0)
+ {
+ const String original (s);
+
+ int number = 0;
+
+ if (appendNumberToFirstInstance)
+ s = original + preNumberString + String (++number) + postNumberString;
+ else
+ ++number;
+
+ while (nextIndex >= 0)
+ {
+ set (nextIndex, (*this)[nextIndex] + preNumberString + String (++number) + postNumberString);
+ nextIndex = indexOf (original, ignoreCase, nextIndex + 1);
+ }
+ }
+ }
+}
+
+void StringArray::minimiseStorageOverheads() throw()
+{
+ strings.minimiseStorageOverheads();
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_StringArray.cpp *********/
+
+/********* Start of inlined file: juce_StringPairArray.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+StringPairArray::StringPairArray (const bool ignoreCase_) throw()
+ : ignoreCase (ignoreCase_)
+{
+}
+
+StringPairArray::StringPairArray (const StringPairArray& other) throw()
+ : keys (other.keys),
+ values (other.values),
+ ignoreCase (other.ignoreCase)
+{
+}
+
+StringPairArray::~StringPairArray() throw()
+{
+}
+
+const StringPairArray& StringPairArray::operator= (const StringPairArray& other) throw()
+{
+ keys = other.keys;
+ values = other.values;
+
+ return *this;
+}
+
+bool StringPairArray::operator== (const StringPairArray& other) const throw()
+{
+ for (int i = keys.size(); --i >= 0;)
+ if (other [keys[i]] != values[i])
+ return false;
+
+ return true;
+}
+
+bool StringPairArray::operator!= (const StringPairArray& other) const throw()
+{
+ return ! operator== (other);
+}
+
+const String& StringPairArray::operator[] (const String& key) const throw()
+{
+ return values [keys.indexOf (key, ignoreCase)];
+}
+
+const String StringPairArray::getValue (const String& key, const String& defaultReturnValue) const
+{
+ const int i = keys.indexOf (key, ignoreCase);
+
+ if (i >= 0)
+ return values[i];
+
+ return defaultReturnValue;
+}
+
+void StringPairArray::set (const String& key,
+ const String& value) throw()
+{
+ const int i = keys.indexOf (key, ignoreCase);
+
+ if (i >= 0)
+ {
+ values.set (i, value);
+ }
+ else
+ {
+ keys.add (key);
+ values.add (value);
+ }
+}
+
+void StringPairArray::addArray (const StringPairArray& other)
+{
+ for (int i = 0; i < other.size(); ++i)
+ set (other.keys[i], other.values[i]);
+}
+
+void StringPairArray::clear() throw()
+{
+ keys.clear();
+ values.clear();
+}
+
+void StringPairArray::remove (const String& key) throw()
+{
+ remove (keys.indexOf (key, ignoreCase));
+}
+
+void StringPairArray::remove (const int index) throw()
+{
+ keys.remove (index);
+ values.remove (index);
+}
+
+void StringPairArray::minimiseStorageOverheads() throw()
+{
+ keys.minimiseStorageOverheads();
+ values.minimiseStorageOverheads();
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_StringPairArray.cpp *********/
+
+/********* Start of inlined file: juce_XmlDocument.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+static bool isXmlIdentifierChar_Slow (const tchar c) throw()
+{
+ return CharacterFunctions::isLetterOrDigit (c)
+ || c == T('_')
+ || c == T('-')
+ || c == T(':')
+ || c == T('.');
+}
+
+#define isXmlIdentifierChar(c) \
+ ((c > 0 && c <= 127) ? identifierLookupTable [(int) c] : isXmlIdentifierChar_Slow (c))
+
+XmlDocument::XmlDocument (const String& documentText) throw()
+ : originalText (documentText),
+ inputSource (0)
+{
+}
+
+XmlDocument::XmlDocument (const File& file)
+{
+ inputSource = new FileInputSource (file);
+}
+
+XmlDocument::~XmlDocument() throw()
+{
+ delete inputSource;
+}
+
+void XmlDocument::setInputSource (InputSource* const newSource) throw()
+{
+ if (inputSource != newSource)
+ {
+ delete inputSource;
+ inputSource = newSource;
+ }
+}
+
+XmlElement* XmlDocument::getDocumentElement (const bool onlyReadOuterDocumentElement)
+{
+ String textToParse (originalText);
+
+ if (textToParse.isEmpty() && inputSource != 0)
+ {
+ InputStream* const in = inputSource->createInputStream();
+
+ if (in != 0)
+ {
+ MemoryBlock data;
+
+ in->readIntoMemoryBlock (data, onlyReadOuterDocumentElement ? 8192 : -1);
+ delete in;
+
+ if (data.getSize() >= 2
+ && ((data[0] == (char)-2 && data[1] == (char)-1)
+ || (data[0] == (char)-1 && data[1] == (char)-2)))
+ {
+ textToParse = String::createStringFromData ((const char*) data.getData(), data.getSize());
+ }
+ else
+ {
+ textToParse = String::fromUTF8 ((const uint8*) data.getData(), data.getSize());
+ }
+
+ if (! onlyReadOuterDocumentElement)
+ originalText = textToParse;
+ }
+ }
+
+ input = textToParse;
+ lastError = String::empty;
+ errorOccurred = false;
+ outOfData = false;
+ needToLoadDTD = true;
+
+ for (int i = 0; i < 128; ++i)
+ identifierLookupTable[i] = isXmlIdentifierChar_Slow ((tchar) i);
+
+ if (textToParse.isEmpty())
+ {
+ lastError = "not enough input";
+ }
+ else
+ {
+ skipHeader();
+
+ if (input != 0)
+ {
+ XmlElement* const result = readNextElement (! onlyReadOuterDocumentElement);
+
+ if (errorOccurred)
+ delete result;
+ else
+ return result;
+ }
+ else
+ {
+ lastError = "incorrect xml header";
+ }
+ }
+
+ return 0;
+}
+
+const String& XmlDocument::getLastParseError() const throw()
+{
+ return lastError;
+}
+
+void XmlDocument::setLastError (const String& desc, const bool carryOn) throw()
+{
+ lastError = desc;
+ errorOccurred = ! carryOn;
+}
+
+const String XmlDocument::getFileContents (const String& filename) const
+{
+ String result;
+
+ if (inputSource != 0)
+ {
+ InputStream* const in = inputSource->createInputStreamFor (filename.trim().unquoted());
+
+ if (in != 0)
+ {
+ result = in->readEntireStreamAsString();
+ delete in;
+ }
+ }
+
+ return result;
+}
+
+tchar XmlDocument::readNextChar() throw()
+{
+ if (*input != 0)
+ {
+ return *input++;
+ }
+ else
+ {
+ outOfData = true;
+ return 0;
+ }
+}
+
+int XmlDocument::findNextTokenLength() throw()
+{
+ int len = 0;
+ tchar c = *input;
+
+ while (isXmlIdentifierChar (c))
+ c = input [++len];
+
+ return len;
+}
+
+void XmlDocument::skipHeader() throw()
+{
+ const tchar* const found = CharacterFunctions::find (input, T(""));
+
+ if (input == 0)
+ return;
+
+ input += 2;
+ }
+
+ skipNextWhiteSpace();
+ const tchar* docType = CharacterFunctions::find (input, T(" 0)
+ {
+ const tchar c = readNextChar();
+
+ if (outOfData)
+ return;
+
+ if (c == T('<'))
+ ++n;
+ else if (c == T('>'))
+ --n;
+ }
+
+ docType += 9;
+ dtdText = String (docType, (int) (input - (docType + 1))).trim();
+}
+
+void XmlDocument::skipNextWhiteSpace() throw()
+{
+ for (;;)
+ {
+ tchar c = *input;
+
+ while (CharacterFunctions::isWhitespace (c))
+ c = *++input;
+
+ if (c == 0)
+ {
+ outOfData = true;
+ break;
+ }
+ else if (c == T('<'))
+ {
+ if (input[1] == T('!')
+ && input[2] == T('-')
+ && input[3] == T('-'))
+ {
+ const tchar* const closeComment = CharacterFunctions::find (input, T("-->"));
+
+ if (closeComment == 0)
+ {
+ outOfData = true;
+ break;
+ }
+
+ input = closeComment + 3;
+ continue;
+ }
+ else if (input[1] == T('?'))
+ {
+ const tchar* const closeBracket = CharacterFunctions::find (input, T("?>"));
+
+ if (closeBracket == 0)
+ {
+ outOfData = true;
+ break;
+ }
+
+ input = closeBracket + 2;
+ continue;
+ }
+ }
+
+ break;
+ }
+}
+
+void XmlDocument::readQuotedString (String& result) throw()
+{
+ const tchar quote = readNextChar();
+
+ while (! outOfData)
+ {
+ const tchar character = readNextChar();
+
+ if (character == quote)
+ break;
+
+ if (character == T('&'))
+ {
+ --input;
+ readEntity (result);
+ }
+ else
+ {
+ --input;
+ const tchar* const start = input;
+
+ for (;;)
+ {
+ const tchar character = *input;
+
+ if (character == quote)
+ {
+ result.append (start, (int) (input - start));
+ ++input;
+
+ return;
+ }
+ else if (character == T('&'))
+ {
+ result.append (start, (int) (input - start));
+ break;
+ }
+ else if (character == 0)
+ {
+ outOfData = true;
+ setLastError ("unmatched quotes", false);
+ break;
+ }
+
+ ++input;
+ }
+ }
+ }
+}
+
+XmlElement* XmlDocument::readNextElement (const bool alsoParseSubElements) throw()
+{
+ XmlElement* node = 0;
+
+ skipNextWhiteSpace();
+ if (outOfData)
+ return 0;
+
+ input = CharacterFunctions::find (input, T("<"));
+
+ if (input != 0)
+ {
+ ++input;
+ int tagLen = findNextTokenLength();
+
+ if (tagLen == 0)
+ {
+ // no tag name - but allow for a gap after the '<' before giving an error
+ skipNextWhiteSpace();
+ tagLen = findNextTokenLength();
+
+ if (tagLen == 0)
+ {
+ setLastError ("tag name missing", false);
+ return node;
+ }
+ }
+
+ node = new XmlElement (input, tagLen);
+ input += tagLen;
+ XmlElement::XmlAttributeNode* lastAttribute = 0;
+
+ // look for attributes
+ for (;;)
+ {
+ skipNextWhiteSpace();
+
+ const tchar c = *input;
+
+ // empty tag..
+ if (c == T('/') && input[1] == T('>'))
+ {
+ input += 2;
+ break;
+ }
+
+ // parse the guts of the element..
+ if (c == T('>'))
+ {
+ ++input;
+ skipNextWhiteSpace();
+
+ if (alsoParseSubElements)
+ readChildElements (node);
+
+ break;
+ }
+
+ // get an attribute..
+ if (isXmlIdentifierChar (c))
+ {
+ const int attNameLen = findNextTokenLength();
+
+ if (attNameLen > 0)
+ {
+ const tchar* attNameStart = input;
+ input += attNameLen;
+
+ skipNextWhiteSpace();
+
+ if (readNextChar() == T('='))
+ {
+ skipNextWhiteSpace();
+
+ const tchar c = *input;
+
+ if (c == T('"') || c == T('\''))
+ {
+ XmlElement::XmlAttributeNode* const newAtt
+ = new XmlElement::XmlAttributeNode (String (attNameStart, attNameLen),
+ String::empty);
+
+ readQuotedString (newAtt->value);
+
+ if (lastAttribute == 0)
+ node->attributes = newAtt;
+ else
+ lastAttribute->next = newAtt;
+
+ lastAttribute = newAtt;
+
+ continue;
+ }
+ }
+ }
+ }
+ else
+ {
+ if (! outOfData)
+ setLastError ("illegal character found in " + node->getTagName() + ": '" + c + "'", false);
+ }
+
+ break;
+ }
+ }
+
+ return node;
+}
+
+void XmlDocument::readChildElements (XmlElement* parent) throw()
+{
+ XmlElement* lastChildNode = 0;
+
+ for (;;)
+ {
+ skipNextWhiteSpace();
+
+ if (outOfData)
+ {
+ setLastError ("unmatched tags", false);
+ break;
+ }
+
+ if (*input == T('<'))
+ {
+ if (input[1] == T('/'))
+ {
+ // our close tag..
+ input = CharacterFunctions::find (input, T(">"));
+ ++input;
+ break;
+ }
+ else if (input[1] == T('!')
+ && input[2] == T('[')
+ && input[3] == T('C')
+ && input[4] == T('D')
+ && input[5] == T('A')
+ && input[6] == T('T')
+ && input[7] == T('A')
+ && input[8] == T('['))
+ {
+ input += 9;
+ const tchar* const inputStart = input;
+
+ int len = 0;
+
+ for (;;)
+ {
+ if (*input == 0)
+ {
+ setLastError ("unterminated CDATA section", false);
+ outOfData = true;
+ break;
+ }
+ else if (input[0] == T(']')
+ && input[1] == T(']')
+ && input[2] == T('>'))
+ {
+ input += 3;
+ break;
+ }
+
+ ++input;
+ ++len;
+ }
+
+ XmlElement* const e = new XmlElement ((int) 0);
+ e->setText (String (inputStart, len));
+
+ if (lastChildNode != 0)
+ lastChildNode->nextElement = e;
+ else
+ parent->addChildElement (e);
+
+ lastChildNode = e;
+ }
+ else
+ {
+ // this is some other element, so parse and add it..
+ XmlElement* const n = readNextElement (true);
+
+ if (n != 0)
+ {
+ if (lastChildNode == 0)
+ parent->addChildElement (n);
+ else
+ lastChildNode->nextElement = n;
+
+ lastChildNode = n;
+ }
+ else
+ {
+ return;
+ }
+ }
+ }
+ else
+ {
+ // read character block..
+ XmlElement* const e = new XmlElement ((int)0);
+
+ if (lastChildNode != 0)
+ lastChildNode->nextElement = e;
+ else
+ parent->addChildElement (e);
+
+ lastChildNode = e;
+
+ String textElementContent;
+
+ for (;;)
+ {
+ const tchar c = *input;
+
+ if (c == T('<'))
+ break;
+
+ if (c == 0)
+ {
+ setLastError ("unmatched tags", false);
+ outOfData = true;
+ return;
+ }
+
+ if (c == T('&'))
+ {
+ String entity;
+ readEntity (entity);
+
+ if (entity.startsWithChar (T('<')) && entity [1] != 0)
+ {
+ const tchar* const oldInput = input;
+ const bool oldOutOfData = outOfData;
+
+ input = (const tchar*) entity;
+ outOfData = false;
+
+ for (;;)
+ {
+ XmlElement* const n = readNextElement (true);
+
+ if (n == 0)
+ break;
+
+ if (lastChildNode == 0)
+ parent->addChildElement (n);
+ else
+ lastChildNode->nextElement = n;
+
+ lastChildNode = n;
+ }
+
+ input = oldInput;
+ outOfData = oldOutOfData;
+ }
+ else
+ {
+ textElementContent += entity;
+ }
+ }
+ else
+ {
+ const tchar* start = input;
+ int len = 0;
+
+ for (;;)
+ {
+ const tchar c = *input;
+
+ if (c == T('<') || c == T('&'))
+ {
+ break;
+ }
+ else if (c == 0)
+ {
+ setLastError ("unmatched tags", false);
+ outOfData = true;
+ return;
+ }
+
+ ++input;
+ ++len;
+ }
+
+ textElementContent.append (start, len);
+ }
+ }
+
+ textElementContent = textElementContent.trim();
+
+ if (textElementContent.isNotEmpty())
+ e->setText (textElementContent);
+ }
+ }
+}
+
+void XmlDocument::readEntity (String& result) throw()
+{
+ // skip over the ampersand
+ ++input;
+
+ if (CharacterFunctions::compareIgnoreCase (input, T("amp;"), 4) == 0)
+ {
+ input += 4;
+ result += T("&");
+ }
+ else if (CharacterFunctions::compareIgnoreCase (input, T("quot;"), 5) == 0)
+ {
+ input += 5;
+ result += T("\"");
+ }
+ else if (CharacterFunctions::compareIgnoreCase (input, T("apos;"), 5) == 0)
+ {
+ input += 5;
+ result += T("\'");
+ }
+ else if (CharacterFunctions::compareIgnoreCase (input, T("lt;"), 3) == 0)
+ {
+ input += 3;
+ result += T("<");
+ }
+ else if (CharacterFunctions::compareIgnoreCase (input, T("gt;"), 3) == 0)
+ {
+ input += 3;
+ result += T(">");
+ }
+ else if (*input == T('#'))
+ {
+ int charCode = 0;
+ ++input;
+
+ if (*input == T('x') || *input == T('X'))
+ {
+ ++input;
+ int numChars = 0;
+
+ while (input[0] != T(';'))
+ {
+ const int hexValue = CharacterFunctions::getHexDigitValue (input[0]);
+
+ if (hexValue < 0 || ++numChars > 8)
+ {
+ setLastError ("illegal escape sequence", true);
+ break;
+ }
+
+ charCode = (charCode << 4) | hexValue;
+ ++input;
+ }
+
+ ++input;
+ }
+ else if (input[0] >= T('0') && input[0] <= T('9'))
+ {
+ int numChars = 0;
+
+ while (input[0] != T(';'))
+ {
+ if (++numChars > 12)
+ {
+ setLastError ("illegal escape sequence", true);
+ break;
+ }
+
+ charCode = charCode * 10 + (input[0] - T('0'));
+ ++input;
+ }
+
+ ++input;
+ }
+ else
+ {
+ setLastError ("illegal escape sequence", true);
+ result += T("&");
+ return;
+ }
+
+ result << (tchar) charCode;
+ }
+ else
+ {
+ const tchar* const entityNameStart = input;
+ const tchar* const closingSemiColon = CharacterFunctions::find (input, T(";"));
+
+ if (closingSemiColon == 0)
+ {
+ outOfData = true;
+ result += T("&");
+ }
+ else
+ {
+ input = closingSemiColon + 1;
+
+ result += expandExternalEntity (String (entityNameStart,
+ (int) (closingSemiColon - entityNameStart)));
+ }
+ }
+}
+
+const String XmlDocument::expandEntity (const String& ent)
+{
+ if (ent.equalsIgnoreCase (T("amp")))
+ {
+ return T("&");
+ }
+ else if (ent.equalsIgnoreCase (T("quot")))
+ {
+ return T("\"");
+ }
+ else if (ent.equalsIgnoreCase (T("apos")))
+ {
+ return T("\'");
+ }
+ else if (ent.equalsIgnoreCase (T("lt")))
+ {
+ return T("<");
+ }
+ else if (ent.equalsIgnoreCase (T("gt")))
+ {
+ return T(">");
+ }
+ else if (ent[0] == T('#'))
+ {
+ if (ent[1] == T('x') || ent[1] == T('X'))
+ {
+ return String::charToString ((tchar) ent.substring (2).getHexValue32());
+ }
+ else if (ent[1] >= T('0') && ent[1] <= T('9'))
+ {
+ return String::charToString ((tchar) ent.substring (1).getIntValue());
+ }
+
+ setLastError ("illegal escape sequence", false);
+ return T("&");
+ }
+ else
+ {
+ return expandExternalEntity (ent);
+ }
+}
+
+const String XmlDocument::expandExternalEntity (const String& entity)
+{
+ if (needToLoadDTD)
+ {
+ if (dtdText.isNotEmpty())
+ {
+ while (dtdText.endsWithChar (T('>')))
+ dtdText = dtdText.dropLastCharacters (1);
+
+ tokenisedDTD.addTokens (dtdText, true);
+
+ if (tokenisedDTD [tokenisedDTD.size() - 2].equalsIgnoreCase (T("system"))
+ && tokenisedDTD [tokenisedDTD.size() - 1].isQuotedString())
+ {
+ const String fn (tokenisedDTD [tokenisedDTD.size() - 1]);
+
+ tokenisedDTD.clear();
+ tokenisedDTD.addTokens (getFileContents (fn), true);
+ }
+ else
+ {
+ tokenisedDTD.clear();
+ const int openBracket = dtdText.indexOfChar (T('['));
+
+ if (openBracket > 0)
+ {
+ const int closeBracket = dtdText.lastIndexOfChar (T(']'));
+
+ if (closeBracket > openBracket)
+ tokenisedDTD.addTokens (dtdText.substring (openBracket + 1,
+ closeBracket), true);
+ }
+ }
+
+ for (int i = tokenisedDTD.size(); --i >= 0;)
+ {
+ if (tokenisedDTD[i].startsWithChar (T('%'))
+ && tokenisedDTD[i].endsWithChar (T(';')))
+ {
+ const String parsed (getParameterEntity (tokenisedDTD[i].substring (1, tokenisedDTD[i].length() - 1)));
+ StringArray newToks;
+ newToks.addTokens (parsed, true);
+
+ tokenisedDTD.remove (i);
+
+ for (int j = newToks.size(); --j >= 0;)
+ tokenisedDTD.insert (i, newToks[j]);
+ }
+ }
+ }
+
+ needToLoadDTD = false;
+ }
+
+ for (int i = 0; i < tokenisedDTD.size(); ++i)
+ {
+ if (tokenisedDTD[i] == entity)
+ {
+ if (tokenisedDTD[i - 1].equalsIgnoreCase (T("')))
+ ent = ent.dropLastCharacters (1);
+
+ ent = ent.trim().unquoted();
+
+ // check for sub-entities..
+ int ampersand = ent.indexOfChar (T('&'));
+
+ while (ampersand >= 0)
+ {
+ const int semiColon = ent.indexOf (i + 1, T(";"));
+
+ if (semiColon < 0)
+ {
+ setLastError ("entity without terminating semi-colon", false);
+ break;
+ }
+
+ const String resolved (expandEntity (ent.substring (i + 1, semiColon)));
+
+ ent = ent.substring (0, ampersand)
+ + resolved
+ + ent.substring (semiColon + 1);
+
+ ampersand = ent.indexOfChar (semiColon + 1, T('&'));
+ }
+
+ return ent;
+ }
+ }
+ }
+
+ setLastError ("unknown entity", true);
+
+ return entity;
+}
+
+const String XmlDocument::getParameterEntity (const String& entity)
+{
+ for (int i = 0; i < tokenisedDTD.size(); ++i)
+ {
+ if (tokenisedDTD[i] == entity)
+ {
+ if (tokenisedDTD [i - 1] == T("%")
+ && tokenisedDTD [i - 2].equalsIgnoreCase (T("')))
+ ent = ent.dropLastCharacters (1);
+
+ if (ent.equalsIgnoreCase (T("system")))
+ {
+ String filename (tokenisedDTD [i + 2]);
+
+ while (filename.endsWithChar (T('>')))
+ filename = filename.dropLastCharacters (1);
+
+ return getFileContents (filename);
+ }
+ else
+ {
+ return ent.trim().unquoted();
+ }
+ }
+ }
+ }
+
+ return entity;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_XmlDocument.cpp *********/
+
+/********* Start of inlined file: juce_XmlElement.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+XmlElement::XmlAttributeNode::XmlAttributeNode (const XmlAttributeNode& other) throw()
+ : name (other.name),
+ value (other.value),
+ next (0)
+{
+}
+
+XmlElement::XmlAttributeNode::XmlAttributeNode (const String& name_,
+ const String& value_) throw()
+ : name (name_),
+ value (value_),
+ next (0)
+{
+}
+
+XmlElement::XmlElement (const String& tagName_) throw()
+ : tagName (tagName_),
+ firstChildElement (0),
+ nextElement (0),
+ attributes (0)
+{
+ // the tag name mustn't be empty, or it'll look like a text element!
+ jassert (tagName_.trim().isNotEmpty())
+}
+
+XmlElement::XmlElement (int /*dummy*/) throw()
+ : firstChildElement (0),
+ nextElement (0),
+ attributes (0)
+{
+}
+
+XmlElement::XmlElement (const tchar* const tagName_,
+ const int nameLen) throw()
+ : tagName (tagName_, nameLen),
+ firstChildElement (0),
+ nextElement (0),
+ attributes (0)
+{
+}
+
+XmlElement::XmlElement (const XmlElement& other) throw()
+ : tagName (other.tagName),
+ firstChildElement (0),
+ nextElement (0),
+ attributes (0)
+{
+ copyChildrenAndAttributesFrom (other);
+}
+
+const XmlElement& XmlElement::operator= (const XmlElement& other) throw()
+{
+ if (this != &other)
+ {
+ removeAllAttributes();
+ deleteAllChildElements();
+
+ tagName = other.tagName;
+
+ copyChildrenAndAttributesFrom (other);
+ }
+
+ return *this;
+}
+
+void XmlElement::copyChildrenAndAttributesFrom (const XmlElement& other) throw()
+{
+ XmlElement* child = other.firstChildElement;
+ XmlElement* lastChild = 0;
+
+ while (child != 0)
+ {
+ XmlElement* const copiedChild = new XmlElement (*child);
+
+ if (lastChild != 0)
+ lastChild->nextElement = copiedChild;
+ else
+ firstChildElement = copiedChild;
+
+ lastChild = copiedChild;
+ child = child->nextElement;
+ }
+
+ const XmlAttributeNode* att = other.attributes;
+ XmlAttributeNode* lastAtt = 0;
+
+ while (att != 0)
+ {
+ XmlAttributeNode* const newAtt = new XmlAttributeNode (*att);
+
+ if (lastAtt != 0)
+ lastAtt->next = newAtt;
+ else
+ attributes = newAtt;
+
+ lastAtt = newAtt;
+ att = att->next;
+ }
+}
+
+XmlElement::~XmlElement() throw()
+{
+ XmlElement* child = firstChildElement;
+
+ while (child != 0)
+ {
+ XmlElement* const nextChild = child->nextElement;
+ delete child;
+ child = nextChild;
+ }
+
+ XmlAttributeNode* att = attributes;
+
+ while (att != 0)
+ {
+ XmlAttributeNode* const nextAtt = att->next;
+ delete att;
+ att = nextAtt;
+ }
+}
+
+static bool isLegalXmlChar (const juce_wchar character)
+{
+ if ((character >= 'a' && character <= 'z')
+ || (character >= 'A' && character <= 'Z')
+ || (character >= '0' && character <= '9'))
+ return true;
+
+ const char* t = " .,;:-()_+=?!'#@[]/\\*%~{}";
+
+ do
+ {
+ if (((juce_wchar) (uint8) *t) == character)
+ return true;
+ }
+ while (*++t != 0);
+
+ return false;
+}
+
+static void escapeIllegalXmlChars (OutputStream& outputStream,
+ const String& text,
+ const bool changeNewLines) throw()
+{
+ const juce_wchar* t = (const juce_wchar*) text;
+
+ for (;;)
+ {
+ const juce_wchar character = *t++;
+
+ if (character == 0)
+ {
+ break;
+ }
+ else if (isLegalXmlChar (character))
+ {
+ outputStream.writeByte ((char) character);
+ }
+ else
+ {
+ switch (character)
+ {
+ case '&':
+ outputStream.write ("&", 5);
+ break;
+
+ case '"':
+ outputStream.write (""", 6);
+ break;
+
+ case '>':
+ outputStream.write (">", 4);
+ break;
+
+ case '<':
+ outputStream.write ("<", 4);
+ break;
+
+ case '\n':
+ if (changeNewLines)
+ outputStream.write ("
", 5);
+ else
+ outputStream.writeByte ((char) character);
+
+ break;
+
+ case '\r':
+ if (changeNewLines)
+ outputStream.write ("
", 5);
+ else
+ outputStream.writeByte ((char) character);
+
+ break;
+
+ default:
+ {
+ String encoded (T("&#"));
+ encoded << String ((int) (unsigned int) character).trim()
+ << T(';');
+
+ outputStream.write ((const char*) encoded, encoded.length());
+ }
+ }
+ }
+ }
+}
+
+static void writeSpaces (OutputStream& out, int numSpaces) throw()
+{
+ if (numSpaces > 0)
+ {
+ const char* const blanks = " ";
+ const int blankSize = (int) sizeof (blanks) - 1;
+
+ while (numSpaces > blankSize)
+ {
+ out.write (blanks, blankSize);
+ numSpaces -= blankSize;
+ }
+
+ out.write (blanks, numSpaces);
+ }
+}
+
+void XmlElement::writeElementAsText (OutputStream& outputStream,
+ const int indentationLevel) const throw()
+{
+ writeSpaces (outputStream, indentationLevel);
+
+ if (! isTextElement())
+ {
+ outputStream.writeByte ('<');
+ const int nameLen = tagName.length();
+ outputStream.write ((const char*) tagName, nameLen);
+
+ const int attIndent = indentationLevel + nameLen + 1;
+ int lineLen = 0;
+
+ const XmlAttributeNode* att = attributes;
+ while (att != 0)
+ {
+ if (lineLen > 60 && indentationLevel >= 0)
+ {
+ outputStream.write ("\r\n", 2);
+ writeSpaces (outputStream, attIndent);
+ lineLen = 0;
+ }
+
+ const int attNameLen = att->name.length();
+ outputStream.writeByte (' ');
+ outputStream.write ((const char*) (att->name), attNameLen);
+ outputStream.write ("=\"", 2);
+ escapeIllegalXmlChars (outputStream, att->value, true);
+ outputStream.writeByte ('"');
+ lineLen += 4 + attNameLen + att->value.length();
+
+ att = att->next;
+ }
+
+ if (firstChildElement != 0)
+ {
+ XmlElement* child = firstChildElement;
+
+ if (child->nextElement == 0 && child->isTextElement())
+ {
+ outputStream.writeByte ('>');
+ escapeIllegalXmlChars (outputStream, child->getText(), false);
+ }
+ else
+ {
+ if (indentationLevel >= 0)
+ outputStream.write (">\r\n", 3);
+ else
+ outputStream.writeByte ('>');
+
+ bool lastWasTextNode = false;
+
+ while (child != 0)
+ {
+ if (child->isTextElement())
+ {
+ if ((! lastWasTextNode) && (indentationLevel >= 0))
+ writeSpaces (outputStream, indentationLevel + 2);
+
+ escapeIllegalXmlChars (outputStream, child->getText(), false);
+ lastWasTextNode = true;
+ }
+ else
+ {
+ if (indentationLevel >= 0)
+ {
+ if (lastWasTextNode)
+ outputStream.write ("\r\n", 2);
+
+ child->writeElementAsText (outputStream, indentationLevel + 2);
+ }
+ else
+ {
+ child->writeElementAsText (outputStream, indentationLevel);
+ }
+
+ lastWasTextNode = false;
+ }
+
+ child = child->nextElement;
+ }
+
+ if (indentationLevel >= 0)
+ {
+ if (lastWasTextNode)
+ outputStream.write ("\r\n", 2);
+
+ writeSpaces (outputStream, indentationLevel);
+ }
+ }
+
+ outputStream.write ("= 0)
+ outputStream.write (">\r\n", 3);
+ else
+ outputStream.writeByte ('>');
+ }
+ else
+ {
+ if (indentationLevel >= 0)
+ outputStream.write ("/>\r\n", 4);
+ else
+ outputStream.write ("/>", 2);
+ }
+ }
+ else
+ {
+ if (indentationLevel >= 0)
+ writeSpaces (outputStream, indentationLevel + 2);
+
+ escapeIllegalXmlChars (outputStream, getText(), false);
+ }
+}
+
+const String XmlElement::createDocument (const String& dtd,
+ const bool allOnOneLine,
+ const bool includeXmlHeader,
+ const tchar* const encoding) const throw()
+{
+ String doc;
+ doc.preallocateStorage (1024);
+
+ if (includeXmlHeader)
+ {
+ doc << " ";
+ else
+ doc += "\"?>\n\n";
+ }
+
+ if (dtd.isNotEmpty())
+ {
+ if (allOnOneLine)
+ doc << dtd << " ";
+ else
+ doc << dtd << "\r\n";
+ }
+
+ MemoryOutputStream mem (2048, 4096);
+ writeElementAsText (mem, allOnOneLine ? -1 : 0);
+
+ return doc + String (mem.getData(),
+ mem.getDataSize());
+}
+
+bool XmlElement::writeToFile (const File& f,
+ const String& dtd,
+ const tchar* const encoding) const throw()
+{
+ if (f.hasWriteAccess())
+ {
+ const File tempFile (f.getNonexistentSibling());
+
+ FileOutputStream* const out = tempFile.createOutputStream();
+
+ if (out != 0)
+ {
+ *out << "\r\n\r\n"
+ << dtd << "\r\n";
+
+ writeElementAsText (*out, 0);
+
+ delete out;
+
+ if (tempFile.moveFileTo (f))
+ return true;
+
+ tempFile.deleteFile();
+ }
+ }
+
+ return false;
+}
+
+bool XmlElement::hasTagName (const tchar* const tagNameWanted) const throw()
+{
+#ifdef JUCE_DEBUG
+ // if debugging, check that the case is actually the same, because
+ // valid xml is case-sensitive, and although this lets it pass, it's
+ // better not to..
+ if (tagName.equalsIgnoreCase (tagNameWanted))
+ {
+ jassert (tagName == tagNameWanted);
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+#else
+ return tagName.equalsIgnoreCase (tagNameWanted);
+#endif
+}
+
+XmlElement* XmlElement::getNextElementWithTagName (const tchar* const requiredTagName) const
+{
+ XmlElement* e = nextElement;
+
+ while (e != 0 && ! e->hasTagName (requiredTagName))
+ e = e->nextElement;
+
+ return e;
+}
+
+int XmlElement::getNumAttributes() const throw()
+{
+ const XmlAttributeNode* att = attributes;
+ int count = 0;
+
+ while (att != 0)
+ {
+ att = att->next;
+ ++count;
+ }
+
+ return count;
+}
+
+const String& XmlElement::getAttributeName (const int index) const throw()
+{
+ const XmlAttributeNode* att = attributes;
+ int count = 0;
+
+ while (att != 0)
+ {
+ if (count == index)
+ return att->name;
+
+ att = att->next;
+ ++count;
+ }
+
+ return String::empty;
+}
+
+const String& XmlElement::getAttributeValue (const int index) const throw()
+{
+ const XmlAttributeNode* att = attributes;
+ int count = 0;
+
+ while (att != 0)
+ {
+ if (count == index)
+ return att->value;
+
+ att = att->next;
+ ++count;
+ }
+
+ return String::empty;
+}
+
+bool XmlElement::hasAttribute (const tchar* const attributeName) const throw()
+{
+ const XmlAttributeNode* att = attributes;
+
+ while (att != 0)
+ {
+ if (att->name.equalsIgnoreCase (attributeName))
+ return true;
+
+ att = att->next;
+ }
+
+ return false;
+}
+
+const String XmlElement::getStringAttribute (const tchar* const attributeName,
+ const tchar* const defaultReturnValue) const throw()
+{
+ const XmlAttributeNode* att = attributes;
+
+ while (att != 0)
+ {
+ if (att->name.equalsIgnoreCase (attributeName))
+ return att->value;
+
+ att = att->next;
+ }
+
+ return defaultReturnValue;
+}
+
+int XmlElement::getIntAttribute (const tchar* const attributeName,
+ const int defaultReturnValue) const throw()
+{
+ const XmlAttributeNode* att = attributes;
+
+ while (att != 0)
+ {
+ if (att->name.equalsIgnoreCase (attributeName))
+ return att->value.getIntValue();
+
+ att = att->next;
+ }
+
+ return defaultReturnValue;
+}
+
+double XmlElement::getDoubleAttribute (const tchar* const attributeName,
+ const double defaultReturnValue) const throw()
+{
+ const XmlAttributeNode* att = attributes;
+
+ while (att != 0)
+ {
+ if (att->name.equalsIgnoreCase (attributeName))
+ return att->value.getDoubleValue();
+
+ att = att->next;
+ }
+
+ return defaultReturnValue;
+}
+
+bool XmlElement::getBoolAttribute (const tchar* const attributeName,
+ const bool defaultReturnValue) const throw()
+{
+ const XmlAttributeNode* att = attributes;
+
+ while (att != 0)
+ {
+ if (att->name.equalsIgnoreCase (attributeName))
+ {
+ tchar firstChar = att->value[0];
+
+ if (CharacterFunctions::isWhitespace (firstChar))
+ firstChar = att->value.trimStart() [0];
+
+ return firstChar == T('1')
+ || firstChar == T('t')
+ || firstChar == T('y')
+ || firstChar == T('T')
+ || firstChar == T('Y');
+ }
+
+ att = att->next;
+ }
+
+ return defaultReturnValue;
+}
+
+bool XmlElement::compareAttribute (const tchar* const attributeName,
+ const tchar* const stringToCompareAgainst,
+ const bool ignoreCase) const throw()
+{
+ const XmlAttributeNode* att = attributes;
+
+ while (att != 0)
+ {
+ if (att->name.equalsIgnoreCase (attributeName))
+ {
+ if (ignoreCase)
+ return att->value.equalsIgnoreCase (stringToCompareAgainst);
+ else
+ return att->value == stringToCompareAgainst;
+ }
+
+ att = att->next;
+ }
+
+ return false;
+}
+
+void XmlElement::setAttribute (const tchar* const attributeName,
+ const String& value) throw()
+{
+#ifdef JUCE_DEBUG
+ // check the identifier being passed in is legal..
+ const tchar* t = attributeName;
+ while (*t != 0)
+ {
+ jassert (CharacterFunctions::isLetterOrDigit (*t)
+ || *t == T('_')
+ || *t == T('-')
+ || *t == T(':'));
+ ++t;
+ }
+#endif
+
+ if (attributes == 0)
+ {
+ attributes = new XmlAttributeNode (attributeName, value);
+ }
+ else
+ {
+ XmlAttributeNode* att = attributes;
+
+ for (;;)
+ {
+ if (att->name.equalsIgnoreCase (attributeName))
+ {
+ att->value = value;
+ break;
+ }
+ else if (att->next == 0)
+ {
+ att->next = new XmlAttributeNode (attributeName, value);
+ break;
+ }
+
+ att = att->next;
+ }
+ }
+}
+
+void XmlElement::setAttribute (const tchar* const attributeName,
+ const tchar* const text) throw()
+{
+ setAttribute (attributeName, String (text));
+}
+
+void XmlElement::setAttribute (const tchar* const attributeName,
+ const int number) throw()
+{
+ setAttribute (attributeName, String (number));
+}
+
+void XmlElement::setAttribute (const tchar* const attributeName,
+ const double number) throw()
+{
+ tchar buffer [40];
+ CharacterFunctions::printf (buffer, numElementsInArray (buffer), T("%.9g"), number);
+
+ setAttribute (attributeName, buffer);
+}
+
+void XmlElement::removeAttribute (const tchar* const attributeName) throw()
+{
+ XmlAttributeNode* att = attributes;
+ XmlAttributeNode* lastAtt = 0;
+
+ while (att != 0)
+ {
+ if (att->name.equalsIgnoreCase (attributeName))
+ {
+ if (lastAtt == 0)
+ attributes = att->next;
+ else
+ lastAtt->next = att->next;
+
+ delete att;
+ break;
+ }
+
+ lastAtt = att;
+ att = att->next;
+ }
+}
+
+void XmlElement::removeAllAttributes() throw()
+{
+ while (attributes != 0)
+ {
+ XmlAttributeNode* const nextAtt = attributes->next;
+ delete attributes;
+ attributes = nextAtt;
+ }
+}
+
+int XmlElement::getNumChildElements() const throw()
+{
+ int count = 0;
+ const XmlElement* child = firstChildElement;
+
+ while (child != 0)
+ {
+ ++count;
+ child = child->nextElement;
+ }
+
+ return count;
+}
+
+XmlElement* XmlElement::getChildElement (const int index) const throw()
+{
+ int count = 0;
+ XmlElement* child = firstChildElement;
+
+ while (child != 0 && count < index)
+ {
+ child = child->nextElement;
+ ++count;
+ }
+
+ return child;
+}
+
+XmlElement* XmlElement::getChildByName (const tchar* const childName) const throw()
+{
+ XmlElement* child = firstChildElement;
+
+ while (child != 0)
+ {
+ if (child->hasTagName (childName))
+ break;
+
+ child = child->nextElement;
+ }
+
+ return child;
+}
+
+void XmlElement::addChildElement (XmlElement* const newNode) throw()
+{
+ if (newNode != 0)
+ {
+ if (firstChildElement == 0)
+ {
+ firstChildElement = newNode;
+ }
+ else
+ {
+ XmlElement* child = firstChildElement;
+
+ while (child->nextElement != 0)
+ child = child->nextElement;
+
+ child->nextElement = newNode;
+
+ // if this is non-zero, then something's probably
+ // gone wrong..
+ jassert (newNode->nextElement == 0);
+ }
+ }
+}
+
+void XmlElement::insertChildElement (XmlElement* const newNode,
+ int indexToInsertAt) throw()
+{
+ if (newNode != 0)
+ {
+ removeChildElement (newNode, false);
+
+ if (indexToInsertAt == 0)
+ {
+ newNode->nextElement = firstChildElement;
+ firstChildElement = newNode;
+ }
+ else
+ {
+ if (firstChildElement == 0)
+ {
+ firstChildElement = newNode;
+ }
+ else
+ {
+ if (indexToInsertAt < 0)
+ indexToInsertAt = INT_MAX;
+
+ XmlElement* child = firstChildElement;
+
+ while (child->nextElement != 0 && --indexToInsertAt > 0)
+ child = child->nextElement;
+
+ newNode->nextElement = child->nextElement;
+ child->nextElement = newNode;
+ }
+ }
+ }
+}
+
+bool XmlElement::replaceChildElement (XmlElement* const currentChildElement,
+ XmlElement* const newNode) throw()
+{
+ if (newNode != 0)
+ {
+ XmlElement* child = firstChildElement;
+ XmlElement* previousNode = 0;
+
+ while (child != 0)
+ {
+ if (child == currentChildElement)
+ {
+ if (child != newNode)
+ {
+ if (previousNode == 0)
+ firstChildElement = newNode;
+ else
+ previousNode->nextElement = newNode;
+
+ newNode->nextElement = child->nextElement;
+
+ delete child;
+ }
+
+ return true;
+ }
+
+ previousNode = child;
+ child = child->nextElement;
+ }
+ }
+
+ return false;
+}
+
+void XmlElement::removeChildElement (XmlElement* const childToRemove,
+ const bool shouldDeleteTheChild) throw()
+{
+ if (childToRemove != 0)
+ {
+ if (firstChildElement == childToRemove)
+ {
+ firstChildElement = childToRemove->nextElement;
+ childToRemove->nextElement = 0;
+ }
+ else
+ {
+ XmlElement* child = firstChildElement;
+ XmlElement* last = 0;
+
+ while (child != 0)
+ {
+ if (child == childToRemove)
+ {
+ if (last == 0)
+ firstChildElement = child->nextElement;
+ else
+ last->nextElement = child->nextElement;
+
+ childToRemove->nextElement = 0;
+ break;
+ }
+
+ last = child;
+ child = child->nextElement;
+ }
+ }
+
+ if (shouldDeleteTheChild)
+ delete childToRemove;
+ }
+}
+
+bool XmlElement::isEquivalentTo (const XmlElement* const other,
+ const bool ignoreOrderOfAttributes) const throw()
+{
+ if (this != other)
+ {
+ if (other == 0 || tagName != other->tagName)
+ {
+ return false;
+ }
+
+ if (ignoreOrderOfAttributes)
+ {
+ int totalAtts = 0;
+ const XmlAttributeNode* att = attributes;
+
+ while (att != 0)
+ {
+ if (! other->compareAttribute (att->name, att->value))
+ return false;
+
+ att = att->next;
+ ++totalAtts;
+ }
+
+ if (totalAtts != other->getNumAttributes())
+ return false;
+ }
+ else
+ {
+ const XmlAttributeNode* thisAtt = attributes;
+ const XmlAttributeNode* otherAtt = other->attributes;
+
+ for (;;)
+ {
+ if (thisAtt == 0 || otherAtt == 0)
+ {
+ if (thisAtt == otherAtt) // both 0, so it's a match
+ break;
+
+ return false;
+ }
+
+ if (thisAtt->name != otherAtt->name
+ || thisAtt->value != otherAtt->value)
+ {
+ return false;
+ }
+
+ thisAtt = thisAtt->next;
+ otherAtt = otherAtt->next;
+ }
+ }
+
+ const XmlElement* thisChild = firstChildElement;
+ const XmlElement* otherChild = other->firstChildElement;
+
+ for (;;)
+ {
+ if (thisChild == 0 || otherChild == 0)
+ {
+ if (thisChild == otherChild) // both 0, so it's a match
+ break;
+
+ return false;
+ }
+
+ if (! thisChild->isEquivalentTo (otherChild, ignoreOrderOfAttributes))
+ return false;
+
+ thisChild = thisChild->nextElement;
+ otherChild = otherChild->nextElement;
+ }
+ }
+
+ return true;
+}
+
+void XmlElement::deleteAllChildElements() throw()
+{
+ while (firstChildElement != 0)
+ {
+ XmlElement* const nextChild = firstChildElement->nextElement;
+ delete firstChildElement;
+ firstChildElement = nextChild;
+ }
+}
+
+void XmlElement::deleteAllChildElementsWithTagName (const tchar* const name) throw()
+{
+ XmlElement* child = firstChildElement;
+
+ while (child != 0)
+ {
+ if (child->hasTagName (name))
+ {
+ XmlElement* const nextChild = child->nextElement;
+ removeChildElement (child, true);
+ child = nextChild;
+ }
+ else
+ {
+ child = child->nextElement;
+ }
+ }
+}
+
+bool XmlElement::containsChildElement (const XmlElement* const possibleChild) const throw()
+{
+ const XmlElement* child = firstChildElement;
+
+ while (child != 0)
+ {
+ if (child == possibleChild)
+ return true;
+
+ child = child->nextElement;
+ }
+
+ return false;
+}
+
+XmlElement* XmlElement::findParentElementOf (const XmlElement* const elementToLookFor) throw()
+{
+ if (this == elementToLookFor || elementToLookFor == 0)
+ return 0;
+
+ XmlElement* child = firstChildElement;
+
+ while (child != 0)
+ {
+ if (elementToLookFor == child)
+ return this;
+
+ XmlElement* const found = child->findParentElementOf (elementToLookFor);
+
+ if (found != 0)
+ return found;
+
+ child = child->nextElement;
+ }
+
+ return 0;
+}
+
+XmlElement** XmlElement::getChildElementsAsArray (const int num) const throw()
+{
+ XmlElement** const elems = new XmlElement* [num];
+
+ XmlElement* e = firstChildElement;
+ int i = 0;
+
+ while (e != 0)
+ {
+ elems [i++] = e;
+ e = e->nextElement;
+ }
+
+ return elems;
+}
+
+void XmlElement::reorderChildElements (XmlElement** const elems, const int num) throw()
+{
+ XmlElement* e = firstChildElement = elems[0];
+
+ for (int i = 1; i < num; ++i)
+ {
+ e->nextElement = elems[i];
+ e = e->nextElement;
+ }
+
+ e->nextElement = 0;
+}
+
+bool XmlElement::isTextElement() const throw()
+{
+ return tagName.isEmpty();
+}
+
+static const tchar* const juce_xmltextContentAttributeName = T("text");
+
+const String XmlElement::getText() const throw()
+{
+ jassert (isTextElement()); // you're trying to get the text from an element that
+ // isn't actually a text element.. If this contains text sub-nodes, you
+ // can use getAllSubText instead to
+
+ return getStringAttribute (juce_xmltextContentAttributeName);
+}
+
+void XmlElement::setText (const String& newText) throw()
+{
+ if (isTextElement())
+ {
+ setAttribute (juce_xmltextContentAttributeName, newText);
+ }
+ else
+ {
+ jassertfalse // you can only change the text in a text element, not a normal one.
+ }
+}
+
+const String XmlElement::getAllSubText() const throw()
+{
+ String result;
+ const XmlElement* child = firstChildElement;
+
+ while (child != 0)
+ {
+ if (child->isTextElement())
+ result += child->getText();
+
+ child = child->nextElement;
+ }
+
+ return result;
+}
+
+const String XmlElement::getChildElementAllSubText (const tchar* const childTagName,
+ const String& defaultReturnValue) const throw()
+{
+ const XmlElement* const child = getChildByName (childTagName);
+
+ if (child != 0)
+ return child->getAllSubText();
+
+ return defaultReturnValue;
+}
+
+XmlElement* XmlElement::createTextElement (const String& text) throw()
+{
+ XmlElement* const e = new XmlElement ((int) 0);
+ e->setAttribute (juce_xmltextContentAttributeName, text);
+ return e;
+}
+
+void XmlElement::addTextElement (const String& text) throw()
+{
+ addChildElement (createTextElement (text));
+}
+
+void XmlElement::deleteAllTextElements() throw()
+{
+ XmlElement* child = firstChildElement;
+
+ while (child != 0)
+ {
+ XmlElement* const next = child->nextElement;
+
+ if (child->isTextElement())
+ removeChildElement (child, true);
+
+ child = next;
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_XmlElement.cpp *********/
+
+/********* Start of inlined file: juce_InterProcessLock.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+// (implemented in the platform-specific code files)
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_InterProcessLock.cpp *********/
+
+/********* Start of inlined file: juce_ReadWriteLock.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ReadWriteLock::ReadWriteLock() throw()
+ : numWaitingWriters (0),
+ numWriters (0),
+ writerThreadId (0)
+{
+}
+
+ReadWriteLock::~ReadWriteLock() throw()
+{
+ jassert (readerThreads.size() == 0);
+ jassert (numWriters == 0);
+}
+
+void ReadWriteLock::enterRead() const throw()
+{
+ const int threadId = Thread::getCurrentThreadId();
+ const ScopedLock sl (accessLock);
+
+ for (;;)
+ {
+ jassert (readerThreads.size() % 2 == 0);
+
+ int i;
+ for (i = 0; i < readerThreads.size(); i += 2)
+ if (readerThreads.getUnchecked(i) == threadId)
+ break;
+
+ if (i < readerThreads.size()
+ || numWriters + numWaitingWriters == 0
+ || (threadId == writerThreadId && numWriters > 0))
+ {
+ if (i < readerThreads.size())
+ {
+ readerThreads.set (i + 1, readerThreads.getUnchecked (i + 1) + 1);
+ }
+ else
+ {
+ readerThreads.add (threadId);
+ readerThreads.add (1);
+ }
+
+ return;
+ }
+
+ const ScopedUnlock ul (accessLock);
+ waitEvent.wait (100);
+ }
+}
+
+void ReadWriteLock::exitRead() const throw()
+{
+ const int threadId = Thread::getCurrentThreadId();
+ const ScopedLock sl (accessLock);
+
+ for (int i = 0; i < readerThreads.size(); i += 2)
+ {
+ if (readerThreads.getUnchecked(i) == threadId)
+ {
+ const int newCount = readerThreads.getUnchecked (i + 1) - 1;
+
+ if (newCount == 0)
+ {
+ readerThreads.removeRange (i, 2);
+ waitEvent.signal();
+ }
+ else
+ {
+ readerThreads.set (i + 1, newCount);
+ }
+
+ return;
+ }
+ }
+
+ jassertfalse // unlocking a lock that wasn't locked..
+}
+
+void ReadWriteLock::enterWrite() const throw()
+{
+ const int threadId = Thread::getCurrentThreadId();
+ const ScopedLock sl (accessLock);
+
+ for (;;)
+ {
+ if (readerThreads.size() + numWriters == 0
+ || threadId == writerThreadId
+ || (readerThreads.size() == 2
+ && readerThreads.getUnchecked(0) == threadId))
+ {
+ writerThreadId = threadId;
+ ++numWriters;
+ break;
+ }
+
+ ++numWaitingWriters;
+ accessLock.exit();
+ waitEvent.wait (100);
+ accessLock.enter();
+ --numWaitingWriters;
+ }
+}
+
+void ReadWriteLock::exitWrite() const throw()
+{
+ const ScopedLock sl (accessLock);
+
+ // check this thread actually had the lock..
+ jassert (numWriters > 0 && writerThreadId == Thread::getCurrentThreadId());
+
+ if (--numWriters == 0)
+ {
+ writerThreadId = 0;
+ waitEvent.signal();
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ReadWriteLock.cpp *********/
+
+/********* Start of inlined file: juce_Thread.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+// these functions are implemented in the platform-specific code.
+void* juce_createThread (void* userData) throw();
+void juce_killThread (void* handle) throw();
+void juce_setThreadPriority (void* handle, int priority) throw();
+void juce_setCurrentThreadName (const String& name) throw();
+#if JUCE_WIN32
+void juce_CloseThreadHandle (void* handle) throw();
+#endif
+
+static VoidArray runningThreads (4);
+static CriticalSection runningThreadsLock;
+
+void Thread::threadEntryPoint (Thread* const thread) throw()
+{
+ runningThreadsLock.enter();
+ runningThreads.add (thread);
+ runningThreadsLock.exit();
+
+ JUCE_TRY
+ {
+ thread->threadId_ = Thread::getCurrentThreadId();
+
+ if (thread->threadName_.isNotEmpty())
+ juce_setCurrentThreadName (thread->threadName_);
+
+ if (thread->startSuspensionEvent_.wait (10000))
+ {
+ if (thread->affinityMask_ != 0)
+ setCurrentThreadAffinityMask (thread->affinityMask_);
+
+ thread->run();
+ }
+ }
+ JUCE_CATCH_ALL_ASSERT
+
+ runningThreadsLock.enter();
+ jassert (runningThreads.contains (thread));
+ runningThreads.removeValue (thread);
+ runningThreadsLock.exit();
+
+#if JUCE_WIN32
+ juce_CloseThreadHandle (thread->threadHandle_);
+#endif
+
+ thread->threadHandle_ = 0;
+ thread->threadId_ = 0;
+}
+
+// used to wrap the incoming call from the platform-specific code
+void JUCE_API juce_threadEntryPoint (void* userData)
+{
+ Thread::threadEntryPoint ((Thread*) userData);
+}
+
+Thread::Thread (const String& threadName)
+ : threadName_ (threadName),
+ threadHandle_ (0),
+ threadPriority_ (5),
+ threadId_ (0),
+ affinityMask_ (0),
+ threadShouldExit_ (false)
+{
+}
+
+Thread::~Thread()
+{
+ stopThread (100);
+}
+
+void Thread::startThread() throw()
+{
+ const ScopedLock sl (startStopLock);
+
+ threadShouldExit_ = false;
+
+ if (threadHandle_ == 0)
+ {
+ threadHandle_ = juce_createThread ((void*) this);
+ juce_setThreadPriority (threadHandle_, threadPriority_);
+ startSuspensionEvent_.signal();
+ }
+}
+
+void Thread::startThread (const int priority) throw()
+{
+ const ScopedLock sl (startStopLock);
+
+ if (threadHandle_ == 0)
+ {
+ threadPriority_ = priority;
+ startThread();
+ }
+ else
+ {
+ setPriority (priority);
+ }
+}
+
+bool Thread::isThreadRunning() const throw()
+{
+ return threadHandle_ != 0;
+}
+
+void Thread::signalThreadShouldExit() throw()
+{
+ threadShouldExit_ = true;
+}
+
+bool Thread::waitForThreadToExit (const int timeOutMilliseconds) const throw()
+{
+ // Doh! So how exactly do you expect this thread to wait for itself to stop??
+ jassert (getThreadId() != getCurrentThreadId());
+
+ const int sleepMsPerIteration = 5;
+ int count = timeOutMilliseconds / sleepMsPerIteration;
+
+ while (isThreadRunning())
+ {
+ if (timeOutMilliseconds > 0 && --count < 0)
+ return false;
+
+ sleep (sleepMsPerIteration);
+ }
+
+ return true;
+}
+
+void Thread::stopThread (const int timeOutMilliseconds) throw()
+{
+ // agh! You can't stop the thread that's calling this method! How on earth
+ // would that work??
+ jassert (getCurrentThreadId() != getThreadId());
+
+ const ScopedLock sl (startStopLock);
+
+ if (isThreadRunning())
+ {
+ signalThreadShouldExit();
+ notify();
+
+ if (timeOutMilliseconds != 0)
+ waitForThreadToExit (timeOutMilliseconds);
+
+ if (isThreadRunning())
+ {
+ // very bad karma if this point is reached, as
+ // there are bound to be locks and events left in
+ // silly states when a thread is killed by force..
+ jassertfalse
+ Logger::writeToLog ("!! killing thread by force !!");
+
+ juce_killThread (threadHandle_);
+ threadHandle_ = 0;
+ threadId_ = 0;
+
+ const ScopedLock sl (runningThreadsLock);
+ runningThreads.removeValue (this);
+ }
+ }
+}
+
+void Thread::setPriority (const int priority) throw()
+{
+ const ScopedLock sl (startStopLock);
+
+ threadPriority_ = priority;
+ juce_setThreadPriority (threadHandle_, priority);
+}
+
+void Thread::setCurrentThreadPriority (const int priority) throw()
+{
+ juce_setThreadPriority (0, priority);
+}
+
+void Thread::setAffinityMask (const uint32 affinityMask) throw()
+{
+ affinityMask_ = affinityMask;
+}
+
+int Thread::getThreadId() const throw()
+{
+ return threadId_;
+}
+
+bool Thread::wait (const int timeOutMilliseconds) const throw()
+{
+ return defaultEvent_.wait (timeOutMilliseconds);
+}
+
+void Thread::notify() const throw()
+{
+ defaultEvent_.signal();
+}
+
+int Thread::getNumRunningThreads() throw()
+{
+ return runningThreads.size();
+}
+
+Thread* Thread::getCurrentThread() throw()
+{
+ const int thisId = getCurrentThreadId();
+ Thread* result = 0;
+
+ runningThreadsLock.enter();
+
+ for (int i = runningThreads.size(); --i >= 0;)
+ {
+ Thread* const t = (Thread*) (runningThreads.getUnchecked(i));
+
+ if (t->threadId_ == thisId)
+ {
+ result = t;
+ break;
+ }
+ }
+
+ runningThreadsLock.exit();
+
+ return result;
+}
+
+void Thread::stopAllThreads (const int timeOutMilliseconds) throw()
+{
+ runningThreadsLock.enter();
+
+ for (int i = runningThreads.size(); --i >= 0;)
+ ((Thread*) runningThreads.getUnchecked(i))->signalThreadShouldExit();
+
+ runningThreadsLock.exit();
+
+ for (;;)
+ {
+ runningThreadsLock.enter();
+ Thread* const t = (Thread*) runningThreads[0];
+ runningThreadsLock.exit();
+
+ if (t == 0)
+ break;
+
+ t->stopThread (timeOutMilliseconds);
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_Thread.cpp *********/
+
+/********* Start of inlined file: juce_ThreadPool.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ThreadPoolJob::ThreadPoolJob (const String& name)
+ : jobName (name),
+ pool (0),
+ shouldStop (false),
+ isActive (false),
+ shouldBeDeleted (false)
+{
+}
+
+ThreadPoolJob::~ThreadPoolJob()
+{
+ // you mustn't delete a job while it's still in a pool! Use ThreadPool::removeJob()
+ // to remove it first!
+ jassert (pool == 0 || ! pool->contains (this));
+}
+
+const String ThreadPoolJob::getJobName() const
+{
+ return jobName;
+}
+
+void ThreadPoolJob::setJobName (const String& newName)
+{
+ jobName = newName;
+}
+
+void ThreadPoolJob::signalJobShouldExit()
+{
+ shouldStop = true;
+}
+
+class ThreadPoolThread : public Thread
+{
+ ThreadPool& pool;
+ bool volatile busy;
+
+ ThreadPoolThread (const ThreadPoolThread&);
+ const ThreadPoolThread& operator= (const ThreadPoolThread&);
+
+public:
+ ThreadPoolThread (ThreadPool& pool_)
+ : Thread (T("Pool")),
+ pool (pool_),
+ busy (false)
+ {
+ }
+
+ ~ThreadPoolThread()
+ {
+ }
+
+ void run()
+ {
+ while (! threadShouldExit())
+ {
+ if (! pool.runNextJob())
+ wait (500);
+ }
+ }
+};
+
+ThreadPool::ThreadPool (const int numThreads_,
+ const bool startThreadsOnlyWhenNeeded,
+ const int stopThreadsWhenNotUsedTimeoutMs)
+ : numThreads (jmax (1, numThreads_)),
+ threadStopTimeout (stopThreadsWhenNotUsedTimeoutMs),
+ priority (5)
+{
+ jassert (numThreads_ > 0); // not much point having one of these with no threads in it.
+
+ threads = (Thread**) juce_calloc (sizeof (Thread*) * numThreads);
+
+ for (int i = numThreads; --i >= 0;)
+ {
+ threads[i] = new ThreadPoolThread (*this);
+
+ if (! startThreadsOnlyWhenNeeded)
+ threads[i]->startThread();
+ }
+}
+
+ThreadPool::~ThreadPool()
+{
+ removeAllJobs (true, 4000);
+
+ int i;
+ for (i = numThreads; --i >= 0;)
+ threads[i]->signalThreadShouldExit();
+
+ for (i = numThreads; --i >= 0;)
+ {
+ threads[i]->stopThread (500);
+ delete threads[i];
+ }
+
+ juce_free (threads);
+}
+
+void ThreadPool::addJob (ThreadPoolJob* const job)
+{
+ jassert (job->pool == 0);
+
+ if (job->pool == 0)
+ {
+ job->pool = this;
+ job->shouldStop = false;
+ job->isActive = false;
+
+ lock.enter();
+ jobs.add (job);
+
+ int numRunning = 0;
+
+ int i;
+ for (i = numThreads; --i >= 0;)
+ if (threads[i]->isThreadRunning() && ! threads[i]->threadShouldExit())
+ ++numRunning;
+
+ if (numRunning < numThreads)
+ {
+ bool startedOne = false;
+ int n = 1000;
+
+ while (--n >= 0 && ! startedOne)
+ {
+ for (int i = numThreads; --i >= 0;)
+ {
+ if (! threads[i]->isThreadRunning())
+ {
+ threads[i]->startThread();
+ startedOne = true;
+ }
+ }
+
+ if (! startedOne)
+ Thread::sleep (5);
+ }
+ }
+
+ lock.exit();
+
+ for (i = numThreads; --i >= 0;)
+ threads[i]->notify();
+ }
+}
+
+int ThreadPool::getNumJobs() const throw()
+{
+ return jobs.size();
+}
+
+ThreadPoolJob* ThreadPool::getJob (const int index) const
+{
+ const ScopedLock sl (lock);
+ return (ThreadPoolJob*) jobs [index];
+}
+
+bool ThreadPool::contains (const ThreadPoolJob* const job) const throw()
+{
+ const ScopedLock sl (lock);
+
+ return jobs.contains ((void*) job);
+}
+
+bool ThreadPool::isJobRunning (const ThreadPoolJob* const job) const
+{
+ const ScopedLock sl (lock);
+
+ return jobs.contains ((void*) job) && job->isActive;
+}
+
+bool ThreadPool::waitForJobToFinish (const ThreadPoolJob* const job,
+ const int timeOutMs) const
+{
+ if (job != 0)
+ {
+ const uint32 start = Time::getMillisecondCounter();
+
+ while (contains (job))
+ {
+ if (timeOutMs >= 0 && Time::getMillisecondCounter() >= start + timeOutMs)
+ return false;
+
+ Thread::sleep (2);
+ }
+ }
+
+ return true;
+}
+
+bool ThreadPool::removeJob (ThreadPoolJob* const job,
+ const bool interruptIfRunning,
+ const int timeOutMs)
+{
+ if (job != 0)
+ {
+ lock.enter();
+
+ if (jobs.contains (job))
+ {
+ if (job->isActive)
+ {
+ if (interruptIfRunning)
+ job->signalJobShouldExit();
+
+ lock.exit();
+
+ return waitForJobToFinish (job, timeOutMs);
+ }
+ else
+ {
+ jobs.removeValue (job);
+ }
+ }
+
+ lock.exit();
+ }
+
+ return true;
+}
+
+bool ThreadPool::removeAllJobs (const bool interruptRunningJobs,
+ const int timeOutMs)
+{
+ lock.enter();
+
+ for (int i = jobs.size(); --i >= 0;)
+ {
+ ThreadPoolJob* const job = (ThreadPoolJob*) jobs.getUnchecked(i);
+
+ if (job->isActive)
+ {
+ if (interruptRunningJobs)
+ job->signalJobShouldExit();
+ }
+ else
+ {
+ jobs.remove (i);
+ }
+ }
+
+ lock.exit();
+
+ const uint32 start = Time::getMillisecondCounter();
+
+ while (jobs.size() > 0)
+ {
+ if (timeOutMs >= 0 && Time::getMillisecondCounter() >= start + timeOutMs)
+ return false;
+
+ Thread::sleep (2);
+ }
+
+ return true;
+}
+
+const StringArray ThreadPool::getNamesOfAllJobs (const bool onlyReturnActiveJobs) const
+{
+ StringArray s;
+ const ScopedLock sl (lock);
+
+ for (int i = 0; i < jobs.size(); ++i)
+ {
+ const ThreadPoolJob* const job = (const ThreadPoolJob*) jobs.getUnchecked(i);
+ if (job->isActive || ! onlyReturnActiveJobs)
+ s.add (job->getJobName());
+ }
+
+ return s;
+}
+
+void ThreadPool::setThreadPriorities (const int newPriority)
+{
+ if (priority != newPriority)
+ {
+ priority = newPriority;
+
+ for (int i = numThreads; --i >= 0;)
+ threads[i]->setPriority (newPriority);
+ }
+}
+
+bool ThreadPool::runNextJob()
+{
+ lock.enter();
+ ThreadPoolJob* job = 0;
+
+ for (int i = 0; i < jobs.size(); ++i)
+ {
+ job = (ThreadPoolJob*) jobs [i];
+
+ if (job != 0 && ! (job->isActive || job->shouldStop))
+ break;
+
+ job = 0;
+ }
+
+ if (job != 0)
+ {
+ job->isActive = true;
+ lock.exit();
+
+ JUCE_TRY
+ {
+ ThreadPoolJob::JobStatus result = job->runJob();
+
+ lastJobEndTime = Time::getApproximateMillisecondCounter();
+
+ const ScopedLock sl (lock);
+
+ if (jobs.contains (job))
+ {
+ job->isActive = false;
+
+ if (result != ThreadPoolJob::jobNeedsRunningAgain || job->shouldStop)
+ {
+ job->pool = 0;
+ job->shouldStop = true;
+ jobs.removeValue (job);
+
+ if (result == ThreadPoolJob::jobHasFinishedAndShouldBeDeleted)
+ delete job;
+ }
+ else
+ {
+ // move the job to the end of the queue if it wants another go
+ jobs.move (jobs.indexOf (job), -1);
+ }
+ }
+ }
+#if JUCE_CATCH_UNHANDLED_EXCEPTIONS
+ catch (...)
+ {
+ lock.enter();
+ jobs.removeValue (job);
+ lock.exit();
+ }
+#endif
+ }
+ else
+ {
+ lock.exit();
+
+ if (threadStopTimeout > 0
+ && Time::getApproximateMillisecondCounter() > lastJobEndTime + threadStopTimeout)
+ {
+ lock.enter();
+
+ if (jobs.size() == 0)
+ {
+ for (int i = numThreads; --i >= 0;)
+ threads[i]->signalThreadShouldExit();
+ }
+
+ lock.exit();
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ThreadPool.cpp *********/
+
+/********* Start of inlined file: juce_TimeSliceThread.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+TimeSliceThread::TimeSliceThread (const String& threadName)
+ : Thread (threadName),
+ index (0),
+ clientBeingCalled (0),
+ clientsChanged (false)
+{
+}
+
+TimeSliceThread::~TimeSliceThread()
+{
+ stopThread (2000);
+}
+
+void TimeSliceThread::addTimeSliceClient (TimeSliceClient* const client)
+{
+ const ScopedLock sl (listLock);
+ clients.addIfNotAlreadyThere (client);
+ clientsChanged = true;
+ notify();
+}
+
+void TimeSliceThread::removeTimeSliceClient (TimeSliceClient* const client)
+{
+ const ScopedLock sl1 (listLock);
+ clientsChanged = true;
+
+ // if there's a chance we're in the middle of calling this client, we need to
+ // also lock the outer lock..
+ if (clientBeingCalled == client)
+ {
+ const ScopedUnlock ul (listLock); // unlock first to get the order right..
+
+ const ScopedLock sl1 (callbackLock);
+ const ScopedLock sl2 (listLock);
+
+ clients.removeValue (client);
+ }
+ else
+ {
+ clients.removeValue (client);
+ }
+}
+
+int TimeSliceThread::getNumClients() const throw()
+{
+ return clients.size();
+}
+
+TimeSliceClient* TimeSliceThread::getClient (const int index) const throw()
+{
+ const ScopedLock sl (listLock);
+ return clients [index];
+}
+
+void TimeSliceThread::run()
+{
+ int numCallsSinceBusy = 0;
+
+ while (! threadShouldExit())
+ {
+ int timeToWait = 500;
+
+ {
+ const ScopedLock sl (callbackLock);
+
+ {
+ const ScopedLock sl (listLock);
+
+ if (clients.size() > 0)
+ {
+ index = (index + 1) % clients.size();
+
+ clientBeingCalled = clients [index];
+ }
+ else
+ {
+ index = 0;
+ clientBeingCalled = 0;
+ }
+
+ if (clientsChanged)
+ {
+ clientsChanged = false;
+ numCallsSinceBusy = 0;
+ }
+ }
+
+ if (clientBeingCalled != 0)
+ {
+ if (clientBeingCalled->useTimeSlice())
+ numCallsSinceBusy = 0;
+ else
+ ++numCallsSinceBusy;
+
+ if (numCallsSinceBusy >= clients.size())
+ timeToWait = 500;
+ else if (index == 0)
+ timeToWait = 1; // throw in an occasional pause, to stop everything locking up
+ else
+ timeToWait = 0;
+ }
+ }
+
+ if (timeToWait > 0)
+ wait (timeToWait);
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_TimeSliceThread.cpp *********/
+
+#if ! JUCE_ONLY_BUILD_CORE_LIBRARY
+
+/********* Start of inlined file: juce_Application.cpp *********/
+
+#if JUCE_MSVC
+ #pragma warning (push)
+ #pragma warning (disable: 4245 4514 4100)
+ #include
+ #pragma warning (pop)
+#endif
+
+BEGIN_JUCE_NAMESPACE
+
+void juce_setCurrentExecutableFileName (const String& filename) throw();
+void juce_setCurrentThreadName (const String& name) throw();
+
+static JUCEApplication* appInstance = 0;
+
+JUCEApplication::JUCEApplication()
+ : appReturnValue (0),
+ stillInitialising (true)
+{
+}
+
+JUCEApplication::~JUCEApplication()
+{
+}
+
+JUCEApplication* JUCEApplication::getInstance() throw()
+{
+ return appInstance;
+}
+
+bool JUCEApplication::isInitialising() const throw()
+{
+ return stillInitialising;
+}
+
+const String JUCEApplication::getApplicationVersion()
+{
+ return String::empty;
+}
+
+bool JUCEApplication::moreThanOneInstanceAllowed()
+{
+ return true;
+}
+
+void JUCEApplication::anotherInstanceStarted (const String&)
+{
+}
+
+void JUCEApplication::systemRequestedQuit()
+{
+ quit();
+}
+
+void JUCEApplication::quit (const bool useMaximumForce)
+{
+ MessageManager::getInstance()->postQuitMessage (useMaximumForce);
+}
+
+void JUCEApplication::setApplicationReturnValue (const int newReturnValue) throw()
+{
+ appReturnValue = newReturnValue;
+}
+
+void JUCEApplication::unhandledException (const std::exception*,
+ const String&,
+ const int)
+{
+ jassertfalse
+}
+
+void JUCEApplication::sendUnhandledException (const std::exception* const e,
+ const char* const sourceFile,
+ const int lineNumber)
+{
+ if (appInstance != 0)
+ appInstance->unhandledException (e, sourceFile, lineNumber);
+}
+
+ApplicationCommandTarget* JUCEApplication::getNextCommandTarget()
+{
+ return 0;
+}
+
+void JUCEApplication::getAllCommands (Array & commands)
+{
+ commands.add (StandardApplicationCommandIDs::quit);
+}
+
+void JUCEApplication::getCommandInfo (const CommandID commandID, ApplicationCommandInfo& result)
+{
+ if (commandID == StandardApplicationCommandIDs::quit)
+ {
+ result.setInfo ("Quit",
+ "Quits the application",
+ "Application",
+ 0);
+
+ result.defaultKeypresses.add (KeyPress (T('q'), ModifierKeys::commandModifier, 0));
+ }
+}
+
+bool JUCEApplication::perform (const InvocationInfo& info)
+{
+ if (info.commandID == StandardApplicationCommandIDs::quit)
+ {
+ systemRequestedQuit();
+ return true;
+ }
+
+ return false;
+}
+
+int JUCEApplication::main (String& commandLine, JUCEApplication* const app)
+{
+ jassert (appInstance == 0);
+ appInstance = app;
+ bool useForce = true;
+
+ initialiseJuce_GUI();
+
+ InterProcessLock* appLock = 0;
+
+ if (! app->moreThanOneInstanceAllowed())
+ {
+ appLock = new InterProcessLock ("juceAppLock_" + app->getApplicationName());
+
+ if (! appLock->enter(0))
+ {
+ MessageManager::broadcastMessage (app->getApplicationName() + "/" + commandLine);
+
+ delete appInstance;
+ appInstance = 0;
+ commandLine = String::empty;
+
+ DBG ("Another instance is running - quitting...");
+ return 0;
+ }
+ }
+
+ JUCE_TRY
+ {
+ juce_setCurrentThreadName ("Juce Message Thread");
+
+ // let the app do its setting-up..
+ app->initialise (commandLine.trim());
+
+ commandLine = String::empty;
+
+ // register for broadcast new app messages
+ MessageManager::getInstance()->registerBroadcastListener (app);
+
+ app->stillInitialising = false;
+
+ // now loop until a quit message is received..
+ useForce = MessageManager::getInstance()->runDispatchLoop();
+
+ MessageManager::getInstance()->deregisterBroadcastListener (app);
+
+ if (appLock != 0)
+ {
+ appLock->exit();
+ delete appLock;
+ }
+ }
+#if JUCE_CATCH_UNHANDLED_EXCEPTIONS
+ catch (const std::exception& e)
+ {
+ app->unhandledException (&e, __FILE__, __LINE__);
+ }
+ catch (...)
+ {
+ app->unhandledException (0, __FILE__, __LINE__);
+ }
+#endif
+
+ return shutdownAppAndClearUp (useForce);
+}
+
+int JUCEApplication::shutdownAppAndClearUp (const bool useMaximumForce)
+{
+ jassert (appInstance != 0);
+ JUCEApplication* const app = appInstance;
+ int returnValue = 0;
+
+ static bool reentrancyCheck = false;
+
+ if (! reentrancyCheck)
+ {
+ reentrancyCheck = true;
+
+ JUCE_TRY
+ {
+ // give the app a chance to clean up..
+ app->shutdown();
+ }
+#if JUCE_CATCH_UNHANDLED_EXCEPTIONS
+ catch (const std::exception& e)
+ {
+ app->unhandledException (&e, __FILE__, __LINE__);
+ }
+ catch (...)
+ {
+ app->unhandledException (0, __FILE__, __LINE__);
+ }
+#endif
+
+ JUCE_TRY
+ {
+ shutdownJuce_GUI();
+
+ returnValue = app->getApplicationReturnValue();
+
+ appInstance = 0;
+ delete app;
+ }
+ JUCE_CATCH_ALL_ASSERT
+
+ if (useMaximumForce)
+ {
+ Process::terminate();
+ }
+
+ reentrancyCheck = false;
+ }
+
+ return returnValue;
+}
+
+int JUCEApplication::main (int argc, char* argv[],
+ JUCEApplication* const newApp)
+{
+ juce_setCurrentExecutableFileName (argv[0]);
+
+ String cmd;
+ for (int i = 1; i < argc; ++i)
+ cmd << argv[i] << T(' ');
+
+ return JUCEApplication::main (cmd, newApp);
+}
+
+void JUCEApplication::actionListenerCallback (const String& message)
+{
+ if (message.startsWith (getApplicationName() + "/"))
+ anotherInstanceStarted (message.substring (getApplicationName().length() + 1));
+}
+
+static bool juceInitialisedGUI = false;
+
+void JUCE_PUBLIC_FUNCTION initialiseJuce_GUI()
+{
+ if (! juceInitialisedGUI)
+ {
+ juceInitialisedGUI = true;
+
+ initialiseJuce_NonGUI();
+ MessageManager::getInstance();
+ Font::initialiseDefaultFontNames();
+ LookAndFeel::setDefaultLookAndFeel (0);
+
+#if JUCE_WIN32 && JUCE_DEBUG
+ // This section is just for catching people who mess up their project settings and
+ // turn RTTI off..
+ try
+ {
+ TextButton tb (String::empty);
+ Component* c = &tb;
+
+ // Got an exception here? Then TURN ON RTTI in your compiler settings!!
+ c = dynamic_cast (c);
+ }
+ catch (...)
+ {
+ // Ended up here? If so, TURN ON RTTI in your compiler settings!! And if you
+ // got as far as this catch statement, then why haven't you got exception catching
+ // turned on in the debugger???
+ jassertfalse
+ }
+#endif
+ }
+}
+
+void JUCE_PUBLIC_FUNCTION shutdownJuce_GUI()
+{
+ if (juceInitialisedGUI)
+ {
+ DeletedAtShutdown::deleteAll();
+
+ LookAndFeel::clearDefaultLookAndFeel();
+ shutdownJuce_NonGUI();
+
+ juceInitialisedGUI = false;
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_Application.cpp *********/
+
+/********* Start of inlined file: juce_ApplicationCommandInfo.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ApplicationCommandInfo::ApplicationCommandInfo (const CommandID commandID_) throw()
+ : commandID (commandID_),
+ flags (0)
+{
+}
+
+void ApplicationCommandInfo::setInfo (const String& shortName_,
+ const String& description_,
+ const String& categoryName_,
+ const int flags_) throw()
+{
+ shortName = shortName_;
+ description = description_;
+ categoryName = categoryName_;
+ flags = flags_;
+}
+
+void ApplicationCommandInfo::setActive (const bool b) throw()
+{
+ if (b)
+ flags &= ~isDisabled;
+ else
+ flags |= isDisabled;
+}
+
+void ApplicationCommandInfo::setTicked (const bool b) throw()
+{
+ if (b)
+ flags |= isTicked;
+ else
+ flags &= ~isTicked;
+}
+
+void ApplicationCommandInfo::addDefaultKeypress (const int keyCode, const ModifierKeys& modifiers) throw()
+{
+ defaultKeypresses.add (KeyPress (keyCode, modifiers, 0));
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ApplicationCommandInfo.cpp *********/
+
+/********* Start of inlined file: juce_ApplicationCommandManager.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ApplicationCommandManager::ApplicationCommandManager()
+ : listeners (8),
+ firstTarget (0)
+{
+ keyMappings = new KeyPressMappingSet (this);
+
+ Desktop::getInstance().addFocusChangeListener (this);
+}
+
+ApplicationCommandManager::~ApplicationCommandManager()
+{
+ Desktop::getInstance().removeFocusChangeListener (this);
+ deleteAndZero (keyMappings);
+}
+
+void ApplicationCommandManager::clearCommands()
+{
+ commands.clear();
+ keyMappings->clearAllKeyPresses();
+ triggerAsyncUpdate();
+}
+
+void ApplicationCommandManager::registerCommand (const ApplicationCommandInfo& newCommand)
+{
+ // zero isn't a valid command ID!
+ jassert (newCommand.commandID != 0);
+
+ // the name isn't optional!
+ jassert (newCommand.shortName.isNotEmpty());
+
+ if (getCommandForID (newCommand.commandID) == 0)
+ {
+ ApplicationCommandInfo* const newInfo = new ApplicationCommandInfo (newCommand);
+ newInfo->flags &= ~ApplicationCommandInfo::isTicked;
+ commands.add (newInfo);
+
+ keyMappings->resetToDefaultMapping (newCommand.commandID);
+
+ triggerAsyncUpdate();
+ }
+ else
+ {
+ // trying to re-register the same command with different parameters?
+ jassert (newCommand.shortName == getCommandForID (newCommand.commandID)->shortName
+ && (newCommand.description == getCommandForID (newCommand.commandID)->description || newCommand.description.isEmpty())
+ && newCommand.categoryName == getCommandForID (newCommand.commandID)->categoryName
+ && newCommand.defaultKeypresses == getCommandForID (newCommand.commandID)->defaultKeypresses
+ && (newCommand.flags & (ApplicationCommandInfo::wantsKeyUpDownCallbacks | ApplicationCommandInfo::hiddenFromKeyEditor | ApplicationCommandInfo::readOnlyInKeyEditor))
+ == (getCommandForID (newCommand.commandID)->flags & (ApplicationCommandInfo::wantsKeyUpDownCallbacks | ApplicationCommandInfo::hiddenFromKeyEditor | ApplicationCommandInfo::readOnlyInKeyEditor)));
+ }
+}
+
+void ApplicationCommandManager::registerAllCommandsForTarget (ApplicationCommandTarget* target)
+{
+ if (target != 0)
+ {
+ Array 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 ApplicationCommandManager::removeCommand (const CommandID commandID)
+{
+ for (int i = commands.size(); --i >= 0;)
+ {
+ if (commands.getUnchecked (i)->commandID == commandID)
+ {
+ commands.remove (i);
+ triggerAsyncUpdate();
+
+ const Array keys (keyMappings->getKeyPressesAssignedToCommand (commandID));
+
+ for (int j = keys.size(); --j >= 0;)
+ keyMappings->removeKeyPress (keys.getReference (j));
+ }
+ }
+}
+
+void ApplicationCommandManager::commandStatusChanged()
+{
+ triggerAsyncUpdate();
+}
+
+const ApplicationCommandInfo* ApplicationCommandManager::getCommandForID (const CommandID commandID) const throw()
+{
+ for (int i = commands.size(); --i >= 0;)
+ if (commands.getUnchecked(i)->commandID == commandID)
+ return commands.getUnchecked(i);
+
+ return 0;
+}
+
+const String ApplicationCommandManager::getNameOfCommand (const CommandID commandID) const throw()
+{
+ const ApplicationCommandInfo* const ci = getCommandForID (commandID);
+
+ return (ci != 0) ? ci->shortName : String::empty;
+}
+
+const String ApplicationCommandManager::getDescriptionOfCommand (const CommandID commandID) const throw()
+{
+ const ApplicationCommandInfo* const ci = getCommandForID (commandID);
+
+ return (ci != 0) ? (ci->description.isNotEmpty() ? ci->description : ci->shortName)
+ : String::empty;
+}
+
+const StringArray ApplicationCommandManager::getCommandCategories() const throw()
+{
+ StringArray s;
+
+ for (int i = 0; i < commands.size(); ++i)
+ s.addIfNotAlreadyThere (commands.getUnchecked(i)->categoryName, false);
+
+ return s;
+}
+
+const Array ApplicationCommandManager::getCommandsInCategory (const String& categoryName) const throw()
+{
+ Array results (4);
+
+ for (int i = 0; i < commands.size(); ++i)
+ if (commands.getUnchecked(i)->categoryName == categoryName)
+ results.add (commands.getUnchecked(i)->commandID);
+
+ return results;
+}
+
+bool ApplicationCommandManager::invokeDirectly (const CommandID commandID, const bool asynchronously)
+{
+ ApplicationCommandTarget::InvocationInfo info (commandID);
+ info.invocationMethod = ApplicationCommandTarget::InvocationInfo::direct;
+
+ return invoke (info, asynchronously);
+}
+
+bool ApplicationCommandManager::invoke (const ApplicationCommandTarget::InvocationInfo& info_, const bool asynchronously)
+{
+ // This call isn't thread-safe for use from a non-UI thread without locking the message
+ // manager first..
+ jassert (MessageManager::getInstance()->currentThreadHasLockedMessageManager());
+
+ ApplicationCommandTarget* const target = getFirstCommandTarget (info_.commandID);
+
+ if (target == 0)
+ return false;
+
+ ApplicationCommandInfo commandInfo (0);
+ target->getCommandInfo (info_.commandID, commandInfo);
+
+ ApplicationCommandTarget::InvocationInfo info (info_);
+ info.commandFlags = commandInfo.flags;
+
+ sendListenerInvokeCallback (info);
+
+ const bool ok = target->invoke (info, asynchronously);
+
+ commandStatusChanged();
+
+ return ok;
+}
+
+ApplicationCommandTarget* ApplicationCommandManager::getFirstCommandTarget (const CommandID)
+{
+ return firstTarget != 0 ? firstTarget
+ : findDefaultComponentTarget();
+}
+
+void ApplicationCommandManager::setFirstCommandTarget (ApplicationCommandTarget* const newTarget) throw()
+{
+ firstTarget = newTarget;
+}
+
+ApplicationCommandTarget* ApplicationCommandManager::getTargetForCommand (const CommandID commandID,
+ ApplicationCommandInfo& upToDateInfo)
+{
+ ApplicationCommandTarget* target = getFirstCommandTarget (commandID);
+
+ if (target == 0)
+ target = JUCEApplication::getInstance();
+
+ if (target != 0)
+ target = target->getTargetForCommand (commandID);
+
+ if (target != 0)
+ target->getCommandInfo (commandID, upToDateInfo);
+
+ return target;
+}
+
+ApplicationCommandTarget* ApplicationCommandManager::findTargetForComponent (Component* c)
+{
+ ApplicationCommandTarget* target = dynamic_cast (c);
+
+ if (target == 0 && c != 0)
+ // (unable to use the syntax findParentComponentOfClass () because of a VC6 compiler bug)
+ target = c->findParentComponentOfClass ((ApplicationCommandTarget*) 0);
+
+ return target;
+}
+
+ApplicationCommandTarget* ApplicationCommandManager::findDefaultComponentTarget()
+{
+ Component* c = Component::getCurrentlyFocusedComponent();
+
+ if (c == 0)
+ {
+ TopLevelWindow* const activeWindow = TopLevelWindow::getActiveTopLevelWindow();
+
+ if (activeWindow != 0)
+ {
+ c = activeWindow->getPeer()->getLastFocusedSubcomponent();
+
+ if (c == 0)
+ c = activeWindow;
+ }
+ }
+
+ if (c == 0)
+ {
+ // getting a bit desperate now - try all desktop comps..
+ for (int i = Desktop::getInstance().getNumComponents(); --i >= 0;)
+ {
+ ApplicationCommandTarget* const target
+ = findTargetForComponent (Desktop::getInstance().getComponent (i)
+ ->getPeer()->getLastFocusedSubcomponent());
+
+ if (target != 0)
+ return target;
+ }
+ }
+
+ if (c != 0)
+ {
+ ResizableWindow* const resizableWindow = dynamic_cast (c);
+
+ // if we're focused on a ResizableWindow, chances are that it's the content
+ // component that really should get the event. And if not, the event will
+ // still be passed up to the top level window anyway, so let's send it to the
+ // content comp.
+ if (resizableWindow != 0 && resizableWindow->getContentComponent() != 0)
+ c = resizableWindow->getContentComponent();
+
+ ApplicationCommandTarget* const target = findTargetForComponent (c);
+
+ if (target != 0)
+ return target;
+ }
+
+ return JUCEApplication::getInstance();
+}
+
+void ApplicationCommandManager::addListener (ApplicationCommandManagerListener* const listener) throw()
+{
+ jassert (listener != 0);
+ if (listener != 0)
+ listeners.add (listener);
+}
+
+void ApplicationCommandManager::removeListener (ApplicationCommandManagerListener* const listener) throw()
+{
+ listeners.removeValue (listener);
+}
+
+void ApplicationCommandManager::sendListenerInvokeCallback (const ApplicationCommandTarget::InvocationInfo& info) const
+{
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ ((ApplicationCommandManagerListener*) listeners.getUnchecked (i))->applicationCommandInvoked (info);
+ i = jmin (i, listeners.size());
+ }
+}
+
+void ApplicationCommandManager::handleAsyncUpdate()
+{
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ ((ApplicationCommandManagerListener*) listeners.getUnchecked (i))->applicationCommandListChanged();
+ i = jmin (i, listeners.size());
+ }
+}
+
+void ApplicationCommandManager::globalFocusChanged (Component*)
+{
+ commandStatusChanged();
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ApplicationCommandManager.cpp *********/
+
+/********* Start of inlined file: juce_ApplicationCommandTarget.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ApplicationCommandTarget::ApplicationCommandTarget()
+ : messageInvoker (0)
+{
+}
+
+ApplicationCommandTarget::~ApplicationCommandTarget()
+{
+ deleteAndZero (messageInvoker);
+}
+
+bool ApplicationCommandTarget::tryToInvoke (const InvocationInfo& info, const bool async)
+{
+ if (isCommandActive (info.commandID))
+ {
+ if (async)
+ {
+ if (messageInvoker == 0)
+ messageInvoker = new CommandTargetMessageInvoker (this);
+
+ messageInvoker->postMessage (new Message (0, 0, 0, new ApplicationCommandTarget::InvocationInfo (info)));
+ return true;
+ }
+ else
+ {
+ const bool success = perform (info);
+
+ jassert (success); // hmm - your target should have been able to perform this command. If it can't
+ // do it at the moment for some reason, it should clear the 'isActive' flag when it
+ // returns the command's info.
+ return success;
+ }
+ }
+
+ return false;
+}
+
+ApplicationCommandTarget* ApplicationCommandTarget::findFirstTargetParentComponent()
+{
+ Component* c = dynamic_cast (this);
+
+ if (c != 0)
+ // (unable to use the syntax findParentComponentOfClass () because of a VC6 compiler bug)
+ return c->findParentComponentOfClass ((ApplicationCommandTarget*) 0);
+
+ return 0;
+}
+
+ApplicationCommandTarget* ApplicationCommandTarget::getTargetForCommand (const CommandID commandID)
+{
+ ApplicationCommandTarget* target = this;
+ int depth = 0;
+
+ while (target != 0)
+ {
+ Array commandIDs;
+ target->getAllCommands (commandIDs);
+
+ if (commandIDs.contains (commandID))
+ return target;
+
+ target = target->getNextCommandTarget();
+
+ ++depth;
+ jassert (depth < 100); // could be a recursive command chain??
+ jassert (target != this); // definitely a recursive command chain!
+
+ if (depth > 100 || target == this)
+ break;
+ }
+
+ if (target == 0)
+ {
+ target = JUCEApplication::getInstance();
+
+ if (target != 0)
+ {
+ Array commandIDs;
+ target->getAllCommands (commandIDs);
+
+ if (commandIDs.contains (commandID))
+ return target;
+ }
+ }
+
+ return 0;
+}
+
+bool ApplicationCommandTarget::isCommandActive (const CommandID commandID)
+{
+ ApplicationCommandInfo info (commandID);
+ info.flags = ApplicationCommandInfo::isDisabled;
+
+ getCommandInfo (commandID, info);
+
+ return (info.flags & ApplicationCommandInfo::isDisabled) == 0;
+}
+
+bool ApplicationCommandTarget::invoke (const InvocationInfo& info, const bool async)
+{
+ ApplicationCommandTarget* target = this;
+ int depth = 0;
+
+ while (target != 0)
+ {
+ if (target->tryToInvoke (info, async))
+ return true;
+
+ target = target->getNextCommandTarget();
+
+ ++depth;
+ jassert (depth < 100); // could be a recursive command chain??
+ jassert (target != this); // definitely a recursive command chain!
+
+ if (depth > 100 || target == this)
+ break;
+ }
+
+ if (target == 0)
+ {
+ target = JUCEApplication::getInstance();
+
+ if (target != 0)
+ return target->tryToInvoke (info, async);
+ }
+
+ return false;
+}
+
+bool ApplicationCommandTarget::invokeDirectly (const CommandID commandID, const bool asynchronously)
+{
+ ApplicationCommandTarget::InvocationInfo info (commandID);
+ info.invocationMethod = ApplicationCommandTarget::InvocationInfo::direct;
+
+ return invoke (info, asynchronously);
+}
+
+ApplicationCommandTarget::InvocationInfo::InvocationInfo (const CommandID commandID_) throw()
+ : commandID (commandID_),
+ commandFlags (0),
+ invocationMethod (direct),
+ originatingComponent (0),
+ isKeyDown (false),
+ millisecsSinceKeyPressed (0)
+{
+}
+
+ApplicationCommandTarget::CommandTargetMessageInvoker::CommandTargetMessageInvoker (ApplicationCommandTarget* const owner_)
+ : owner (owner_)
+{
+}
+
+ApplicationCommandTarget::CommandTargetMessageInvoker::~CommandTargetMessageInvoker()
+{
+}
+
+void ApplicationCommandTarget::CommandTargetMessageInvoker::handleMessage (const Message& message)
+{
+ InvocationInfo* const info = (InvocationInfo*) message.pointerParameter;
+ owner->tryToInvoke (*info, false);
+ delete info;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ApplicationCommandTarget.cpp *********/
+
+/********* Start of inlined file: juce_ApplicationProperties.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+juce_ImplementSingleton (ApplicationProperties)
+
+ApplicationProperties::ApplicationProperties() throw()
+ : userProps (0),
+ commonProps (0),
+ msBeforeSaving (3000),
+ options (PropertiesFile::storeAsBinary),
+ commonSettingsAreReadOnly (0)
+{
+}
+
+ApplicationProperties::~ApplicationProperties()
+{
+ closeFiles();
+ clearSingletonInstance();
+}
+
+void ApplicationProperties::setStorageParameters (const String& applicationName,
+ const String& fileNameSuffix,
+ const String& folderName_,
+ const int millisecondsBeforeSaving,
+ const int propertiesFileOptions) throw()
+{
+ appName = applicationName;
+ fileSuffix = fileNameSuffix;
+ folderName = folderName_;
+ msBeforeSaving = millisecondsBeforeSaving;
+ options = propertiesFileOptions;
+}
+
+bool ApplicationProperties::testWriteAccess (const bool testUserSettings,
+ const bool testCommonSettings,
+ const bool showWarningDialogOnFailure)
+{
+ const bool userOk = (! testUserSettings) || getUserSettings()->save();
+ const bool commonOk = (! testCommonSettings) || getCommonSettings (false)->save();
+
+ if (! (userOk && commonOk))
+ {
+ if (showWarningDialogOnFailure)
+ {
+ String filenames;
+
+ if (userProps != 0 && ! userOk)
+ filenames << '\n' << userProps->getFile().getFullPathName();
+
+ if (commonProps != 0 && ! commonOk)
+ filenames << '\n' << commonProps->getFile().getFullPathName();
+
+ AlertWindow::showMessageBox (AlertWindow::WarningIcon,
+ appName + TRANS(" - Unable to save settings"),
+ TRANS("An error occurred when trying to save the application's settings file...\n\nIn order to save and restore its settings, ")
+ + appName + TRANS(" needs to be able to write to the following files:\n")
+ + filenames
+ + TRANS("\n\nMake sure that these files aren't read-only, and that the disk isn't full."));
+ }
+
+ return false;
+ }
+
+ return true;
+}
+
+void ApplicationProperties::openFiles() throw()
+{
+ // You need to call setStorageParameters() before trying to get hold of the
+ // properties!
+ jassert (appName.isNotEmpty());
+
+ if (appName.isNotEmpty())
+ {
+ if (userProps == 0)
+ userProps = PropertiesFile::createDefaultAppPropertiesFile (appName, fileSuffix, folderName,
+ false, msBeforeSaving, options);
+
+ if (commonProps == 0)
+ commonProps = PropertiesFile::createDefaultAppPropertiesFile (appName, fileSuffix, folderName,
+ true, msBeforeSaving, options);
+
+ userProps->setFallbackPropertySet (commonProps);
+ }
+}
+
+PropertiesFile* ApplicationProperties::getUserSettings() throw()
+{
+ if (userProps == 0)
+ openFiles();
+
+ return userProps;
+}
+
+PropertiesFile* ApplicationProperties::getCommonSettings (const bool returnUserPropsIfReadOnly) throw()
+{
+ if (commonProps == 0)
+ openFiles();
+
+ if (returnUserPropsIfReadOnly)
+ {
+ if (commonSettingsAreReadOnly == 0)
+ commonSettingsAreReadOnly = commonProps->save() ? -1 : 1;
+
+ if (commonSettingsAreReadOnly > 0)
+ return userProps;
+ }
+
+ return commonProps;
+}
+
+bool ApplicationProperties::saveIfNeeded()
+{
+ return (userProps == 0 || userProps->saveIfNeeded())
+ && (commonProps == 0 || commonProps->saveIfNeeded());
+}
+
+void ApplicationProperties::closeFiles()
+{
+ deleteAndZero (userProps);
+ deleteAndZero (commonProps);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ApplicationProperties.cpp *********/
+
+/********* Start of inlined file: juce_DeletedAtShutdown.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+static VoidArray objectsToDelete (16);
+static CriticalSection lock;
+
+DeletedAtShutdown::DeletedAtShutdown() throw()
+{
+ const ScopedLock sl (lock);
+ objectsToDelete.add (this);
+}
+
+DeletedAtShutdown::~DeletedAtShutdown()
+{
+ const ScopedLock sl (lock);
+ objectsToDelete.removeValue (this);
+}
+
+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.
+ lock.enter();
+ const VoidArray localCopy (objectsToDelete);
+ lock.exit();
+
+ for (int i = localCopy.size(); --i >= 0;)
+ {
+ JUCE_TRY
+ {
+ DeletedAtShutdown* const deletee = (DeletedAtShutdown*) localCopy.getUnchecked(i);
+
+ // double-check that it's not already been deleted during another object's destructor.
+ lock.enter();
+ const bool okToDelete = objectsToDelete.contains (deletee);
+ lock.exit();
+
+ if (okToDelete)
+ delete deletee;
+ }
+ JUCE_CATCH_EXCEPTION
+ }
+
+ // if no objects got re-created during shutdown, this should have been emptied by their
+ // destructors
+ jassert (objectsToDelete.size() == 0);
+
+ objectsToDelete.clear(); // just to make sure the array doesn't have any memory still allocated
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_DeletedAtShutdown.cpp *********/
+
+/********* Start of inlined file: juce_PropertiesFile.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+static const int propFileMagicNumber = ((int) littleEndianInt ("PROP"));
+static const int propFileMagicNumberCompressed = ((int) littleEndianInt ("CPRP"));
+
+static const tchar* const propertyFileXmlTag = T("PROPERTIES");
+static const tchar* const propertyTagName = T("VALUE");
+
+PropertiesFile::PropertiesFile (const File& f,
+ const int millisecondsBeforeSaving,
+ const int options_) throw()
+ : PropertySet (ignoreCaseOfKeyNames),
+ file (f),
+ timerInterval (millisecondsBeforeSaving),
+ options (options_),
+ needsWriting (false)
+{
+ // You need to correctly specify just one storage format for the file
+ jassert ((options_ & (storeAsBinary | storeAsCompressedBinary | storeAsXML)) == storeAsBinary
+ || (options_ & (storeAsBinary | storeAsCompressedBinary | storeAsXML)) == storeAsCompressedBinary
+ || (options_ & (storeAsBinary | storeAsCompressedBinary | storeAsXML)) == storeAsXML);
+
+ InputStream* fileStream = f.createInputStream();
+
+ if (fileStream != 0)
+ {
+ int magicNumber = fileStream->readInt();
+
+ if (magicNumber == propFileMagicNumberCompressed)
+ {
+ fileStream = new SubregionStream (fileStream, 4, -1, true);
+ fileStream = new GZIPDecompressorInputStream (fileStream, true);
+
+ magicNumber = propFileMagicNumber;
+ }
+
+ if (magicNumber == propFileMagicNumber)
+ {
+ BufferedInputStream in (fileStream, 2048, true);
+
+ int numValues = in.readInt();
+
+ while (--numValues >= 0 && ! in.isExhausted())
+ {
+ const String key (in.readString());
+ const String value (in.readString());
+
+ jassert (key.isNotEmpty());
+ if (key.isNotEmpty())
+ getAllProperties().set (key, value);
+ }
+ }
+ else
+ {
+ // Not a binary props file - let's see if it's XML..
+ delete fileStream;
+
+ XmlDocument parser (f);
+ XmlElement* doc = parser.getDocumentElement (true);
+
+ if (doc != 0 && doc->hasTagName (propertyFileXmlTag))
+ {
+ delete doc;
+ doc = parser.getDocumentElement();
+
+ if (doc != 0)
+ {
+ forEachXmlChildElementWithTagName (*doc, e, propertyTagName)
+ {
+ const String name (e->getStringAttribute (T("name")));
+
+ if (name.isNotEmpty())
+ getAllProperties().set (name, e->getStringAttribute (T("val")));
+ }
+ }
+ else
+ {
+ // must be a pretty broken XML file we're trying to parse here!
+ jassertfalse
+ }
+
+ delete doc;
+ }
+ }
+ }
+}
+
+PropertiesFile::~PropertiesFile()
+{
+ saveIfNeeded();
+}
+
+bool PropertiesFile::saveIfNeeded()
+{
+ const ScopedLock sl (getLock());
+
+ return (! needsWriting) || save();
+}
+
+bool PropertiesFile::needsToBeSaved() const throw()
+{
+ const ScopedLock sl (getLock());
+
+ return needsWriting;
+}
+
+bool PropertiesFile::save()
+{
+ const ScopedLock sl (getLock());
+
+ stopTimer();
+
+ if (file == File::nonexistent
+ || file.isDirectory()
+ || ! file.getParentDirectory().createDirectory())
+ return false;
+
+ if ((options & storeAsXML) != 0)
+ {
+ XmlElement* const doc = new XmlElement (propertyFileXmlTag);
+
+ for (int i = 0; i < getAllProperties().size(); ++i)
+ {
+ XmlElement* const e = new XmlElement (propertyTagName);
+ e->setAttribute (T("name"), getAllProperties().getAllKeys() [i]);
+ e->setAttribute (T("val"), getAllProperties().getAllValues() [i]);
+ doc->addChildElement (e);
+ }
+
+ const bool ok = doc->writeToFile (file, String::empty);
+
+ delete doc;
+
+ return ok;
+ }
+ else
+ {
+ const File tempFile (file.getNonexistentSibling (false));
+ OutputStream* out = tempFile.createOutputStream();
+
+ if (out != 0)
+ {
+ if ((options & storeAsCompressedBinary) != 0)
+ {
+ out->writeInt (propFileMagicNumberCompressed);
+ out->flush();
+
+ out = new GZIPCompressorOutputStream (out, 9, true);
+ }
+ else
+ {
+ // have you set up the storage option flags correctly?
+ jassert ((options & storeAsBinary) != 0);
+
+ out->writeInt (propFileMagicNumber);
+ }
+
+ const int numProperties = getAllProperties().size();
+
+ out->writeInt (numProperties);
+
+ for (int i = 0; i < numProperties; ++i)
+ {
+ out->writeString (getAllProperties().getAllKeys() [i]);
+ out->writeString (getAllProperties().getAllValues() [i]);
+ }
+
+ out->flush();
+ delete out;
+
+ if (tempFile.moveFileTo (file))
+ {
+ needsWriting = false;
+ return true;
+ }
+
+ tempFile.deleteFile();
+ }
+ }
+
+ return false;
+}
+
+void PropertiesFile::timerCallback()
+{
+ saveIfNeeded();
+}
+
+void PropertiesFile::propertyChanged()
+{
+ sendChangeMessage (this);
+
+ needsWriting = true;
+
+ if (timerInterval > 0)
+ startTimer (timerInterval);
+ else if (timerInterval == 0)
+ saveIfNeeded();
+}
+
+const File PropertiesFile::getFile() const throw()
+{
+ return file;
+}
+
+const File PropertiesFile::getDefaultAppSettingsFile (const String& applicationName,
+ const String& fileNameSuffix,
+ const String& folderName,
+ const bool commonToAllUsers)
+{
+ // mustn't have illegal characters in this name..
+ jassert (applicationName == File::createLegalFileName (applicationName));
+
+#if JUCE_MAC
+ File dir (commonToAllUsers ? "/Library/Preferences"
+ : "~/Library/Preferences");
+
+ if (folderName.isNotEmpty())
+ dir = dir.getChildFile (folderName);
+#endif
+
+#ifdef JUCE_LINUX
+ const File dir ((commonToAllUsers ? T("/var/") : T("~/"))
+ + (folderName.isNotEmpty() ? folderName
+ : (T(".") + applicationName)));
+#endif
+
+#if JUCE_WIN32
+ File dir (File::getSpecialLocation (commonToAllUsers ? File::commonApplicationDataDirectory
+ : File::userApplicationDataDirectory));
+
+ if (dir == File::nonexistent)
+ return File::nonexistent;
+
+ dir = dir.getChildFile (folderName.isNotEmpty() ? folderName
+ : applicationName);
+
+#endif
+
+ return dir.getChildFile (applicationName)
+ .withFileExtension (fileNameSuffix);
+}
+
+PropertiesFile* PropertiesFile::createDefaultAppPropertiesFile (const String& applicationName,
+ const String& fileNameSuffix,
+ const String& folderName,
+ const bool commonToAllUsers,
+ const int millisecondsBeforeSaving,
+ const int propertiesFileOptions)
+{
+ const File file (getDefaultAppSettingsFile (applicationName,
+ fileNameSuffix,
+ folderName,
+ commonToAllUsers));
+
+ jassert (file != File::nonexistent);
+
+ if (file == File::nonexistent)
+ return 0;
+
+ return new PropertiesFile (file, millisecondsBeforeSaving, propertiesFileOptions);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_PropertiesFile.cpp *********/
+
+/********* Start of inlined file: juce_AiffAudioFormat.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+#undef chunkName
+#define chunkName(a) (int)littleEndianInt(a)
+
+#define aiffFormatName TRANS("AIFF file")
+static const tchar* const aiffExtensions[] = { T(".aiff"), T(".aif"), 0 };
+
+class AiffAudioFormatReader : public AudioFormatReader
+{
+public:
+ int bytesPerFrame;
+ int64 dataChunkStart;
+ bool littleEndian;
+
+ AiffAudioFormatReader (InputStream* in)
+ : AudioFormatReader (in, aiffFormatName)
+ {
+ if (input->readInt() == chunkName ("FORM"))
+ {
+ const int len = input->readIntBigEndian();
+ const int64 end = input->getPosition() + len;
+
+ const int nextType = input->readInt();
+ if (nextType == chunkName ("AIFF") || nextType == chunkName ("AIFC"))
+ {
+ bool hasGotVer = false;
+ bool hasGotData = false;
+ bool hasGotType = false;
+
+ while (input->getPosition() < end)
+ {
+ const int type = input->readInt();
+ const uint32 length = (uint32) input->readIntBigEndian();
+ const int64 chunkEnd = input->getPosition() + length;
+
+ if (type == chunkName ("FVER"))
+ {
+ hasGotVer = true;
+
+ const int ver = input->readIntBigEndian();
+ if (ver != 0 && ver != (int)0xa2805140)
+ break;
+ }
+ else if (type == chunkName ("COMM"))
+ {
+ hasGotType = true;
+
+ numChannels = (unsigned int)input->readShortBigEndian();
+ lengthInSamples = input->readIntBigEndian();
+ bitsPerSample = input->readShortBigEndian();
+ bytesPerFrame = (numChannels * bitsPerSample) >> 3;
+
+ unsigned char sampleRateBytes[10];
+ input->read (sampleRateBytes, 10);
+ const int byte0 = sampleRateBytes[0];
+
+ if ((byte0 & 0x80) != 0
+ || byte0 <= 0x3F || byte0 > 0x40
+ || (byte0 == 0x40 && sampleRateBytes[1] > 0x1C))
+ break;
+
+ unsigned int sampRate = bigEndianInt ((char*) sampleRateBytes + 2);
+ sampRate >>= (16414 - bigEndianShort ((char*) sampleRateBytes));
+ sampleRate = (int)sampRate;
+
+ if (length <= 18)
+ {
+ // some types don't have a chunk large enough to include a compression
+ // type, so assume it's just big-endian pcm
+ littleEndian = false;
+ }
+ else
+ {
+ const int compType = input->readInt();
+
+ if (compType == chunkName ("NONE") || compType == chunkName ("twos"))
+ {
+ littleEndian = false;
+ }
+ else if (compType == chunkName ("sowt"))
+ {
+ littleEndian = true;
+ }
+ else
+ {
+ sampleRate = 0;
+ break;
+ }
+ }
+ }
+ else if (type == chunkName ("SSND"))
+ {
+ hasGotData = true;
+
+ const int offset = input->readIntBigEndian();
+ dataChunkStart = input->getPosition() + 4 + offset;
+ lengthInSamples = (bytesPerFrame > 0) ? jmin (lengthInSamples, (int64) (length / bytesPerFrame)) : 0;
+ }
+ else if ((hasGotVer && hasGotData && hasGotType)
+ || chunkEnd < input->getPosition()
+ || input->isExhausted())
+ {
+ break;
+ }
+
+ input->setPosition (chunkEnd);
+ }
+ }
+ }
+ }
+
+ ~AiffAudioFormatReader()
+ {
+ }
+
+ bool read (int** destSamples,
+ int64 startSampleInFile,
+ int numSamples)
+ {
+ int64 start = startSampleInFile;
+ int startOffsetInDestBuffer = 0;
+
+ if (startSampleInFile < 0)
+ {
+ const int silence = (int) jmin (-startSampleInFile, (int64) numSamples);
+
+ int** destChan = destSamples;
+
+ for (int i = 2; --i >= 0;)
+ {
+ if (*destChan != 0)
+ {
+ zeromem (*destChan, sizeof (int) * silence);
+ ++destChan;
+ }
+ }
+
+ startOffsetInDestBuffer += silence;
+ numSamples -= silence;
+ start = 0;
+ }
+
+ int numToDo = jlimit (0, numSamples, (int) (lengthInSamples - start));
+
+ if (numToDo > 0)
+ {
+ input->setPosition (dataChunkStart + start * bytesPerFrame);
+
+ int num = numToDo;
+ int* left = destSamples[0];
+ if (left != 0)
+ left += startOffsetInDestBuffer;
+
+ int* right = destSamples[1];
+ if (right != 0)
+ right += startOffsetInDestBuffer;
+
+ // (keep this a multiple of 3)
+ const int tempBufSize = 1440 * 4;
+ char tempBuffer [tempBufSize];
+
+ while (num > 0)
+ {
+ const int numThisTime = jmin (tempBufSize / bytesPerFrame, num);
+ const int bytesRead = input->read (tempBuffer, numThisTime * bytesPerFrame);
+
+ if (bytesRead < numThisTime * bytesPerFrame)
+ zeromem (tempBuffer + bytesRead, numThisTime * bytesPerFrame - bytesRead);
+
+ if (bitsPerSample == 16)
+ {
+ if (littleEndian)
+ {
+ const short* src = (const short*) tempBuffer;
+
+ if (numChannels > 1)
+ {
+ if (left == 0)
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *right++ = (int) swapIfBigEndian ((unsigned short) *src++) << 16;
+ ++src;
+ }
+ }
+ else if (right == 0)
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ ++src;
+ *left++ = (int) swapIfBigEndian ((unsigned short) *src++) << 16;
+ }
+ }
+ else
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *left++ = (int) swapIfBigEndian ((unsigned short) *src++) << 16;
+ *right++ = (int) swapIfBigEndian ((unsigned short) *src++) << 16;
+ }
+ }
+ }
+ else
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *left++ = (int) swapIfBigEndian ((unsigned short) *src++) << 16;
+ }
+ }
+ }
+ else
+ {
+ const char* src = (const char*) tempBuffer;
+
+ if (numChannels > 1)
+ {
+ if (left == 0)
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *right++ = bigEndianShort (src) << 16;
+ src += 4;
+ }
+ }
+ else if (right == 0)
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ src += 2;
+ *left++ = bigEndianShort (src) << 16;
+ src += 2;
+ }
+ }
+ else
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *left++ = bigEndianShort (src) << 16;
+ src += 2;
+ *right++ = bigEndianShort (src) << 16;
+ src += 2;
+ }
+ }
+ }
+ else
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *left++ = bigEndianShort (src) << 16;
+ src += 2;
+ }
+ }
+ }
+ }
+ else if (bitsPerSample == 24)
+ {
+ const char* src = (const char*)tempBuffer;
+
+ if (littleEndian)
+ {
+ if (numChannels > 1)
+ {
+ if (left == 0)
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *right++ = littleEndian24Bit (src) << 8;
+ src += 6;
+ }
+ }
+ else if (right == 0)
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ src += 3;
+ *left++ = littleEndian24Bit (src) << 8;
+ src += 3;
+ }
+ }
+ else
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *left++ = littleEndian24Bit (src) << 8;
+ src += 3;
+ *right++ = littleEndian24Bit (src) << 8;
+ src += 3;
+ }
+ }
+ }
+ else
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *left++ = littleEndian24Bit (src) << 8;
+ src += 3;
+ }
+ }
+ }
+ else
+ {
+ if (numChannels > 1)
+ {
+ if (left == 0)
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *right++ = bigEndian24Bit (src) << 8;
+ src += 6;
+ }
+ }
+ else if (right == 0)
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ src += 3;
+ *left++ = bigEndian24Bit (src) << 8;
+ src += 3;
+ }
+ }
+ else
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *left++ = bigEndian24Bit (src) << 8;
+ src += 3;
+ *right++ = bigEndian24Bit (src) << 8;
+ src += 3;
+ }
+ }
+ }
+ else
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *left++ = bigEndian24Bit (src) << 8;
+ src += 3;
+ }
+ }
+ }
+ }
+ else if (bitsPerSample == 32)
+ {
+ const unsigned int* src = (const unsigned int*) tempBuffer;
+ unsigned int* l = (unsigned int*) left;
+ unsigned int* r = (unsigned int*) right;
+
+ if (littleEndian)
+ {
+ if (numChannels > 1)
+ {
+ if (l == 0)
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ ++src;
+ *r++ = swapIfBigEndian (*src++);
+ }
+ }
+ else if (r == 0)
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *l++ = swapIfBigEndian (*src++);
+ ++src;
+ }
+ }
+ else
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *l++ = swapIfBigEndian (*src++);
+ *r++ = swapIfBigEndian (*src++);
+ }
+ }
+ }
+ else
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *l++ = swapIfBigEndian (*src++);
+ }
+ }
+ }
+ else
+ {
+ if (numChannels > 1)
+ {
+ if (l == 0)
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ ++src;
+ *r++ = swapIfLittleEndian (*src++);
+ }
+ }
+ else if (r == 0)
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *l++ = swapIfLittleEndian (*src++);
+ ++src;
+ }
+ }
+ else
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *l++ = swapIfLittleEndian (*src++);
+ *r++ = swapIfLittleEndian (*src++);
+ }
+ }
+ }
+ else
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *l++ = swapIfLittleEndian (*src++);
+ }
+ }
+ }
+
+ left = (int*) l;
+ right = (int*) r;
+ }
+ else if (bitsPerSample == 8)
+ {
+ const char* src = (const char*) tempBuffer;
+
+ if (numChannels > 1)
+ {
+ if (left == 0)
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *right++ = ((int) *src++) << 24;
+ ++src;
+ }
+ }
+ else if (right == 0)
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ ++src;
+ *left++ = ((int) *src++) << 24;
+ }
+ }
+ else
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *left++ = ((int) *src++) << 24;
+ *right++ = ((int) *src++) << 24;
+ }
+ }
+ }
+ else
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *left++ = ((int) *src++) << 24;
+ }
+ }
+ }
+
+ num -= numThisTime;
+ }
+ }
+
+ if (numToDo < numSamples)
+ {
+ int** destChan = destSamples;
+ while (*destChan != 0)
+ {
+ zeromem ((*destChan) + (startOffsetInDestBuffer + numToDo),
+ sizeof (int) * (numSamples - numToDo));
+ ++destChan;
+ }
+ }
+
+ return true;
+ }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ AiffAudioFormatReader (const AiffAudioFormatReader&);
+ const AiffAudioFormatReader& operator= (const AiffAudioFormatReader&);
+};
+
+class AiffAudioFormatWriter : public AudioFormatWriter
+{
+ MemoryBlock tempBlock;
+ uint32 lengthInSamples, bytesWritten;
+ int64 headerPosition;
+ bool writeFailed;
+
+ AiffAudioFormatWriter (const AiffAudioFormatWriter&);
+ const AiffAudioFormatWriter& operator= (const AiffAudioFormatWriter&);
+
+ void writeHeader()
+ {
+ const bool couldSeekOk = output->setPosition (headerPosition);
+ (void) couldSeekOk;
+
+ // if this fails, you've given it an output stream that can't seek! It needs
+ // to be able to seek back to write the header
+ jassert (couldSeekOk);
+
+ const int headerLen = 54;
+ int audioBytes = lengthInSamples * ((bitsPerSample * numChannels) / 8);
+ audioBytes += (audioBytes & 1);
+
+ output->writeInt (chunkName ("FORM"));
+ output->writeIntBigEndian (headerLen + audioBytes - 8);
+ output->writeInt (chunkName ("AIFF"));
+ output->writeInt (chunkName ("COMM"));
+ output->writeIntBigEndian (18);
+ output->writeShortBigEndian ((short) numChannels);
+ output->writeIntBigEndian (lengthInSamples);
+ output->writeShortBigEndian ((short) bitsPerSample);
+
+ uint8 sampleRateBytes[10];
+ zeromem (sampleRateBytes, 10);
+
+ if (sampleRate <= 1)
+ {
+ sampleRateBytes[0] = 0x3f;
+ sampleRateBytes[1] = 0xff;
+ sampleRateBytes[2] = 0x80;
+ }
+ else
+ {
+ int mask = 0x40000000;
+ sampleRateBytes[0] = 0x40;
+
+ if (sampleRate >= mask)
+ {
+ jassertfalse
+ sampleRateBytes[1] = 0x1d;
+ }
+ else
+ {
+ int n = (int) sampleRate;
+
+ int i;
+ for (i = 0; i <= 32 ; ++i)
+ {
+ if ((n & mask) != 0)
+ break;
+
+ mask >>= 1;
+ }
+
+ n = n << (i + 1);
+
+ sampleRateBytes[1] = (uint8) (29 - i);
+ sampleRateBytes[2] = (uint8) ((n >> 24) & 0xff);
+ sampleRateBytes[3] = (uint8) ((n >> 16) & 0xff);
+ sampleRateBytes[4] = (uint8) ((n >> 8) & 0xff);
+ sampleRateBytes[5] = (uint8) (n & 0xff);
+ }
+ }
+
+ output->write (sampleRateBytes, 10);
+
+ output->writeInt (chunkName ("SSND"));
+ output->writeIntBigEndian (audioBytes + 8);
+ output->writeInt (0);
+ output->writeInt (0);
+
+ jassert (output->getPosition() == headerLen);
+ }
+
+public:
+
+ AiffAudioFormatWriter (OutputStream* out,
+ const double sampleRate,
+ const unsigned int chans,
+ const int bits)
+ : AudioFormatWriter (out,
+ aiffFormatName,
+ sampleRate,
+ chans,
+ bits),
+ lengthInSamples (0),
+ bytesWritten (0),
+ writeFailed (false)
+ {
+ headerPosition = out->getPosition();
+ writeHeader();
+ }
+
+ ~AiffAudioFormatWriter()
+ {
+ if ((bytesWritten & 1) != 0)
+ output->writeByte (0);
+
+ writeHeader();
+ }
+
+ bool write (const int** data, int numSamples)
+ {
+ if (writeFailed)
+ return false;
+
+ const int bytes = numChannels * numSamples * bitsPerSample / 8;
+ tempBlock.ensureSize (bytes, false);
+ char* buffer = (char*) tempBlock.getData();
+
+ const int* left = data[0];
+ const int* right = data[1];
+ if (right == 0)
+ right = left;
+
+ if (bitsPerSample == 16)
+ {
+ short* b = (short*) buffer;
+
+ if (numChannels > 1)
+ {
+ for (int i = numSamples; --i >= 0;)
+ {
+ *b++ = (short) swapIfLittleEndian ((unsigned short) (*left++ >> 16));
+ *b++ = (short) swapIfLittleEndian ((unsigned short) (*right++ >> 16));
+ }
+ }
+ else
+ {
+ for (int i = numSamples; --i >= 0;)
+ {
+ *b++ = (short) swapIfLittleEndian ((unsigned short) (*left++ >> 16));
+ }
+ }
+ }
+ else if (bitsPerSample == 24)
+ {
+ char* b = (char*) buffer;
+
+ if (numChannels > 1)
+ {
+ for (int i = numSamples; --i >= 0;)
+ {
+ bigEndian24BitToChars (*left++ >> 8, b);
+ b += 3;
+ bigEndian24BitToChars (*right++ >> 8, b);
+ b += 3;
+ }
+ }
+ else
+ {
+ for (int i = numSamples; --i >= 0;)
+ {
+ bigEndian24BitToChars (*left++ >> 8, b);
+ b += 3;
+ }
+ }
+ }
+ else if (bitsPerSample == 32)
+ {
+ unsigned int* b = (unsigned int*) buffer;
+
+ if (numChannels > 1)
+ {
+ for (int i = numSamples; --i >= 0;)
+ {
+ *b++ = swapIfLittleEndian ((unsigned int) *left++);
+ *b++ = swapIfLittleEndian ((unsigned int) *right++);
+ }
+ }
+ else
+ {
+ for (int i = numSamples; --i >= 0;)
+ {
+ *b++ = swapIfLittleEndian ((unsigned int) *left++);
+ }
+ }
+ }
+ else if (bitsPerSample == 8)
+ {
+ char* b = (char*)buffer;
+
+ if (numChannels > 1)
+ {
+ for (int i = numSamples; --i >= 0;)
+ {
+ *b++ = (char) (*left++ >> 24);
+ *b++ = (char) (*right++ >> 24);
+ }
+ }
+ else
+ {
+ for (int i = numSamples; --i >= 0;)
+ {
+ *b++ = (char) (*left++ >> 24);
+ }
+ }
+ }
+
+ if (bytesWritten + bytes >= (uint32) 0xfff00000
+ || ! output->write (buffer, bytes))
+ {
+ // failed to write to disk, so let's try writing the header.
+ // If it's just run out of disk space, then if it does manage
+ // to write the header, we'll still have a useable file..
+ writeHeader();
+ writeFailed = true;
+ return false;
+ }
+ else
+ {
+ bytesWritten += bytes;
+ lengthInSamples += numSamples;
+
+ return true;
+ }
+ }
+
+ juce_UseDebuggingNewOperator
+};
+
+AiffAudioFormat::AiffAudioFormat()
+ : AudioFormat (aiffFormatName, (const tchar**) aiffExtensions)
+{
+}
+
+AiffAudioFormat::~AiffAudioFormat()
+{
+}
+
+const Array AiffAudioFormat::getPossibleSampleRates()
+{
+ const int rates[] = { 22050, 32000, 44100, 48000, 88200, 96000, 176400, 192000, 0 };
+ return Array (rates);
+}
+
+const Array AiffAudioFormat::getPossibleBitDepths()
+{
+ const int depths[] = { 8, 16, 24, 0 };
+ return Array (depths);
+}
+
+bool AiffAudioFormat::canDoStereo()
+{
+ return true;
+}
+
+bool AiffAudioFormat::canDoMono()
+{
+ return true;
+}
+
+#if JUCE_MAC
+bool AiffAudioFormat::canHandleFile (const File& f)
+{
+ if (AudioFormat::canHandleFile (f))
+ return true;
+
+ const OSType type = PlatformUtilities::getTypeOfFile (f.getFullPathName());
+ return type == 'AIFF' || type == 'AIFC'
+ || type == 'aiff' || type == 'aifc';
+}
+#endif
+
+AudioFormatReader* AiffAudioFormat::createReaderFor (InputStream* sourceStream,
+ const bool deleteStreamIfOpeningFails)
+{
+ AiffAudioFormatReader* w = new AiffAudioFormatReader (sourceStream);
+
+ if (w->sampleRate == 0)
+ {
+ if (! deleteStreamIfOpeningFails)
+ w->input = 0;
+
+ deleteAndZero (w);
+ }
+
+ return w;
+}
+
+AudioFormatWriter* AiffAudioFormat::createWriterFor (OutputStream* out,
+ double sampleRate,
+ unsigned int chans,
+ int bitsPerSample,
+ const StringPairArray& /*metadataValues*/,
+ int /*qualityOptionIndex*/)
+{
+ if (getPossibleBitDepths().contains (bitsPerSample))
+ {
+ return new AiffAudioFormatWriter (out,
+ sampleRate,
+ chans,
+ bitsPerSample);
+ }
+
+ return 0;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_AiffAudioFormat.cpp *********/
+
+/********* Start of inlined file: juce_AudioCDReader.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+#if JUCE_MAC
+
+// Mac version doesn't need any native code because it's all done with files..
+// Windows + Linux versions are in the platform-dependent code sections.
+
+static void findCDs (OwnedArray& cds)
+{
+ File volumes ("/Volumes");
+ volumes.findChildFiles (cds, File::findDirectories, false);
+
+ for (int i = cds.size(); --i >= 0;)
+ if (! cds[i]->getChildFile (".TOC.plist").exists())
+ cds.remove (i);
+}
+
+const StringArray AudioCDReader::getAvailableCDNames()
+{
+ OwnedArray cds;
+ findCDs (cds);
+
+ StringArray names;
+
+ for (int i = 0; i < cds.size(); ++i)
+ names.add (cds[i]->getFileName());
+
+ return names;
+}
+
+AudioCDReader* AudioCDReader::createReaderForCD (const int index)
+{
+ OwnedArray cds;
+ findCDs (cds);
+
+ if (cds[index] != 0)
+ return new AudioCDReader (*cds[index]);
+ else
+ return 0;
+}
+
+AudioCDReader::AudioCDReader (const File& volume)
+ : AudioFormatReader (0, "CD Audio"),
+ volumeDir (volume),
+ currentReaderTrack (-1),
+ reader (0)
+{
+ sampleRate = 44100.0;
+ bitsPerSample = 16;
+ numChannels = 2;
+ usesFloatingPointData = false;
+
+ refreshTrackLengths();
+}
+
+AudioCDReader::~AudioCDReader()
+{
+ if (reader != 0)
+ delete reader;
+}
+
+static int getTrackNumber (const File& file)
+{
+ return file.getFileName()
+ .initialSectionContainingOnly (T("0123456789"))
+ .getIntValue();
+}
+
+int AudioCDReader::compareElements (const File* const first, const File* const second) throw()
+{
+ const int firstTrack = getTrackNumber (*first);
+ const int secondTrack = getTrackNumber (*second);
+
+ jassert (firstTrack > 0 && secondTrack > 0);
+
+ return firstTrack - secondTrack;
+}
+
+void AudioCDReader::refreshTrackLengths()
+{
+ tracks.clear();
+ trackStartSamples.clear();
+ volumeDir.findChildFiles (tracks, File::findFiles | File::ignoreHiddenFiles, false, T("*.aiff"));
+
+ tracks.sort (*this);
+
+ AiffAudioFormat format;
+ int sample = 0;
+
+ for (int i = 0; i < tracks.size(); ++i)
+ {
+ trackStartSamples.add (sample);
+
+ FileInputStream* const in = tracks[i]->createInputStream();
+
+ if (in != 0)
+ {
+ AudioFormatReader* const r = format.createReaderFor (in, true);
+
+ if (r != 0)
+ {
+ sample += r->lengthInSamples;
+ delete r;
+ }
+ }
+ }
+
+ trackStartSamples.add (sample);
+ lengthInSamples = sample;
+}
+
+bool AudioCDReader::read (int** destSamples,
+ int64 startSampleInFile,
+ int numSamples)
+{
+ while (numSamples > 0)
+ {
+ int track = -1;
+
+ for (int i = 0; i < trackStartSamples.size() - 1; ++i)
+ {
+ if (startSampleInFile < trackStartSamples.getUnchecked (i + 1))
+ {
+ track = i;
+ break;
+ }
+ }
+
+ if (track < 0)
+ return false;
+
+ if (track != currentReaderTrack)
+ {
+ deleteAndZero (reader);
+
+ if (tracks [track] != 0)
+ {
+ FileInputStream* const in = tracks [track]->createInputStream();
+
+ if (in != 0)
+ {
+ BufferedInputStream* const bin = new BufferedInputStream (in, 65536, true);
+
+ AiffAudioFormat format;
+ reader = format.createReaderFor (bin, true);
+
+ if (reader == 0)
+ currentReaderTrack = -1;
+ else
+ currentReaderTrack = track;
+ }
+ }
+ }
+
+ if (reader == 0)
+ return false;
+
+ const int startPos = (int) (startSampleInFile - trackStartSamples.getUnchecked (track));
+ const int numAvailable = (int) jmin ((int64) numSamples, reader->lengthInSamples - startPos);
+
+ reader->read (destSamples, startPos, numAvailable);
+
+ numSamples -= numAvailable;
+ startSampleInFile += numAvailable;
+ }
+
+ return true;
+}
+
+bool AudioCDReader::isCDStillPresent() const
+{
+ return volumeDir.exists();
+}
+
+int AudioCDReader::getNumTracks() const
+{
+ return tracks.size();
+}
+
+int AudioCDReader::getPositionOfTrackStart (int trackNum) const
+{
+ return trackStartSamples [trackNum];
+}
+
+bool AudioCDReader::isTrackAudio (int trackNum) const
+{
+ return tracks [trackNum] != 0;
+}
+
+void AudioCDReader::enableIndexScanning (bool b)
+{
+ // any way to do this on a Mac??
+}
+
+int AudioCDReader::getLastIndex() const
+{
+ return 0;
+}
+
+const Array AudioCDReader::findIndexesInTrack (const int trackNumber)
+{
+ return Array ();
+}
+
+int AudioCDReader::getCDDBId()
+{
+ return 0; //xxx
+}
+
+#endif
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_AudioCDReader.cpp *********/
+
+/********* Start of inlined file: juce_AudioFormat.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+AudioFormatReader::AudioFormatReader (InputStream* const in,
+ const String& formatName_)
+ : sampleRate (0),
+ bitsPerSample (0),
+ lengthInSamples (0),
+ numChannels (0),
+ usesFloatingPointData (false),
+ input (in),
+ formatName (formatName_)
+{
+}
+
+AudioFormatReader::~AudioFormatReader()
+{
+ delete input;
+}
+
+static void findMaxMin (const float* src, const int num,
+ float& maxVal, float& minVal)
+{
+ float mn = src[0];
+ float mx = mn;
+
+ for (int i = 1; i < num; ++i)
+ {
+ const float s = src[i];
+ if (s > mx)
+ mx = s;
+ if (s < mn)
+ mn = s;
+ }
+
+ maxVal = mx;
+ minVal = mn;
+}
+
+void AudioFormatReader::readMaxLevels (int64 startSampleInFile,
+ int64 numSamples,
+ float& lowestLeft, float& highestLeft,
+ float& lowestRight, float& highestRight)
+{
+ if (numSamples <= 0)
+ {
+ lowestLeft = 0;
+ lowestRight = 0;
+ highestLeft = 0;
+ highestRight = 0;
+ return;
+ }
+
+ const int bufferSize = (int) jmin (numSamples, (int64) 4096);
+ MemoryBlock tempSpace (bufferSize * sizeof (int) * 2 + 64);
+
+ int* tempBuffer[3];
+ tempBuffer[0] = (int*) tempSpace.getData();
+ tempBuffer[1] = ((int*) tempSpace.getData()) + bufferSize;
+ tempBuffer[2] = 0;
+
+ if (usesFloatingPointData)
+ {
+ float lmin = 1.0e6;
+ float lmax = -lmin;
+ float rmin = lmin;
+ float rmax = lmax;
+
+ while (numSamples > 0)
+ {
+ const int numToDo = (int) jmin (numSamples, (int64) bufferSize);
+ read ((int**) tempBuffer, startSampleInFile, numToDo);
+
+ numSamples -= numToDo;
+
+ float bufmin, bufmax;
+ findMaxMin ((float*) tempBuffer[0], numToDo, bufmax, bufmin);
+ lmin = jmin (lmin, bufmin);
+ lmax = jmax (lmax, bufmax);
+
+ if (numChannels > 1)
+ {
+ findMaxMin ((float*) tempBuffer[1], numToDo, bufmax, bufmin);
+ rmin = jmin (rmin, bufmin);
+ rmax = jmax (rmax, bufmax);
+ }
+ }
+
+ if (numChannels <= 1)
+ {
+ rmax = lmax;
+ rmin = lmin;
+ }
+
+ lowestLeft = lmin;
+ highestLeft = lmax;
+ lowestRight = rmin;
+ highestRight = rmax;
+ }
+ else
+ {
+ int lmax = INT_MIN;
+ int lmin = INT_MAX;
+ int rmax = INT_MIN;
+ int rmin = INT_MAX;
+
+ while (numSamples > 0)
+ {
+ const int numToDo = (int) jmin (numSamples, (int64) bufferSize);
+ read ((int**) tempBuffer, startSampleInFile, numToDo);
+
+ numSamples -= numToDo;
+
+ for (int j = numChannels; --j >= 0;)
+ {
+ int bufMax = INT_MIN;
+ int bufMin = INT_MAX;
+
+ const int* const b = tempBuffer[j];
+
+ for (int i = 0; i < numToDo; ++i)
+ {
+ const int samp = b[i];
+
+ if (samp < bufMin)
+ bufMin = samp;
+
+ if (samp > bufMax)
+ bufMax = samp;
+ }
+
+ if (j == 0)
+ {
+ lmax = jmax (lmax, bufMax);
+ lmin = jmin (lmin, bufMin);
+ }
+ else
+ {
+ rmax = jmax (rmax, bufMax);
+ rmin = jmin (rmin, bufMin);
+ }
+ }
+ }
+
+ if (numChannels <= 1)
+ {
+ rmax = lmax;
+ rmin = lmin;
+ }
+
+ lowestLeft = lmin / (float)INT_MAX;
+ highestLeft = lmax / (float)INT_MAX;
+ lowestRight = rmin / (float)INT_MAX;
+ highestRight = rmax / (float)INT_MAX;
+ }
+}
+
+int64 AudioFormatReader::searchForLevel (int64 startSample,
+ int64 numSamplesToSearch,
+ const double magnitudeRangeMinimum,
+ const double magnitudeRangeMaximum,
+ const int minimumConsecutiveSamples)
+{
+ if (numSamplesToSearch == 0)
+ return -1;
+
+ const int bufferSize = 4096;
+ MemoryBlock tempSpace (bufferSize * sizeof (int) * 2 + 64);
+
+ int* tempBuffer[3];
+ tempBuffer[0] = (int*) tempSpace.getData();
+ tempBuffer[1] = ((int*) tempSpace.getData()) + bufferSize;
+ tempBuffer[2] = 0;
+
+ int consecutive = 0;
+ int64 firstMatchPos = -1;
+
+ jassert (magnitudeRangeMaximum > magnitudeRangeMinimum);
+
+ const double doubleMin = jlimit (0.0, (double) INT_MAX, magnitudeRangeMinimum * INT_MAX);
+ const double doubleMax = jlimit (doubleMin, (double) INT_MAX, magnitudeRangeMaximum * INT_MAX);
+ const int intMagnitudeRangeMinimum = roundDoubleToInt (doubleMin);
+ const int intMagnitudeRangeMaximum = roundDoubleToInt (doubleMax);
+
+ while (numSamplesToSearch != 0)
+ {
+ const int numThisTime = (int) jmin (abs64 (numSamplesToSearch), (int64) bufferSize);
+ int64 bufferStart = startSample;
+
+ if (numSamplesToSearch < 0)
+ bufferStart -= numThisTime;
+
+ if (bufferStart >= (int) lengthInSamples)
+ break;
+
+ read ((int**) tempBuffer, bufferStart, numThisTime);
+
+ int num = numThisTime;
+ while (--num >= 0)
+ {
+ if (numSamplesToSearch < 0)
+ --startSample;
+
+ bool matches = false;
+ const int index = (int) (startSample - bufferStart);
+
+ if (usesFloatingPointData)
+ {
+ const float sample1 = fabsf (((float*) tempBuffer[0]) [index]);
+
+ if (sample1 >= magnitudeRangeMinimum
+ && sample1 <= magnitudeRangeMaximum)
+ {
+ matches = true;
+ }
+ else if (numChannels > 1)
+ {
+ const float sample2 = fabsf (((float*) tempBuffer[1]) [index]);
+
+ matches = (sample2 >= magnitudeRangeMinimum
+ && sample2 <= magnitudeRangeMaximum);
+ }
+ }
+ else
+ {
+ const int sample1 = abs (tempBuffer[0] [index]);
+
+ if (sample1 >= intMagnitudeRangeMinimum
+ && sample1 <= intMagnitudeRangeMaximum)
+ {
+ matches = true;
+ }
+ else if (numChannels > 1)
+ {
+ const int sample2 = abs (tempBuffer[1][index]);
+
+ matches = (sample2 >= intMagnitudeRangeMinimum
+ && sample2 <= intMagnitudeRangeMaximum);
+ }
+ }
+
+ if (matches)
+ {
+ if (firstMatchPos < 0)
+ firstMatchPos = startSample;
+
+ if (++consecutive >= minimumConsecutiveSamples)
+ {
+ if (firstMatchPos < 0 || firstMatchPos >= lengthInSamples)
+ return -1;
+
+ return firstMatchPos;
+ }
+ }
+ else
+ {
+ consecutive = 0;
+ firstMatchPos = -1;
+ }
+
+ if (numSamplesToSearch > 0)
+ ++startSample;
+ }
+
+ if (numSamplesToSearch > 0)
+ numSamplesToSearch -= numThisTime;
+ else
+ numSamplesToSearch += numThisTime;
+ }
+
+ return -1;
+}
+
+AudioFormatWriter::AudioFormatWriter (OutputStream* const out,
+ const String& formatName_,
+ const double rate,
+ const unsigned int numChannels_,
+ const unsigned int bitsPerSample_)
+ : sampleRate (rate),
+ numChannels (numChannels_),
+ bitsPerSample (bitsPerSample_),
+ usesFloatingPointData (false),
+ output (out),
+ formatName (formatName_)
+{
+}
+
+AudioFormatWriter::~AudioFormatWriter()
+{
+ delete output;
+}
+
+bool AudioFormatWriter::writeFromAudioReader (AudioFormatReader& reader,
+ int64 startSample,
+ int numSamplesToRead)
+{
+ const int bufferSize = 16384;
+ const int maxChans = 128;
+ AudioSampleBuffer tempBuffer (reader.numChannels, bufferSize);
+ int* buffers [maxChans];
+
+ for (int i = maxChans; --i >= 0;)
+ buffers[i] = 0;
+
+ while (numSamplesToRead > 0)
+ {
+ const int numToDo = jmin (numSamplesToRead, bufferSize);
+
+ for (int i = tempBuffer.getNumChannels(); --i >= 0;)
+ buffers[i] = (int*) tempBuffer.getSampleData (i, 0);
+
+ if (! reader.read (buffers, startSample, numToDo))
+ return false;
+
+ if (reader.usesFloatingPointData != isFloatingPoint())
+ {
+ int** bufferChan = buffers;
+
+ while (*bufferChan != 0)
+ {
+ int* b = *bufferChan++;
+
+ if (isFloatingPoint())
+ {
+ // int -> float
+ const double factor = 1.0 / INT_MAX;
+
+ for (int i = 0; i < numToDo; ++i)
+ ((float*)b)[i] = (float) (factor * b[i]);
+ }
+ else
+ {
+ // float -> int
+ for (int i = 0; i < numToDo; ++i)
+ {
+ const double samp = *(const float*) b;
+
+ if (samp <= -1.0)
+ *b++ = INT_MIN;
+ else if (samp >= 1.0)
+ *b++ = INT_MAX;
+ else
+ *b++ = roundDoubleToInt (INT_MAX * samp);
+ }
+ }
+ }
+ }
+
+ if (! write ((const int**) buffers, numToDo))
+ return false;
+
+ numSamplesToRead -= numToDo;
+ startSample += numToDo;
+ }
+
+ return true;
+}
+
+bool AudioFormatWriter::writeFromAudioSource (AudioSource& source,
+ int numSamplesToRead,
+ const int samplesPerBlock)
+{
+ const int maxChans = 128;
+ AudioSampleBuffer tempBuffer (getNumChannels(), samplesPerBlock);
+ int* buffers [maxChans];
+
+ while (numSamplesToRead > 0)
+ {
+ const int numToDo = jmin (numSamplesToRead, samplesPerBlock);
+
+ AudioSourceChannelInfo info;
+ info.buffer = &tempBuffer;
+ info.startSample = 0;
+ info.numSamples = numToDo;
+ info.clearActiveBufferRegion();
+
+ source.getNextAudioBlock (info);
+
+ int i;
+ for (i = maxChans; --i >= 0;)
+ buffers[i] = 0;
+
+ for (i = tempBuffer.getNumChannels(); --i >= 0;)
+ buffers[i] = (int*) tempBuffer.getSampleData (i, 0);
+
+ if (! isFloatingPoint())
+ {
+ int** bufferChan = buffers;
+
+ while (*bufferChan != 0)
+ {
+ int* b = *bufferChan++;
+
+ // float -> int
+ for (int j = numToDo; --j >= 0;)
+ {
+ const double samp = *(const float*) b;
+
+ if (samp <= -1.0)
+ *b++ = INT_MIN;
+ else if (samp >= 1.0)
+ *b++ = INT_MAX;
+ else
+ *b++ = roundDoubleToInt (INT_MAX * samp);
+ }
+ }
+ }
+
+ if (! write ((const int**) buffers, numToDo))
+ return false;
+
+ numSamplesToRead -= numToDo;
+ }
+
+ return true;
+}
+
+AudioFormat::AudioFormat (const String& name,
+ const tchar** const extensions)
+ : formatName (name),
+ fileExtensions (extensions)
+{
+}
+
+AudioFormat::~AudioFormat()
+{
+}
+
+const String& AudioFormat::getFormatName() const
+{
+ return formatName;
+}
+
+const StringArray& AudioFormat::getFileExtensions() const
+{
+ return fileExtensions;
+}
+
+bool AudioFormat::canHandleFile (const File& f)
+{
+ for (int i = 0; i < fileExtensions.size(); ++i)
+ if (f.hasFileExtension (fileExtensions[i]))
+ return true;
+
+ return false;
+}
+
+bool AudioFormat::isCompressed()
+{
+ return false;
+}
+
+const StringArray AudioFormat::getQualityOptions()
+{
+ return StringArray();
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_AudioFormat.cpp *********/
+
+/********* Start of inlined file: juce_AudioFormatManager.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+AudioFormatManager::AudioFormatManager()
+ : knownFormats (4),
+ defaultFormatIndex (0)
+{
+}
+
+AudioFormatManager::~AudioFormatManager()
+{
+ clearFormats();
+ clearSingletonInstance();
+}
+
+juce_ImplementSingleton (AudioFormatManager);
+
+void AudioFormatManager::registerFormat (AudioFormat* newFormat,
+ const bool makeThisTheDefaultFormat)
+{
+ jassert (newFormat != 0);
+
+ if (newFormat != 0)
+ {
+#ifdef JUCE_DEBUG
+ for (int i = getNumKnownFormats(); --i >= 0;)
+ {
+ if (getKnownFormat (i)->getFormatName() == newFormat->getFormatName())
+ {
+ jassertfalse // trying to add the same format twice!
+ }
+ }
+#endif
+
+ if (makeThisTheDefaultFormat)
+ defaultFormatIndex = knownFormats.size();
+
+ knownFormats.add (newFormat);
+ }
+}
+
+void AudioFormatManager::registerBasicFormats()
+{
+#if JUCE_MAC
+ registerFormat (new AiffAudioFormat(), true);
+ registerFormat (new WavAudioFormat(), false);
+#else
+ registerFormat (new WavAudioFormat(), true);
+ registerFormat (new AiffAudioFormat(), false);
+#endif
+
+#if JUCE_USE_FLAC
+ registerFormat (new FlacAudioFormat(), false);
+#endif
+
+#if JUCE_USE_OGGVORBIS
+ registerFormat (new OggVorbisAudioFormat(), false);
+#endif
+}
+
+void AudioFormatManager::clearFormats()
+{
+ for (int i = getNumKnownFormats(); --i >= 0;)
+ {
+ AudioFormat* const af = getKnownFormat(i);
+ delete af;
+ }
+
+ knownFormats.clear();
+ defaultFormatIndex = 0;
+}
+
+int AudioFormatManager::getNumKnownFormats() const
+{
+ return knownFormats.size();
+}
+
+AudioFormat* AudioFormatManager::getKnownFormat (const int index) const
+{
+ return (AudioFormat*) knownFormats [index];
+}
+
+AudioFormat* AudioFormatManager::getDefaultFormat() const
+{
+ return getKnownFormat (defaultFormatIndex);
+}
+
+AudioFormat* AudioFormatManager::findFormatForFileExtension (const String& fileExtension) const
+{
+ String e (fileExtension);
+ if (! e.startsWithChar (T('.')))
+ e = T(".") + e;
+
+ for (int i = 0; i < getNumKnownFormats(); ++i)
+ if (getKnownFormat(i)->getFileExtensions().contains (e, true))
+ return getKnownFormat(i);
+
+ return 0;
+}
+
+const String AudioFormatManager::getWildcardForAllFormats() const
+{
+ StringArray allExtensions;
+
+ int i;
+ for (i = 0; i < getNumKnownFormats(); ++i)
+ allExtensions.addArray (getKnownFormat (i)->getFileExtensions());
+
+ allExtensions.trim();
+ allExtensions.removeEmptyStrings();
+
+ String s;
+ for (i = 0; i < allExtensions.size(); ++i)
+ {
+ s << T('*');
+
+ if (! allExtensions[i].startsWithChar (T('.')))
+ s << T('.');
+
+ s << allExtensions[i];
+
+ if (i < allExtensions.size() - 1)
+ s << T(';');
+ }
+
+ return s;
+}
+
+AudioFormatReader* AudioFormatManager::createReaderFor (const File& file)
+{
+ // you need to actually register some formats before the manager can
+ // use them to open a file!
+ jassert (knownFormats.size() > 0);
+
+ for (int i = 0; i < getNumKnownFormats(); ++i)
+ {
+ AudioFormat* const af = getKnownFormat(i);
+
+ if (af->canHandleFile (file))
+ {
+ InputStream* const in = file.createInputStream();
+
+ if (in != 0)
+ {
+ AudioFormatReader* const r = af->createReaderFor (in, true);
+
+ if (r != 0)
+ return r;
+ }
+ }
+ }
+
+ return 0;
+}
+
+AudioFormatReader* AudioFormatManager::createReaderFor (InputStream* in)
+{
+ // you need to actually register some formats before the manager can
+ // use them to open a file!
+ jassert (knownFormats.size() > 0);
+
+ if (in != 0)
+ {
+ const int64 originalStreamPos = in->getPosition();
+
+ for (int i = 0; i < getNumKnownFormats(); ++i)
+ {
+ AudioFormatReader* const r = getKnownFormat(i)->createReaderFor (in, false);
+
+ if (r != 0)
+ return r;
+
+ in->setPosition (originalStreamPos);
+
+ // the stream that is passed-in must be capable of being repositioned so
+ // that all the formats can have a go at opening it.
+ jassert (in->getPosition() == originalStreamPos);
+ }
+
+ delete in;
+ }
+
+ return 0;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_AudioFormatManager.cpp *********/
+
+/********* Start of inlined file: juce_AudioSubsectionReader.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+AudioSubsectionReader::AudioSubsectionReader (AudioFormatReader* const source_,
+ const int64 startSample_,
+ const int64 length_,
+ const bool deleteSourceWhenDeleted_)
+ : AudioFormatReader (0, source_->getFormatName()),
+ source (source_),
+ startSample (startSample_),
+ deleteSourceWhenDeleted (deleteSourceWhenDeleted_)
+{
+ length = jmin (jmax ((int64) 0, source->lengthInSamples - startSample), length_);
+
+ sampleRate = source->sampleRate;
+ bitsPerSample = source->bitsPerSample;
+ lengthInSamples = length;
+ numChannels = source->numChannels;
+ usesFloatingPointData = source->usesFloatingPointData;
+}
+
+AudioSubsectionReader::~AudioSubsectionReader()
+{
+ if (deleteSourceWhenDeleted)
+ delete source;
+}
+
+bool AudioSubsectionReader::read (int** destSamples,
+ int64 startSampleInFile,
+ int numSamples)
+{
+ if (startSampleInFile < 0 || startSampleInFile + numSamples > length)
+ {
+ int** d = destSamples;
+ while (*d != 0)
+ {
+ zeromem (*d, sizeof (int) * numSamples);
+ ++d;
+ }
+
+ startSampleInFile = jmax ((int64) 0, startSampleInFile);
+ numSamples = jmax (0, jmin (numSamples, (int) (length - startSampleInFile)));
+ }
+
+ return source->read (destSamples,
+ startSampleInFile + startSample,
+ numSamples);
+}
+
+void AudioSubsectionReader::readMaxLevels (int64 startSampleInFile,
+ int64 numSamples,
+ float& lowestLeft,
+ float& highestLeft,
+ float& lowestRight,
+ float& highestRight)
+{
+ startSampleInFile = jmax ((int64) 0, startSampleInFile);
+ numSamples = jmax ((int64) 0, jmin (numSamples, length - startSampleInFile));
+
+ source->readMaxLevels (startSampleInFile + startSample,
+ numSamples,
+ lowestLeft,
+ highestLeft,
+ lowestRight,
+ highestRight);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_AudioSubsectionReader.cpp *********/
+
+/********* Start of inlined file: juce_AudioThumbnail.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+const int timeBeforeDeletingReader = 2000;
+
+struct AudioThumbnailDataFormat
+{
+ char thumbnailMagic[4];
+ int samplesPerThumbSample;
+ int64 totalSamples; // source samples
+ int64 numFinishedSamples; // source samples
+ int numThumbnailSamples;
+ int numChannels;
+ int sampleRate;
+ char future[16];
+ char data[1];
+};
+
+#if JUCE_BIG_ENDIAN
+ static void swap (int& n) { n = (int) swapByteOrder ((uint32) n); }
+ static void swap (int64& n) { n = (int64) swapByteOrder ((uint64) n); }
+#endif
+
+static void swapEndiannessIfNeeded (AudioThumbnailDataFormat* const d)
+{
+ (void) d;
+
+#if JUCE_BIG_ENDIAN
+ swap (d->samplesPerThumbSample);
+ swap (d->totalSamples);
+ swap (d->numFinishedSamples);
+ swap (d->numThumbnailSamples);
+ swap (d->numChannels);
+ swap (d->sampleRate);
+#endif
+}
+
+AudioThumbnail::AudioThumbnail (const int orginalSamplesPerThumbnailSample_,
+ AudioFormatManager& formatManagerToUse_,
+ AudioThumbnailCache& cacheToUse)
+ : formatManagerToUse (formatManagerToUse_),
+ cache (cacheToUse),
+ source (0),
+ reader (0),
+ orginalSamplesPerThumbnailSample (orginalSamplesPerThumbnailSample_)
+{
+ clear();
+}
+
+AudioThumbnail::~AudioThumbnail()
+{
+ cache.removeThumbnail (this);
+
+ const ScopedLock sl (readerLock);
+ deleteAndZero (reader);
+
+ delete source;
+}
+
+void AudioThumbnail::setSource (InputSource* const newSource)
+{
+ cache.removeThumbnail (this);
+ timerCallback(); // stops the timer and deletes the reader
+
+ delete source;
+ source = newSource;
+
+ clear();
+
+ if (! (cache.loadThumb (*this, newSource->hashCode())
+ && isFullyLoaded()))
+ {
+ {
+ const ScopedLock sl (readerLock);
+ reader = createReader();
+ }
+
+ if (reader != 0)
+ {
+ initialiseFromAudioFile (*reader);
+ cache.addThumbnail (this);
+ }
+ }
+
+ sendChangeMessage (this);
+}
+
+bool AudioThumbnail::useTimeSlice()
+{
+ const ScopedLock sl (readerLock);
+
+ if (isFullyLoaded())
+ {
+ if (reader != 0)
+ startTimer (timeBeforeDeletingReader);
+
+ cache.removeThumbnail (this);
+ return false;
+ }
+
+ if (reader == 0)
+ reader = createReader();
+
+ if (reader != 0)
+ {
+ readNextBlockFromAudioFile (*reader);
+ stopTimer();
+
+ sendChangeMessage (this);
+
+ const bool justFinished = isFullyLoaded();
+
+ if (justFinished)
+ cache.storeThumb (*this, source->hashCode());
+
+ return ! justFinished;
+ }
+
+ return false;
+}
+
+AudioFormatReader* AudioThumbnail::createReader() const
+{
+ if (source != 0)
+ {
+ InputStream* const audioFileStream = source->createInputStream();
+
+ if (audioFileStream != 0)
+ return formatManagerToUse.createReaderFor (audioFileStream);
+ }
+
+ return 0;
+}
+
+void AudioThumbnail::timerCallback()
+{
+ stopTimer();
+
+ const ScopedLock sl (readerLock);
+ deleteAndZero (reader);
+}
+
+void AudioThumbnail::clear()
+{
+ data.setSize (sizeof (AudioThumbnailDataFormat) + 3);
+
+ AudioThumbnailDataFormat* const d = (AudioThumbnailDataFormat*) data.getData();
+
+ d->thumbnailMagic[0] = 'j';
+ d->thumbnailMagic[1] = 'a';
+ d->thumbnailMagic[2] = 't';
+ d->thumbnailMagic[3] = 'm';
+
+ d->samplesPerThumbSample = orginalSamplesPerThumbnailSample;
+ d->totalSamples = 0;
+ d->numFinishedSamples = 0;
+ d->numThumbnailSamples = 0;
+ d->numChannels = 0;
+ d->sampleRate = 0;
+
+ numSamplesCached = 0;
+ cacheNeedsRefilling = true;
+}
+
+void AudioThumbnail::loadFrom (InputStream& input)
+{
+ data.setSize (0);
+ input.readIntoMemoryBlock (data);
+
+ AudioThumbnailDataFormat* const d = (AudioThumbnailDataFormat*) data.getData();
+ swapEndiannessIfNeeded (d);
+
+ if (! (d->thumbnailMagic[0] == 'j'
+ && d->thumbnailMagic[1] == 'a'
+ && d->thumbnailMagic[2] == 't'
+ && d->thumbnailMagic[3] == 'm'))
+ {
+ clear();
+ }
+
+ numSamplesCached = 0;
+ cacheNeedsRefilling = true;
+}
+
+void AudioThumbnail::saveTo (OutputStream& output) const
+{
+ AudioThumbnailDataFormat* const d = (AudioThumbnailDataFormat*) data.getData();
+ swapEndiannessIfNeeded (d);
+ output.write (data.getData(), data.getSize());
+ swapEndiannessIfNeeded (d);
+}
+
+bool AudioThumbnail::initialiseFromAudioFile (AudioFormatReader& reader)
+{
+ AudioThumbnailDataFormat* d = (AudioThumbnailDataFormat*) data.getData();
+
+ d->totalSamples = reader.lengthInSamples;
+ d->numChannels = jmin (2, reader.numChannels);
+ d->numFinishedSamples = 0;
+ d->sampleRate = roundDoubleToInt (reader.sampleRate);
+ d->numThumbnailSamples = (int) (d->totalSamples / d->samplesPerThumbSample) + 1;
+
+ data.setSize (sizeof (AudioThumbnailDataFormat) + 3 + d->numThumbnailSamples * d->numChannels * 2);
+
+ d = (AudioThumbnailDataFormat*) data.getData();
+ zeromem (&(d->data[0]), d->numThumbnailSamples * d->numChannels * 2);
+
+ return d->totalSamples > 0;
+}
+
+bool AudioThumbnail::readNextBlockFromAudioFile (AudioFormatReader& reader)
+{
+ AudioThumbnailDataFormat* const d = (AudioThumbnailDataFormat*) data.getData();
+
+ if (d->numFinishedSamples < d->totalSamples)
+ {
+ const int numToDo = (int) jmin ((int64) 65536, d->totalSamples - d->numFinishedSamples);
+
+ generateSection (reader,
+ d->numFinishedSamples,
+ numToDo);
+
+ d->numFinishedSamples += numToDo;
+ }
+
+ cacheNeedsRefilling = true;
+ return (d->numFinishedSamples < d->totalSamples);
+}
+
+int AudioThumbnail::getNumChannels() const throw()
+{
+ const AudioThumbnailDataFormat* const d = (const AudioThumbnailDataFormat*) data.getData();
+ jassert (d != 0);
+
+ return d->numChannels;
+}
+
+double AudioThumbnail::getTotalLength() const throw()
+{
+ const AudioThumbnailDataFormat* const d = (const AudioThumbnailDataFormat*) data.getData();
+ jassert (d != 0);
+
+ if (d->sampleRate > 0)
+ return d->totalSamples / (double)d->sampleRate;
+ else
+ return 0.0;
+}
+
+void AudioThumbnail::generateSection (AudioFormatReader& reader,
+ int64 startSample,
+ int numSamples)
+{
+ AudioThumbnailDataFormat* const d = (AudioThumbnailDataFormat*) data.getData();
+ jassert (d != 0);
+
+ int firstDataPos = (int) (startSample / d->samplesPerThumbSample);
+ int lastDataPos = (int) ((startSample + numSamples) / d->samplesPerThumbSample);
+
+ char* l = getChannelData (0);
+ char* r = getChannelData (1);
+
+ for (int i = firstDataPos; i < lastDataPos; ++i)
+ {
+ const int sourceStart = i * d->samplesPerThumbSample;
+ const int sourceEnd = sourceStart + d->samplesPerThumbSample;
+
+ float lowestLeft, highestLeft, lowestRight, highestRight;
+
+ reader.readMaxLevels (sourceStart,
+ sourceEnd - sourceStart,
+ lowestLeft,
+ highestLeft,
+ lowestRight,
+ highestRight);
+
+ int n = i * 2;
+
+ if (r != 0)
+ {
+ l [n] = (char) jlimit (-128.0f, 127.0f, lowestLeft * 127.0f);
+ r [n++] = (char) jlimit (-128.0f, 127.0f, lowestRight * 127.0f);
+ l [n] = (char) jlimit (-128.0f, 127.0f, highestLeft * 127.0f);
+ r [n++] = (char) jlimit (-128.0f, 127.0f, highestRight * 127.0f);
+ }
+ else
+ {
+ l [n++] = (char) jlimit (-128.0f, 127.0f, lowestLeft * 127.0f);
+ l [n++] = (char) jlimit (-128.0f, 127.0f, highestLeft * 127.0f);
+ }
+ }
+}
+
+char* AudioThumbnail::getChannelData (int channel) const
+{
+ AudioThumbnailDataFormat* const d = (AudioThumbnailDataFormat*) data.getData();
+ jassert (d != 0);
+
+ if (channel >= 0 && channel < d->numChannels)
+ return d->data + (channel * 2 * d->numThumbnailSamples);
+
+ return 0;
+}
+
+bool AudioThumbnail::isFullyLoaded() const throw()
+{
+ const AudioThumbnailDataFormat* const d = (const AudioThumbnailDataFormat*) data.getData();
+ jassert (d != 0);
+
+ return d->numFinishedSamples >= d->totalSamples;
+}
+
+void AudioThumbnail::refillCache (const int numSamples,
+ double startTime,
+ const double timePerPixel)
+{
+ const AudioThumbnailDataFormat* const d = (const AudioThumbnailDataFormat*) data.getData();
+ jassert (d != 0);
+
+ if (numSamples <= 0
+ || timePerPixel <= 0.0
+ || d->sampleRate <= 0)
+ {
+ numSamplesCached = 0;
+ cacheNeedsRefilling = true;
+ return;
+ }
+
+ if (numSamples == numSamplesCached
+ && numChannelsCached == d->numChannels
+ && startTime == cachedStart
+ && timePerPixel == cachedTimePerPixel
+ && ! cacheNeedsRefilling)
+ {
+ return;
+ }
+
+ numSamplesCached = numSamples;
+ numChannelsCached = d->numChannels;
+ cachedStart = startTime;
+ cachedTimePerPixel = timePerPixel;
+
+ cachedLevels.ensureSize (2 * numChannelsCached * numSamples);
+
+ const bool needExtraDetail = (timePerPixel * d->sampleRate <= d->samplesPerThumbSample);
+
+ const ScopedLock sl (readerLock);
+
+ cacheNeedsRefilling = false;
+
+ if (needExtraDetail && reader == 0)
+ reader = createReader();
+
+ if (reader != 0 && timePerPixel * d->sampleRate <= d->samplesPerThumbSample)
+ {
+ startTimer (timeBeforeDeletingReader);
+
+ char* cacheData = (char*) cachedLevels.getData();
+ int sample = roundDoubleToInt (startTime * d->sampleRate);
+
+ for (int i = numSamples; --i >= 0;)
+ {
+ const int nextSample = roundDoubleToInt ((startTime + timePerPixel) * d->sampleRate);
+
+ if (sample >= 0)
+ {
+ if (sample >= reader->lengthInSamples)
+ break;
+
+ float lmin, lmax, rmin, rmax;
+
+ reader->readMaxLevels (sample,
+ jmax (1, nextSample - sample),
+ lmin, lmax, rmin, rmax);
+
+ cacheData[0] = (char) jlimit (-128, 127, roundFloatToInt (lmin * 127.0f));
+ cacheData[1] = (char) jlimit (-128, 127, roundFloatToInt (lmax * 127.0f));
+
+ if (numChannelsCached > 1)
+ {
+ cacheData[2] = (char) jlimit (-128, 127, roundFloatToInt (rmin * 127.0f));
+ cacheData[3] = (char) jlimit (-128, 127, roundFloatToInt (rmax * 127.0f));
+ }
+
+ cacheData += 2 * numChannelsCached;
+ }
+
+ startTime += timePerPixel;
+ sample = nextSample;
+ }
+ }
+ else
+ {
+ for (int channelNum = 0; channelNum < numChannelsCached; ++channelNum)
+ {
+ char* const data = getChannelData (channelNum);
+ char* cacheData = ((char*) cachedLevels.getData()) + channelNum * 2;
+
+ const double timeToThumbSampleFactor = d->sampleRate / (double) d->samplesPerThumbSample;
+
+ startTime = cachedStart;
+ int sample = roundDoubleToInt (startTime * timeToThumbSampleFactor);
+ const int numFinished = (int) (d->numFinishedSamples / d->samplesPerThumbSample);
+
+ for (int i = numSamples; --i >= 0;)
+ {
+ const int nextSample = roundDoubleToInt ((startTime + timePerPixel) * timeToThumbSampleFactor);
+
+ if (sample >= 0 && data != 0)
+ {
+ char mx = -128;
+ char mn = 127;
+
+ while (sample <= nextSample)
+ {
+ if (sample >= numFinished)
+ break;
+
+ const int n = sample << 1;
+ const char sampMin = data [n];
+ const char sampMax = data [n + 1];
+
+ if (sampMin < mn)
+ mn = sampMin;
+
+ if (sampMax > mx)
+ mx = sampMax;
+
+ ++sample;
+ }
+
+ if (mn <= mx)
+ {
+ cacheData[0] = mn;
+ cacheData[1] = mx;
+ }
+ else
+ {
+ cacheData[0] = 1;
+ cacheData[1] = 0;
+ }
+ }
+ else
+ {
+ cacheData[0] = 1;
+ cacheData[1] = 0;
+ }
+
+ cacheData += numChannelsCached * 2;
+ startTime += timePerPixel;
+ sample = nextSample;
+ }
+ }
+ }
+}
+
+void AudioThumbnail::drawChannel (Graphics& g,
+ int x, int y, int w, int h,
+ double startTime,
+ double endTime,
+ int channelNum,
+ const float verticalZoomFactor)
+{
+ refillCache (w, startTime, (endTime - startTime) / w);
+
+ if (numSamplesCached >= w
+ && channelNum >= 0
+ && channelNum < numChannelsCached)
+ {
+ const float topY = (float) y;
+ const float bottomY = topY + h;
+ const float midY = topY + h * 0.5f;
+ const float vscale = verticalZoomFactor * h / 256.0f;
+
+ const Rectangle clip (g.getClipBounds());
+ const int skipLeft = clip.getX() - x;
+ w -= skipLeft;
+ x += skipLeft;
+
+ const char* cacheData = ((const char*) cachedLevels.getData())
+ + (channelNum << 1)
+ + skipLeft * (numChannelsCached << 1);
+
+ while (--w >= 0)
+ {
+ const char mn = cacheData[0];
+ const char mx = cacheData[1];
+ cacheData += numChannelsCached << 1;
+
+ if (mn <= mx) // if the wrong way round, signifies that the sample's not yet known
+ g.drawLine ((float) x, jmax (midY - mx * vscale - 0.3f, topY),
+ (float) x, jmin (midY - mn * vscale + 0.3f, bottomY));
+
+ ++x;
+
+ if (x >= clip.getRight())
+ break;
+ }
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_AudioThumbnail.cpp *********/
+
+/********* Start of inlined file: juce_AudioThumbnailCache.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+struct ThumbnailCacheEntry
+{
+ int64 hash;
+ uint32 lastUsed;
+ MemoryBlock data;
+
+ juce_UseDebuggingNewOperator
+};
+
+AudioThumbnailCache::AudioThumbnailCache (const int maxNumThumbsToStore_)
+ : TimeSliceThread (T("thumb cache")),
+ maxNumThumbsToStore (maxNumThumbsToStore_)
+{
+ startThread (2);
+}
+
+AudioThumbnailCache::~AudioThumbnailCache()
+{
+}
+
+bool AudioThumbnailCache::loadThumb (AudioThumbnail& thumb, const int64 hashCode)
+{
+ for (int i = thumbs.size(); --i >= 0;)
+ {
+ if (thumbs[i]->hash == hashCode)
+ {
+ MemoryInputStream in ((const char*) thumbs[i]->data.getData(),
+ thumbs[i]->data.getSize(),
+ false);
+
+ thumb.loadFrom (in);
+
+ thumbs[i]->lastUsed = Time::getMillisecondCounter();
+ return true;
+ }
+ }
+
+ return false;
+}
+
+void AudioThumbnailCache::storeThumb (const AudioThumbnail& thumb,
+ const int64 hashCode)
+{
+ MemoryOutputStream out;
+ thumb.saveTo (out);
+
+ ThumbnailCacheEntry* te = 0;
+
+ for (int i = thumbs.size(); --i >= 0;)
+ {
+ if (thumbs[i]->hash == hashCode)
+ {
+ te = thumbs[i];
+ break;
+ }
+ }
+
+ if (te == 0)
+ {
+ te = new ThumbnailCacheEntry();
+ te->hash = hashCode;
+
+ if (thumbs.size() < maxNumThumbsToStore)
+ {
+ thumbs.add (te);
+ }
+ else
+ {
+ int oldest = 0;
+ unsigned int oldestTime = Time::getMillisecondCounter() + 1;
+
+ int i;
+ for (i = thumbs.size(); --i >= 0;)
+ if (thumbs[i]->lastUsed < oldestTime)
+ oldest = i;
+
+ thumbs.set (i, te);
+ }
+ }
+
+ te->lastUsed = Time::getMillisecondCounter();
+ te->data.setSize (0);
+ te->data.append (out.getData(), out.getDataSize());
+}
+
+void AudioThumbnailCache::clear()
+{
+ thumbs.clear();
+}
+
+void AudioThumbnailCache::addThumbnail (AudioThumbnail* const thumb)
+{
+ addTimeSliceClient (thumb);
+}
+
+void AudioThumbnailCache::removeThumbnail (AudioThumbnail* const thumb)
+{
+ removeTimeSliceClient (thumb);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_AudioThumbnailCache.cpp *********/
+
+/********* Start of inlined file: juce_QuickTimeAudioFormat.cpp *********/
+
+#if JUCE_QUICKTIME
+
+#if ! defined (_WIN32)
+ #include
+ #include
+ #include
+ #include
+ #include
+#else
+ #ifdef _MSC_VER
+ #pragma warning (push)
+ #pragma warning (disable : 4100)
+ #endif
+
+ /* If you've got an include error here, you probably need to install the QuickTime SDK and
+ add its header directory to your include path.
+
+ Alternatively, if you don't need any QuickTime services, just turn off the JUC_QUICKTIME
+ flag in juce_Config.h
+ */
+ #include
+ #include
+ #include
+ #include
+ #include
+
+ #ifdef _MSC_VER
+ #pragma warning (pop)
+ #endif
+#endif
+
+BEGIN_JUCE_NAMESPACE
+
+bool juce_OpenQuickTimeMovieFromStream (InputStream* input, Movie& movie, Handle& dataHandle);
+
+#define quickTimeFormatName TRANS("QuickTime file")
+static const tchar* const quickTimeExtensions[] = { T(".mov"), T(".mp3"), T(".mp4"), 0 };
+
+class QTAudioReader : public AudioFormatReader
+{
+public:
+ QTAudioReader (InputStream* const input_, const int trackNum_)
+ : AudioFormatReader (input_, quickTimeFormatName),
+ ok (false),
+ movie (0),
+ trackNum (trackNum_),
+ extractor (0),
+ lastSampleRead (0),
+ lastThreadId (0),
+ dataHandle (0)
+ {
+ bufferList = (AudioBufferList*) juce_calloc (256);
+
+#ifdef WIN32
+ if (InitializeQTML (0) != noErr)
+ return;
+#endif
+ if (EnterMovies() != noErr)
+ return;
+
+#if JUCE_MAC
+ EnterMoviesOnThread (0);
+#endif
+
+ bool opened = juce_OpenQuickTimeMovieFromStream (input_, movie, dataHandle);
+
+ if (! opened)
+ return;
+
+ {
+ const int numTracks = GetMovieTrackCount (movie);
+ int trackCount = 0;
+
+ for (int i = 1; i <= numTracks; ++i)
+ {
+ track = GetMovieIndTrack (movie, i);
+ media = GetTrackMedia (track);
+
+ OSType mediaType;
+ GetMediaHandlerDescription (media, &mediaType, 0, 0);
+
+ if (mediaType == SoundMediaType
+ && trackCount++ == trackNum_)
+ {
+ ok = true;
+ break;
+ }
+ }
+ }
+
+ if (! ok)
+ return;
+
+ ok = false;
+
+ lengthInSamples = GetMediaDecodeDuration (media);
+ usesFloatingPointData = false;
+
+ samplesPerFrame = (int) (GetMediaDecodeDuration (media) / GetMediaSampleCount (media));
+
+ trackUnitsPerFrame = GetMovieTimeScale (movie) * samplesPerFrame
+ / GetMediaTimeScale (media);
+
+ OSStatus err = MovieAudioExtractionBegin (movie, 0, &extractor);
+
+ unsigned long output_layout_size;
+ err = MovieAudioExtractionGetPropertyInfo (extractor,
+ kQTPropertyClass_MovieAudioExtraction_Audio,
+ kQTMovieAudioExtractionAudioPropertyID_AudioChannelLayout,
+ 0, &output_layout_size, 0);
+ if (err != noErr)
+ return;
+
+ AudioChannelLayout* const qt_audio_channel_layout
+ = (AudioChannelLayout*) juce_calloc (output_layout_size);
+
+ err = MovieAudioExtractionGetProperty (extractor,
+ kQTPropertyClass_MovieAudioExtraction_Audio,
+ kQTMovieAudioExtractionAudioPropertyID_AudioChannelLayout,
+ output_layout_size, qt_audio_channel_layout, 0);
+
+ qt_audio_channel_layout->mChannelLayoutTag = kAudioChannelLayoutTag_Stereo;
+
+ err = MovieAudioExtractionSetProperty (extractor,
+ kQTPropertyClass_MovieAudioExtraction_Audio,
+ kQTMovieAudioExtractionAudioPropertyID_AudioChannelLayout,
+ sizeof (qt_audio_channel_layout),
+ qt_audio_channel_layout);
+
+ juce_free (qt_audio_channel_layout);
+
+ err = MovieAudioExtractionGetProperty (extractor,
+ kQTPropertyClass_MovieAudioExtraction_Audio,
+ kQTMovieAudioExtractionAudioPropertyID_AudioStreamBasicDescription,
+ sizeof (inputStreamDesc),
+ &inputStreamDesc, 0);
+ if (err != noErr)
+ return;
+
+ inputStreamDesc.mFormatFlags = kAudioFormatFlagIsSignedInteger
+ | kAudioFormatFlagIsPacked
+ | kAudioFormatFlagsNativeEndian;
+ inputStreamDesc.mBitsPerChannel = sizeof (SInt16) * 8;
+ inputStreamDesc.mChannelsPerFrame = jmin (2, inputStreamDesc.mChannelsPerFrame);
+ inputStreamDesc.mBytesPerFrame = sizeof (SInt16) * inputStreamDesc.mChannelsPerFrame;
+ inputStreamDesc.mBytesPerPacket = inputStreamDesc.mBytesPerFrame;
+
+ err = MovieAudioExtractionSetProperty (extractor,
+ kQTPropertyClass_MovieAudioExtraction_Audio,
+ kQTMovieAudioExtractionAudioPropertyID_AudioStreamBasicDescription,
+ sizeof (inputStreamDesc),
+ &inputStreamDesc);
+ if (err != noErr)
+ return;
+
+ Boolean allChannelsDiscrete = false;
+ err = MovieAudioExtractionSetProperty (extractor,
+ kQTPropertyClass_MovieAudioExtraction_Movie,
+ kQTMovieAudioExtractionMoviePropertyID_AllChannelsDiscrete,
+ sizeof (allChannelsDiscrete),
+ &allChannelsDiscrete);
+
+ if (err != noErr)
+ return;
+
+ bufferList->mNumberBuffers = 1;
+ bufferList->mBuffers[0].mNumberChannels = inputStreamDesc.mChannelsPerFrame;
+ bufferList->mBuffers[0].mDataByteSize = (UInt32) (samplesPerFrame * inputStreamDesc.mBytesPerFrame) + 16;
+ bufferList->mBuffers[0].mData = malloc (bufferList->mBuffers[0].mDataByteSize);
+
+ sampleRate = inputStreamDesc.mSampleRate;
+ bitsPerSample = 16;
+ numChannels = inputStreamDesc.mChannelsPerFrame;
+
+ detachThread();
+ ok = true;
+ }
+
+ ~QTAudioReader()
+ {
+ if (dataHandle != 0)
+ DisposeHandle (dataHandle);
+
+ if (extractor != 0)
+ {
+ MovieAudioExtractionEnd (extractor);
+ extractor = 0;
+ }
+
+ checkThreadIsAttached();
+ DisposeMovie (movie);
+
+ juce_free (bufferList->mBuffers[0].mData);
+ juce_free (bufferList);
+ }
+
+ bool read (int** destSamples,
+ int64 startSample,
+ int numSamples)
+ {
+ checkThreadIsAttached();
+ int done = 0;
+
+ while (numSamples > 0)
+ {
+ if (! loadFrame ((int) startSample))
+ return false;
+
+ const int numToDo = jmin (numSamples, samplesPerFrame);
+
+ for (unsigned int j = 0; j < inputStreamDesc.mChannelsPerFrame; ++j)
+ {
+ if (destSamples[j] != 0)
+ {
+ const short* const src = ((const short*) bufferList->mBuffers[0].mData) + j;
+
+ for (int i = 0; i < numToDo; ++i)
+ destSamples[j][done + i] = src [i << 1] << 16;
+ }
+ }
+
+ done += numToDo;
+ startSample += numToDo;
+ numSamples -= numToDo;
+ }
+
+ detachThread();
+ return true;
+ }
+
+ bool loadFrame (const int sampleNum)
+ {
+ if (lastSampleRead != sampleNum)
+ {
+ TimeRecord time;
+ time.scale = (TimeScale) inputStreamDesc.mSampleRate;
+ time.base = 0;
+ time.value.hi = 0;
+ time.value.lo = (UInt32) sampleNum;
+
+ OSStatus err = MovieAudioExtractionSetProperty (extractor,
+ kQTPropertyClass_MovieAudioExtraction_Movie,
+ kQTMovieAudioExtractionMoviePropertyID_CurrentTime,
+ sizeof (time), &time);
+
+ if (err != noErr)
+ return false;
+ }
+
+ bufferList->mBuffers[0].mDataByteSize = inputStreamDesc.mBytesPerFrame * samplesPerFrame;
+
+ UInt32 outFlags = 0;
+ UInt32 actualNumSamples = samplesPerFrame;
+ OSStatus err = MovieAudioExtractionFillBuffer (extractor, &actualNumSamples,
+ bufferList, &outFlags);
+
+ lastSampleRead = sampleNum + samplesPerFrame;
+
+ return err == noErr;
+ }
+
+ juce_UseDebuggingNewOperator
+
+ bool ok;
+
+private:
+ Movie movie;
+ Media media;
+ Track track;
+ const int trackNum;
+ double trackUnitsPerFrame;
+ int samplesPerFrame;
+ int lastSampleRead, lastThreadId;
+ MovieAudioExtractionRef extractor;
+ AudioStreamBasicDescription inputStreamDesc;
+ AudioBufferList* bufferList;
+ Handle dataHandle;
+
+ /*OSErr readMovieStream (long offset, long size, void* dataPtr)
+ {
+ input->setPosition (offset);
+ input->read (dataPtr, size);
+ return noErr;
+ }
+
+ static OSErr readMovieStreamProc (long offset, long size, void* dataPtr, void* userRef)
+ {
+ return ((QTAudioReader*) userRef)->readMovieStream (offset, size, dataPtr);
+ }*/
+
+ void checkThreadIsAttached()
+ {
+#if JUCE_MAC
+ if (Thread::getCurrentThreadId() != lastThreadId)
+ EnterMoviesOnThread (0);
+ AttachMovieToCurrentThread (movie);
+#endif
+ }
+
+ void detachThread()
+ {
+#if JUCE_MAC
+ DetachMovieFromCurrentThread (movie);
+#endif
+ }
+};
+
+QuickTimeAudioFormat::QuickTimeAudioFormat()
+ : AudioFormat (quickTimeFormatName, (const tchar**) quickTimeExtensions)
+{
+}
+
+QuickTimeAudioFormat::~QuickTimeAudioFormat()
+{
+}
+
+const Array QuickTimeAudioFormat::getPossibleSampleRates()
+{
+ return Array();
+}
+
+const Array QuickTimeAudioFormat::getPossibleBitDepths()
+{
+ return Array();
+}
+
+bool QuickTimeAudioFormat::canDoStereo()
+{
+ return true;
+}
+
+bool QuickTimeAudioFormat::canDoMono()
+{
+ return true;
+}
+
+AudioFormatReader* QuickTimeAudioFormat::createReaderFor (InputStream* sourceStream,
+ const bool deleteStreamIfOpeningFails)
+{
+ QTAudioReader* r = new QTAudioReader (sourceStream, 0);
+
+ if (! r->ok)
+ {
+ if (! deleteStreamIfOpeningFails)
+ r->input = 0;
+
+ deleteAndZero (r);
+ }
+
+ return r;
+}
+
+AudioFormatWriter* QuickTimeAudioFormat::createWriterFor (OutputStream* /*streamToWriteTo*/,
+ double /*sampleRateToUse*/,
+ unsigned int /*numberOfChannels*/,
+ int /*bitsPerSample*/,
+ const StringPairArray& /*metadataValues*/,
+ int /*qualityOptionIndex*/)
+{
+ jassertfalse // not yet implemented!
+ return 0;
+}
+
+END_JUCE_NAMESPACE
+
+#endif
+/********* End of inlined file: juce_QuickTimeAudioFormat.cpp *********/
+
+/********* Start of inlined file: juce_WavAudioFormat.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+#define wavFormatName TRANS("WAV file")
+static const tchar* const wavExtensions[] = { T(".wav"), T(".bwf"), 0 };
+
+const tchar* const WavAudioFormat::bwavDescription = T("bwav description");
+const tchar* const WavAudioFormat::bwavOriginator = T("bwav originator");
+const tchar* const WavAudioFormat::bwavOriginatorRef = T("bwav originator ref");
+const tchar* const WavAudioFormat::bwavOriginationDate = T("bwav origination date");
+const tchar* const WavAudioFormat::bwavOriginationTime = T("bwav origination time");
+const tchar* const WavAudioFormat::bwavTimeReference = T("bwav time reference");
+const tchar* const WavAudioFormat::bwavCodingHistory = T("bwav coding history");
+
+const StringPairArray WavAudioFormat::createBWAVMetadata (const String& description,
+ const String& originator,
+ const String& originatorRef,
+ const Time& date,
+ const int64 timeReferenceSamples,
+ const String& codingHistory)
+{
+ StringPairArray m;
+
+ m.set (bwavDescription, description);
+ m.set (bwavOriginator, originator);
+ m.set (bwavOriginatorRef, originatorRef);
+ m.set (bwavOriginationDate, date.formatted (T("%Y-%m-%d")));
+ m.set (bwavOriginationTime, date.formatted (T("%H:%M:%S")));
+ m.set (bwavTimeReference, String (timeReferenceSamples));
+ m.set (bwavCodingHistory, codingHistory);
+
+ return m;
+}
+
+#if JUCE_MSVC
+ #pragma pack (push, 1)
+ #define PACKED
+#elif defined (JUCE_GCC)
+ #define PACKED __attribute__((packed))
+#else
+ #define PACKED
+#endif
+
+struct BWAVChunk
+{
+ char description [256];
+ char originator [32];
+ char originatorRef [32];
+ char originationDate [10];
+ char originationTime [8];
+ uint32 timeRefLow;
+ uint32 timeRefHigh;
+ uint16 version;
+ uint8 umid[64];
+ uint8 reserved[190];
+ char codingHistory[1];
+
+ void copyTo (StringPairArray& values) const
+ {
+ values.set (WavAudioFormat::bwavDescription, String (description, 256));
+ values.set (WavAudioFormat::bwavOriginator, String (originator, 32));
+ values.set (WavAudioFormat::bwavOriginatorRef, String (originatorRef, 32));
+ values.set (WavAudioFormat::bwavOriginationDate, String (originationDate, 10));
+ values.set (WavAudioFormat::bwavOriginationTime, String (originationTime, 8));
+
+ const uint32 timeLow = swapIfBigEndian (timeRefLow);
+ const uint32 timeHigh = swapIfBigEndian (timeRefHigh);
+ const int64 time = (((int64)timeHigh) << 32) + timeLow;
+
+ values.set (WavAudioFormat::bwavTimeReference, String (time));
+ values.set (WavAudioFormat::bwavCodingHistory, String (codingHistory));
+ }
+
+ static MemoryBlock createFrom (const StringPairArray& values)
+ {
+ const int sizeNeeded = sizeof (BWAVChunk) + values [WavAudioFormat::bwavCodingHistory].length();
+ MemoryBlock data ((sizeNeeded + 3) & ~3);
+ data.fillWith (0);
+
+ BWAVChunk* b = (BWAVChunk*) data.getData();
+
+ // although copyToBuffer may overrun by one byte, that's ok as long as these
+ // operations get done in the right order
+ values [WavAudioFormat::bwavDescription].copyToBuffer (b->description, 256);
+ values [WavAudioFormat::bwavOriginator].copyToBuffer (b->originator, 32);
+ values [WavAudioFormat::bwavOriginatorRef].copyToBuffer (b->originatorRef, 32);
+ values [WavAudioFormat::bwavOriginationDate].copyToBuffer (b->originationDate, 10);
+ values [WavAudioFormat::bwavOriginationTime].copyToBuffer (b->originationTime, 8);
+
+ const int64 time = values [WavAudioFormat::bwavTimeReference].getLargeIntValue();
+ b->timeRefLow = swapIfBigEndian ((uint32) (time & 0xffffffff));
+ b->timeRefHigh = swapIfBigEndian ((uint32) (time >> 32));
+
+ values [WavAudioFormat::bwavCodingHistory].copyToBuffer (b->codingHistory, 256 * 1024);
+
+ if (b->description[0] != 0
+ || b->originator[0] != 0
+ || b->originationDate[0] != 0
+ || b->originationTime[0] != 0
+ || b->codingHistory[0] != 0
+ || time != 0)
+ {
+ return data;
+ }
+
+ return MemoryBlock();
+ }
+
+} PACKED;
+
+#if JUCE_MSVC
+ #pragma pack (pop)
+#endif
+
+#undef PACKED
+
+#undef chunkName
+#define chunkName(a) ((int) littleEndianInt(a))
+
+class WavAudioFormatReader : public AudioFormatReader
+{
+ int bytesPerFrame;
+ int64 dataChunkStart, dataLength;
+
+ WavAudioFormatReader (const WavAudioFormatReader&);
+ const WavAudioFormatReader& operator= (const WavAudioFormatReader&);
+
+public:
+
+ WavAudioFormatReader (InputStream* const in)
+ : AudioFormatReader (in, wavFormatName),
+ dataLength (0)
+ {
+ if (input->readInt() == chunkName ("RIFF"))
+ {
+ const uint32 len = (uint32) input->readInt();
+ const int64 end = input->getPosition() + len;
+ bool hasGotType = false;
+ bool hasGotData = false;
+
+ if (input->readInt() == chunkName ("WAVE"))
+ {
+ while (input->getPosition() < end
+ && ! input->isExhausted())
+ {
+ const int chunkType = input->readInt();
+ uint32 length = (uint32) input->readInt();
+ const int64 chunkEnd = input->getPosition() + length + (length & 1);
+
+ if (chunkType == chunkName ("fmt "))
+ {
+ // read the format chunk
+ const short format = input->readShort();
+ const short numChans = input->readShort();
+ sampleRate = input->readInt();
+ const int bytesPerSec = input->readInt();
+
+ numChannels = numChans;
+ bytesPerFrame = bytesPerSec / (int)sampleRate;
+ bitsPerSample = 8 * bytesPerFrame / numChans;
+
+ if (format == 3)
+ usesFloatingPointData = true;
+ else if (format != 1)
+ bytesPerFrame = 0;
+
+ hasGotType = true;
+ }
+ else if (chunkType == chunkName ("data"))
+ {
+ // get the data chunk's position
+ dataLength = length;
+ dataChunkStart = input->getPosition();
+ lengthInSamples = (bytesPerFrame > 0) ? (dataLength / bytesPerFrame) : 0;
+
+ hasGotData = true;
+ }
+ else if (chunkType == chunkName ("bext"))
+ {
+ // Broadcast-wav extension chunk..
+ BWAVChunk* const bwav = (BWAVChunk*) juce_calloc (jmax (length + 1, (int) sizeof (BWAVChunk)));
+
+ if (bwav != 0)
+ {
+ input->read (bwav, length);
+ bwav->copyTo (metadataValues);
+ juce_free (bwav);
+ }
+ }
+ else if ((hasGotType && hasGotData) || chunkEnd <= input->getPosition())
+ {
+ break;
+ }
+
+ input->setPosition (chunkEnd);
+ }
+ }
+ }
+ }
+
+ ~WavAudioFormatReader()
+ {
+ }
+
+ bool read (int** destSamples,
+ int64 startSampleInFile,
+ int numSamples)
+ {
+ int64 start = startSampleInFile;
+ int startOffsetInDestBuffer = 0;
+
+ if (startSampleInFile < 0)
+ {
+ const int silence = (int) jmin (-startSampleInFile, (int64) numSamples);
+
+ int** destChan = destSamples;
+
+ for (int i = 2; --i >= 0;)
+ {
+ if (*destChan != 0)
+ {
+ zeromem (*destChan, sizeof (int) * silence);
+ ++destChan;
+ }
+ }
+
+ startOffsetInDestBuffer += silence;
+ numSamples -= silence;
+ start = 0;
+ }
+
+ const int numToDo = (int) jlimit ((int64) 0, (int64) numSamples, lengthInSamples - start);
+
+ if (numToDo > 0)
+ {
+ input->setPosition (dataChunkStart + start * bytesPerFrame);
+
+ int num = numToDo;
+ int* left = destSamples[0];
+ if (left != 0)
+ left += startOffsetInDestBuffer;
+
+ int* right = destSamples[1];
+ if (right != 0)
+ right += startOffsetInDestBuffer;
+
+ // (keep this a multiple of 3)
+ const int tempBufSize = 1440 * 4;
+ char tempBuffer [tempBufSize];
+
+ while (num > 0)
+ {
+ const int numThisTime = jmin (tempBufSize / bytesPerFrame, num);
+ const int bytesRead = input->read (tempBuffer, numThisTime * bytesPerFrame);
+
+ if (bytesRead < numThisTime * bytesPerFrame)
+ zeromem (tempBuffer + bytesRead, numThisTime * bytesPerFrame - bytesRead);
+
+ if (bitsPerSample == 16)
+ {
+ const short* src = (const short*) tempBuffer;
+
+ if (numChannels > 1)
+ {
+ if (left == 0)
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ ++src;
+ *right++ = (int) swapIfBigEndian ((unsigned short) *src++) << 16;
+ }
+ }
+ else if (right == 0)
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *left++ = (int) swapIfBigEndian ((unsigned short) *src++) << 16;
+ ++src;
+ }
+ }
+ else
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *left++ = (int) swapIfBigEndian ((unsigned short) *src++) << 16;
+ *right++ = (int) swapIfBigEndian ((unsigned short) *src++) << 16;
+ }
+ }
+ }
+ else
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *left++ = (int) swapIfBigEndian ((unsigned short) *src++) << 16;
+ }
+ }
+ }
+ else if (bitsPerSample == 24)
+ {
+ const char* src = (const char*) tempBuffer;
+
+ if (numChannels > 1)
+ {
+ if (left == 0)
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ src += 6;
+ *right++ = littleEndian24Bit (src) << 8;
+ }
+ }
+ else if (right == 0)
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *left++ = littleEndian24Bit (src) << 8;
+ src += 6;
+ }
+ }
+ else
+ {
+ for (int i = 0; i < numThisTime; ++i)
+ {
+ *left++ = littleEndian24Bit (src) << 8;
+ src += 3;
+ *right++ = littleEndian24Bit (src) << 8;
+ src += 3;
+ }
+ }
+ }
+ else
+ {
+ for (int i = 0; i < numThisTime; ++i)
+ {
+ *left++ = littleEndian24Bit (src) << 8;
+ src += 3;
+ }
+ }
+ }
+ else if (bitsPerSample == 32)
+ {
+ const unsigned int* src = (const unsigned int*) tempBuffer;
+ unsigned int* l = (unsigned int*) left;
+ unsigned int* r = (unsigned int*) right;
+
+ if (numChannels > 1)
+ {
+ if (l == 0)
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ ++src;
+ *r++ = swapIfBigEndian (*src++);
+ }
+ }
+ else if (r == 0)
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *l++ = swapIfBigEndian (*src++);
+ ++src;
+ }
+ }
+ else
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *l++ = swapIfBigEndian (*src++);
+ *r++ = swapIfBigEndian (*src++);
+ }
+ }
+ }
+ else
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *l++ = swapIfBigEndian (*src++);
+ }
+ }
+
+ left = (int*)l;
+ right = (int*)r;
+ }
+ else if (bitsPerSample == 8)
+ {
+ const unsigned char* src = (const unsigned char*) tempBuffer;
+
+ if (numChannels > 1)
+ {
+ if (left == 0)
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ ++src;
+ *right++ = ((int) *src++ - 128) << 24;
+ }
+ }
+ else if (right == 0)
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *left++ = ((int) *src++ - 128) << 24;
+ ++src;
+ }
+ }
+ else
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *left++ = ((int) *src++ - 128) << 24;
+ *right++ = ((int) *src++ - 128) << 24;
+ }
+ }
+ }
+ else
+ {
+ for (int i = numThisTime; --i >= 0;)
+ {
+ *left++ = ((int)*src++ - 128) << 24;
+ }
+ }
+ }
+
+ num -= numThisTime;
+ }
+ }
+
+ if (numToDo < numSamples)
+ {
+ int** destChan = destSamples;
+
+ while (*destChan != 0)
+ {
+ zeromem ((*destChan) + (startOffsetInDestBuffer + numToDo),
+ sizeof (int) * (numSamples - numToDo));
+ ++destChan;
+ }
+ }
+
+ return true;
+ }
+
+ juce_UseDebuggingNewOperator
+};
+
+class WavAudioFormatWriter : public AudioFormatWriter
+{
+ MemoryBlock tempBlock, bwavChunk;
+ uint32 lengthInSamples, bytesWritten;
+ int64 headerPosition;
+ bool writeFailed;
+
+ WavAudioFormatWriter (const WavAudioFormatWriter&);
+ const WavAudioFormatWriter& operator= (const WavAudioFormatWriter&);
+
+ void writeHeader()
+ {
+ const bool seekedOk = output->setPosition (headerPosition);
+ (void) seekedOk;
+
+ // if this fails, you've given it an output stream that can't seek! It needs
+ // to be able to seek back to write the header
+ jassert (seekedOk);
+
+ const int bytesPerFrame = numChannels * bitsPerSample / 8;
+ output->writeInt (chunkName ("RIFF"));
+ output->writeInt (lengthInSamples * bytesPerFrame
+ + ((bwavChunk.getSize() > 0) ? (44 + bwavChunk.getSize()) : 36));
+
+ output->writeInt (chunkName ("WAVE"));
+ output->writeInt (chunkName ("fmt "));
+ output->writeInt (16);
+ output->writeShort ((bitsPerSample < 32) ? (short) 1 /*WAVE_FORMAT_PCM*/
+ : (short) 3 /*WAVE_FORMAT_IEEE_FLOAT*/);
+ output->writeShort ((short) numChannels);
+ output->writeInt ((int) sampleRate);
+ output->writeInt (bytesPerFrame * (int) sampleRate);
+ output->writeShort ((short) bytesPerFrame);
+ output->writeShort ((short) bitsPerSample);
+
+ if (bwavChunk.getSize() > 0)
+ {
+ output->writeInt (chunkName ("bext"));
+ output->writeInt (bwavChunk.getSize());
+ output->write (bwavChunk.getData(), bwavChunk.getSize());
+ }
+
+ output->writeInt (chunkName ("data"));
+ output->writeInt (lengthInSamples * bytesPerFrame);
+
+ usesFloatingPointData = (bitsPerSample == 32);
+ }
+
+public:
+
+ WavAudioFormatWriter (OutputStream* const out,
+ const double sampleRate,
+ const unsigned int numChannels_,
+ const int bits,
+ const StringPairArray& metadataValues)
+ : AudioFormatWriter (out,
+ wavFormatName,
+ sampleRate,
+ numChannels_,
+ bits),
+ lengthInSamples (0),
+ bytesWritten (0),
+ writeFailed (false)
+ {
+ if (metadataValues.size() > 0)
+ bwavChunk = BWAVChunk::createFrom (metadataValues);
+
+ headerPosition = out->getPosition();
+ writeHeader();
+ }
+
+ ~WavAudioFormatWriter()
+ {
+ writeHeader();
+ }
+
+ bool write (const int** data, int numSamples)
+ {
+ if (writeFailed)
+ return false;
+
+ const int bytes = numChannels * numSamples * bitsPerSample / 8;
+ tempBlock.ensureSize (bytes, false);
+ char* buffer = (char*) tempBlock.getData();
+
+ const int* left = data[0];
+ const int* right = data[1];
+ if (right == 0)
+ right = left;
+
+ if (bitsPerSample == 16)
+ {
+ short* b = (short*) buffer;
+
+ if (numChannels > 1)
+ {
+ for (int i = numSamples; --i >= 0;)
+ {
+ *b++ = (short) swapIfBigEndian ((unsigned short) (*left++ >> 16));
+ *b++ = (short) swapIfBigEndian ((unsigned short) (*right++ >> 16));
+ }
+ }
+ else
+ {
+ for (int i = numSamples; --i >= 0;)
+ {
+ *b++ = (short) swapIfBigEndian ((unsigned short) (*left++ >> 16));
+ }
+ }
+ }
+ else if (bitsPerSample == 24)
+ {
+ char* b = (char*) buffer;
+
+ if (numChannels > 1)
+ {
+ for (int i = numSamples; --i >= 0;)
+ {
+ littleEndian24BitToChars ((*left++) >> 8, b);
+ b += 3;
+ littleEndian24BitToChars ((*right++) >> 8, b);
+ b += 3;
+ }
+ }
+ else
+ {
+ for (int i = numSamples; --i >= 0;)
+ {
+ littleEndian24BitToChars ((*left++) >> 8, b);
+ b += 3;
+ }
+ }
+ }
+ else if (bitsPerSample == 32)
+ {
+ unsigned int* b = (unsigned int*) buffer;
+
+ if (numChannels > 1)
+ {
+ for (int i = numSamples; --i >= 0;)
+ {
+ *b++ = swapIfBigEndian ((unsigned int) *left++);
+ *b++ = swapIfBigEndian ((unsigned int) *right++);
+ }
+ }
+ else
+ {
+ for (int i = numSamples; --i >= 0;)
+ {
+ *b++ = swapIfBigEndian ((unsigned int) *left++);
+ }
+ }
+ }
+ else if (bitsPerSample == 8)
+ {
+ unsigned char* b = (unsigned char*) buffer;
+
+ if (numChannels > 1)
+ {
+ for (int i = numSamples; --i >= 0;)
+ {
+ *b++ = (unsigned char) (128 + (*left++ >> 24));
+ *b++ = (unsigned char) (128 + (*right++ >> 24));
+ }
+ }
+ else
+ {
+ for (int i = numSamples; --i >= 0;)
+ {
+ *b++ = (unsigned char) (128 + (*left++ >> 24));
+ }
+ }
+ }
+
+ if (bytesWritten + bytes >= (uint32) 0xfff00000
+ || ! output->write (buffer, bytes))
+ {
+ // failed to write to disk, so let's try writing the header.
+ // If it's just run out of disk space, then if it does manage
+ // to write the header, we'll still have a useable file..
+ writeHeader();
+ writeFailed = true;
+ return false;
+ }
+ else
+ {
+ bytesWritten += bytes;
+ lengthInSamples += numSamples;
+
+ return true;
+ }
+ }
+
+ juce_UseDebuggingNewOperator
+};
+
+WavAudioFormat::WavAudioFormat()
+ : AudioFormat (wavFormatName, (const tchar**) wavExtensions)
+{
+}
+
+WavAudioFormat::~WavAudioFormat()
+{
+}
+
+const Array WavAudioFormat::getPossibleSampleRates()
+{
+ const int rates[] = { 22050, 32000, 44100, 48000, 88200, 96000, 176400, 192000, 0 };
+ return Array (rates);
+}
+
+const Array WavAudioFormat::getPossibleBitDepths()
+{
+ const int depths[] = { 8, 16, 24, 32, 0 };
+ return Array (depths);
+}
+
+bool WavAudioFormat::canDoStereo()
+{
+ return true;
+}
+
+bool WavAudioFormat::canDoMono()
+{
+ return true;
+}
+
+AudioFormatReader* WavAudioFormat::createReaderFor (InputStream* sourceStream,
+ const bool deleteStreamIfOpeningFails)
+{
+ WavAudioFormatReader* r = new WavAudioFormatReader (sourceStream);
+
+ if (r->sampleRate == 0)
+ {
+ if (! deleteStreamIfOpeningFails)
+ r->input = 0;
+
+ deleteAndZero (r);
+ }
+
+ return r;
+}
+
+AudioFormatWriter* WavAudioFormat::createWriterFor (OutputStream* out,
+ double sampleRate,
+ unsigned int numChannels,
+ int bitsPerSample,
+ const StringPairArray& metadataValues,
+ int /*qualityOptionIndex*/)
+{
+ if (getPossibleBitDepths().contains (bitsPerSample))
+ {
+ return new WavAudioFormatWriter (out,
+ sampleRate,
+ numChannels,
+ bitsPerSample,
+ metadataValues);
+ }
+
+ return 0;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_WavAudioFormat.cpp *********/
+
+/********* Start of inlined file: juce_AudioFormatReaderSource.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+AudioFormatReaderSource::AudioFormatReaderSource (AudioFormatReader* const reader_,
+ const bool deleteReaderWhenThisIsDeleted)
+ : reader (reader_),
+ deleteReader (deleteReaderWhenThisIsDeleted),
+ nextPlayPos (0),
+ looping (false)
+{
+ jassert (reader != 0);
+}
+
+AudioFormatReaderSource::~AudioFormatReaderSource()
+{
+ releaseResources();
+
+ if (deleteReader)
+ delete reader;
+}
+
+void AudioFormatReaderSource::setNextReadPosition (int newPosition)
+{
+ nextPlayPos = newPosition;
+}
+
+void AudioFormatReaderSource::setLooping (const bool shouldLoop) throw()
+{
+ looping = shouldLoop;
+}
+
+int AudioFormatReaderSource::getNextReadPosition() const
+{
+ return (looping) ? (nextPlayPos % (int) reader->lengthInSamples)
+ : nextPlayPos;
+}
+
+int AudioFormatReaderSource::getTotalLength() const
+{
+ return (int) reader->lengthInSamples;
+}
+
+void AudioFormatReaderSource::prepareToPlay (int /*samplesPerBlockExpected*/,
+ double /*sampleRate*/)
+{
+}
+
+void AudioFormatReaderSource::releaseResources()
+{
+}
+
+void AudioFormatReaderSource::getNextAudioBlock (const AudioSourceChannelInfo& info)
+{
+ if (info.numSamples > 0)
+ {
+ const int start = nextPlayPos;
+
+ if (looping)
+ {
+ const int newStart = start % (int) reader->lengthInSamples;
+ const int newEnd = (start + info.numSamples) % (int) reader->lengthInSamples;
+
+ if (newEnd > newStart)
+ {
+ info.buffer->readFromAudioReader (reader,
+ info.startSample,
+ newEnd - newStart,
+ newStart,
+ true, true);
+ }
+ else
+ {
+ const int endSamps = (int) reader->lengthInSamples - newStart;
+
+ info.buffer->readFromAudioReader (reader,
+ info.startSample,
+ endSamps,
+ newStart,
+ true, true);
+
+ info.buffer->readFromAudioReader (reader,
+ info.startSample + endSamps,
+ newEnd,
+ 0,
+ true, true);
+ }
+
+ nextPlayPos = newEnd;
+ }
+ else
+ {
+ info.buffer->readFromAudioReader (reader,
+ info.startSample,
+ info.numSamples,
+ start,
+ true, true);
+
+ nextPlayPos += info.numSamples;
+ }
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_AudioFormatReaderSource.cpp *********/
+
+/********* Start of inlined file: juce_AudioSourcePlayer.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+AudioSourcePlayer::AudioSourcePlayer()
+ : source (0),
+ sampleRate (0),
+ bufferSize (0),
+ tempBuffer (2, 8)
+{
+}
+
+AudioSourcePlayer::~AudioSourcePlayer()
+{
+ setSource (0);
+}
+
+void AudioSourcePlayer::setSource (AudioSource* newSource)
+{
+ if (source != newSource)
+ {
+ AudioSource* const oldSource = source;
+
+ if (newSource != 0 && bufferSize > 0 && sampleRate > 0)
+ newSource->prepareToPlay (bufferSize, sampleRate);
+
+ {
+ const ScopedLock sl (readLock);
+ source = newSource;
+ }
+
+ if (oldSource != 0)
+ oldSource->releaseResources();
+ }
+}
+
+void AudioSourcePlayer::audioDeviceIOCallback (const float** inputChannelData,
+ int totalNumInputChannels,
+ float** outputChannelData,
+ int totalNumOutputChannels,
+ int numSamples)
+{
+ // these should have been prepared by audioDeviceAboutToStart()...
+ jassert (sampleRate > 0 && bufferSize > 0);
+
+ const ScopedLock sl (readLock);
+
+ if (source != 0)
+ {
+ AudioSourceChannelInfo info;
+ int i, numActiveChans = 0, numInputs = 0, numOutputs = 0;
+
+ // messy stuff needed to compact the channels down into an array
+ // of non-zero pointers..
+ for (i = 0; i < totalNumInputChannels; ++i)
+ {
+ if (inputChannelData[i] != 0)
+ {
+ inputChans [numInputs++] = inputChannelData[i];
+ if (numInputs >= numElementsInArray (inputChans))
+ break;
+ }
+ }
+
+ for (i = 0; i < totalNumOutputChannels; ++i)
+ {
+ if (outputChannelData[i] != 0)
+ {
+ outputChans [numOutputs++] = outputChannelData[i];
+ if (numOutputs >= numElementsInArray (outputChans))
+ break;
+ }
+ }
+
+ if (numInputs > numOutputs)
+ {
+ // if there aren't enough output channels for the number of
+ // inputs, we need to create some temporary extra ones (can't
+ // use the input data in case it gets written to)
+ tempBuffer.setSize (numInputs - numOutputs, numSamples,
+ false, false, true);
+
+ for (i = 0; i < numOutputs; ++i)
+ {
+ channels[numActiveChans] = outputChans[i];
+ memcpy (channels[numActiveChans], inputChans[i], sizeof (float) * numSamples);
+ ++numActiveChans;
+ }
+
+ for (i = numOutputs; i < numInputs; ++i)
+ {
+ channels[numActiveChans] = tempBuffer.getSampleData (i - numOutputs, 0);
+ memcpy (channels[numActiveChans], inputChans[i], sizeof (float) * numSamples);
+ ++numActiveChans;
+ }
+ }
+ else
+ {
+ for (i = 0; i < numInputs; ++i)
+ {
+ channels[numActiveChans] = outputChans[i];
+ memcpy (channels[numActiveChans], inputChans[i], sizeof (float) * numSamples);
+ ++numActiveChans;
+ }
+
+ for (i = numInputs; i < numOutputs; ++i)
+ {
+ channels[numActiveChans] = outputChans[i];
+ zeromem (channels[numActiveChans], sizeof (float) * numSamples);
+ ++numActiveChans;
+ }
+ }
+
+ AudioSampleBuffer buffer (channels, numActiveChans, numSamples);
+
+ info.buffer = &buffer;
+ info.startSample = 0;
+ info.numSamples = numSamples;
+
+ source->getNextAudioBlock (info);
+ }
+ else
+ {
+ for (int i = 0; i < totalNumOutputChannels; ++i)
+ if (outputChannelData[i] != 0)
+ zeromem (outputChannelData[i], sizeof (float) * numSamples);
+ }
+}
+
+void AudioSourcePlayer::audioDeviceAboutToStart (AudioIODevice* device)
+{
+ sampleRate = device->getCurrentSampleRate();
+ bufferSize = device->getCurrentBufferSizeSamples();
+ zeromem (channels, sizeof (channels));
+
+ if (source != 0)
+ source->prepareToPlay (bufferSize, sampleRate);
+}
+
+void AudioSourcePlayer::audioDeviceStopped()
+{
+ if (source != 0)
+ source->releaseResources();
+
+ sampleRate = 0.0;
+ bufferSize = 0;
+
+ tempBuffer.setSize (2, 8);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_AudioSourcePlayer.cpp *********/
+
+/********* Start of inlined file: juce_AudioTransportSource.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+AudioTransportSource::AudioTransportSource()
+ : source (0),
+ resamplerSource (0),
+ bufferingSource (0),
+ positionableSource (0),
+ masterSource (0),
+ gain (1.0f),
+ lastGain (1.0f),
+ playing (false),
+ stopped (true),
+ sampleRate (44100.0),
+ sourceSampleRate (0.0),
+ blockSize (128),
+ readAheadBufferSize (0),
+ isPrepared (false),
+ inputStreamEOF (false)
+{
+}
+
+AudioTransportSource::~AudioTransportSource()
+{
+ setSource (0);
+
+ releaseResources();
+}
+
+void AudioTransportSource::setSource (PositionableAudioSource* const newSource,
+ int readAheadBufferSize_,
+ double sourceSampleRateToCorrectFor)
+{
+ if (source == newSource)
+ {
+ if (source == 0)
+ return;
+
+ setSource (0, 0, 0); // deselect and reselect to avoid releasing resources wrongly
+ }
+
+ readAheadBufferSize = readAheadBufferSize_;
+ sourceSampleRate = sourceSampleRateToCorrectFor;
+
+ ResamplingAudioSource* newResamplerSource = 0;
+ BufferingAudioSource* newBufferingSource = 0;
+ PositionableAudioSource* newPositionableSource = 0;
+ AudioSource* newMasterSource = 0;
+
+ ResamplingAudioSource* oldResamplerSource = resamplerSource;
+ BufferingAudioSource* oldBufferingSource = bufferingSource;
+ AudioSource* oldMasterSource = masterSource;
+
+ if (newSource != 0)
+ {
+ newPositionableSource = newSource;
+
+ if (readAheadBufferSize_ > 0)
+ newPositionableSource = newBufferingSource
+ = new BufferingAudioSource (newPositionableSource, false, readAheadBufferSize_);
+
+ newPositionableSource->setNextReadPosition (0);
+
+ if (sourceSampleRateToCorrectFor != 0)
+ newMasterSource = newResamplerSource
+ = new ResamplingAudioSource (newPositionableSource, false);
+ else
+ newMasterSource = newPositionableSource;
+
+ if (isPrepared)
+ {
+ if (newResamplerSource != 0 && sourceSampleRate > 0 && sampleRate > 0)
+ newResamplerSource->setResamplingRatio (sourceSampleRate / sampleRate);
+
+ newMasterSource->prepareToPlay (blockSize, sampleRate);
+ }
+ }
+
+ {
+ const ScopedLock sl (callbackLock);
+
+ source = newSource;
+ resamplerSource = newResamplerSource;
+ bufferingSource = newBufferingSource;
+ masterSource = newMasterSource;
+ positionableSource = newPositionableSource;
+
+ playing = false;
+ }
+
+ if (oldMasterSource != 0)
+ oldMasterSource->releaseResources();
+
+ if (oldResamplerSource != 0)
+ delete oldResamplerSource;
+
+ if (oldBufferingSource != 0)
+ delete oldBufferingSource;
+}
+
+void AudioTransportSource::start()
+{
+ if ((! playing) && masterSource != 0)
+ {
+ callbackLock.enter();
+ playing = true;
+ stopped = false;
+ inputStreamEOF = false;
+ callbackLock.exit();
+
+ sendChangeMessage (this);
+ }
+}
+
+void AudioTransportSource::stop()
+{
+ if (playing)
+ {
+ callbackLock.enter();
+ playing = false;
+ callbackLock.exit();
+
+ int n = 500;
+ while (--n >= 0 && ! stopped)
+ Thread::sleep (2);
+
+ sendChangeMessage (this);
+ }
+}
+
+void AudioTransportSource::setPosition (double newPosition)
+{
+ if (sampleRate > 0.0)
+ setNextReadPosition (roundDoubleToInt (newPosition * sampleRate));
+}
+
+double AudioTransportSource::getCurrentPosition() const
+{
+ if (sampleRate > 0.0)
+ return getNextReadPosition() / sampleRate;
+ else
+ return 0.0;
+}
+
+void AudioTransportSource::setNextReadPosition (int newPosition)
+{
+ if (positionableSource != 0)
+ {
+ if (sampleRate > 0 && sourceSampleRate > 0)
+ newPosition = roundDoubleToInt (newPosition * sourceSampleRate / sampleRate);
+
+ positionableSource->setNextReadPosition (newPosition);
+ }
+}
+
+int AudioTransportSource::getNextReadPosition() const
+{
+ if (positionableSource != 0)
+ {
+ const double ratio = (sampleRate > 0 && sourceSampleRate > 0) ? sampleRate / sourceSampleRate : 1.0;
+
+ return roundDoubleToInt (positionableSource->getNextReadPosition() * ratio);
+ }
+
+ return 0;
+}
+
+int AudioTransportSource::getTotalLength() const
+{
+ const ScopedLock sl (callbackLock);
+
+ if (positionableSource != 0)
+ {
+ const double ratio = (sampleRate > 0 && sourceSampleRate > 0) ? sampleRate / sourceSampleRate : 1.0;
+
+ return roundDoubleToInt (positionableSource->getTotalLength() * ratio);
+ }
+
+ return 0;
+}
+
+bool AudioTransportSource::isLooping() const
+{
+ const ScopedLock sl (callbackLock);
+
+ return positionableSource != 0
+ && positionableSource->isLooping();
+}
+
+void AudioTransportSource::setGain (const float newGain) throw()
+{
+ gain = newGain;
+}
+
+void AudioTransportSource::prepareToPlay (int samplesPerBlockExpected,
+ double sampleRate_)
+{
+ const ScopedLock sl (callbackLock);
+
+ sampleRate = sampleRate_;
+ blockSize = samplesPerBlockExpected;
+
+ if (masterSource != 0)
+ masterSource->prepareToPlay (samplesPerBlockExpected, sampleRate);
+
+ if (resamplerSource != 0 && sourceSampleRate != 0)
+ resamplerSource->setResamplingRatio (sourceSampleRate / sampleRate);
+
+ isPrepared = true;
+}
+
+void AudioTransportSource::releaseResources()
+{
+ const ScopedLock sl (callbackLock);
+
+ if (masterSource != 0)
+ masterSource->releaseResources();
+
+ isPrepared = false;
+}
+
+void AudioTransportSource::getNextAudioBlock (const AudioSourceChannelInfo& info)
+{
+ const ScopedLock sl (callbackLock);
+
+ inputStreamEOF = false;
+
+ if (masterSource != 0 && ! stopped)
+ {
+ masterSource->getNextAudioBlock (info);
+
+ if (! playing)
+ {
+ // just stopped playing, so fade out the last block..
+ for (int i = info.buffer->getNumChannels(); --i >= 0;)
+ info.buffer->applyGainRamp (i, info.startSample, jmin (256, info.numSamples), 1.0f, 0.0f);
+
+ if (info.numSamples > 256)
+ info.buffer->clear (info.startSample + 256, info.numSamples - 256);
+ }
+
+ if (positionableSource->getNextReadPosition() > positionableSource->getTotalLength() + 1
+ && ! positionableSource->isLooping())
+ {
+ playing = false;
+ inputStreamEOF = true;
+ sendChangeMessage (this);
+ }
+
+ stopped = ! playing;
+
+ for (int i = info.buffer->getNumChannels(); --i >= 0;)
+ {
+ info.buffer->applyGainRamp (i, info.startSample, info.numSamples,
+ lastGain, gain);
+ }
+ }
+ else
+ {
+ info.clearActiveBufferRegion();
+ stopped = true;
+ }
+
+ lastGain = gain;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_AudioTransportSource.cpp *********/
+
+/********* Start of inlined file: juce_BufferingAudioSource.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+class SharedBufferingAudioSourceThread : public DeletedAtShutdown,
+ public Thread,
+ private Timer
+{
+public:
+ SharedBufferingAudioSourceThread()
+ : Thread ("Audio Buffer"),
+ sources (8)
+ {
+ }
+
+ ~SharedBufferingAudioSourceThread()
+ {
+ stopThread (10000);
+ clearSingletonInstance();
+ }
+
+ juce_DeclareSingleton (SharedBufferingAudioSourceThread, false)
+
+ void addSource (BufferingAudioSource* source)
+ {
+ const ScopedLock sl (lock);
+
+ if (! sources.contains ((void*) source))
+ {
+ sources.add ((void*) source);
+ startThread();
+
+ stopTimer();
+ }
+
+ notify();
+ }
+
+ void removeSource (BufferingAudioSource* source)
+ {
+ const ScopedLock sl (lock);
+ sources.removeValue ((void*) source);
+
+ if (sources.size() == 0)
+ startTimer (5000);
+ }
+
+private:
+ VoidArray sources;
+ CriticalSection lock;
+
+ void run()
+ {
+ while (! threadShouldExit())
+ {
+ bool busy = false;
+
+ for (int i = sources.size(); --i >= 0;)
+ {
+ if (threadShouldExit())
+ return;
+
+ const ScopedLock sl (lock);
+
+ BufferingAudioSource* const b = (BufferingAudioSource*) sources[i];
+
+ if (b != 0 && b->readNextBufferChunk())
+ busy = true;
+ }
+
+ if (! busy)
+ wait (500);
+ }
+ }
+
+ void timerCallback()
+ {
+ stopTimer();
+
+ if (sources.size() == 0)
+ deleteInstance();
+ }
+
+ SharedBufferingAudioSourceThread (const SharedBufferingAudioSourceThread&);
+ const SharedBufferingAudioSourceThread& operator= (const SharedBufferingAudioSourceThread&);
+};
+
+juce_ImplementSingleton (SharedBufferingAudioSourceThread)
+
+BufferingAudioSource::BufferingAudioSource (PositionableAudioSource* source_,
+ const bool deleteSourceWhenDeleted_,
+ int numberOfSamplesToBuffer_)
+ : source (source_),
+ deleteSourceWhenDeleted (deleteSourceWhenDeleted_),
+ numberOfSamplesToBuffer (jmax (1024, numberOfSamplesToBuffer_)),
+ buffer (2, 0),
+ bufferValidStart (0),
+ bufferValidEnd (0),
+ nextPlayPos (0),
+ wasSourceLooping (false)
+{
+ jassert (source_ != 0);
+
+ jassert (numberOfSamplesToBuffer_ > 1024); // not much point using this class if you're
+ // not using a larger buffer..
+}
+
+BufferingAudioSource::~BufferingAudioSource()
+{
+ SharedBufferingAudioSourceThread* const thread = SharedBufferingAudioSourceThread::getInstanceWithoutCreating();
+
+ if (thread != 0)
+ thread->removeSource (this);
+
+ if (deleteSourceWhenDeleted)
+ delete source;
+}
+
+void BufferingAudioSource::prepareToPlay (int samplesPerBlockExpected, double sampleRate_)
+{
+ source->prepareToPlay (samplesPerBlockExpected, sampleRate_);
+
+ sampleRate = sampleRate_;
+
+ buffer.setSize (2, jmax (samplesPerBlockExpected * 2, numberOfSamplesToBuffer));
+ buffer.clear();
+
+ bufferValidStart = 0;
+ bufferValidEnd = 0;
+
+ SharedBufferingAudioSourceThread::getInstance()->addSource (this);
+
+ while (bufferValidEnd - bufferValidStart < jmin (((int) sampleRate_) / 4,
+ buffer.getNumSamples() / 2))
+ {
+ SharedBufferingAudioSourceThread::getInstance()->notify();
+ Thread::sleep (5);
+ }
+}
+
+void BufferingAudioSource::releaseResources()
+{
+ SharedBufferingAudioSourceThread* const thread = SharedBufferingAudioSourceThread::getInstanceWithoutCreating();
+
+ if (thread != 0)
+ thread->removeSource (this);
+
+ buffer.setSize (2, 0);
+ source->releaseResources();
+}
+
+void BufferingAudioSource::getNextAudioBlock (const AudioSourceChannelInfo& info)
+{
+ const ScopedLock sl (bufferStartPosLock);
+
+ const int validStart = jlimit (bufferValidStart, bufferValidEnd, nextPlayPos) - nextPlayPos;
+ const int validEnd = jlimit (bufferValidStart, bufferValidEnd, nextPlayPos + info.numSamples) - nextPlayPos;
+
+ if (validStart == validEnd)
+ {
+ // total cache miss
+ info.clearActiveBufferRegion();
+ }
+ else
+ {
+ if (validStart > 0)
+ info.buffer->clear (info.startSample, validStart); // partial cache miss at start
+
+ if (validEnd < info.numSamples)
+ info.buffer->clear (info.startSample + validEnd,
+ info.numSamples - validEnd); // partial cache miss at end
+
+ if (validStart < validEnd)
+ {
+ for (int chan = jmin (2, info.buffer->getNumChannels()); --chan >= 0;)
+ {
+ const int startBufferIndex = (validStart + nextPlayPos) % buffer.getNumSamples();
+ const int endBufferIndex = (validEnd + nextPlayPos) % buffer.getNumSamples();
+
+ if (startBufferIndex < endBufferIndex)
+ {
+ info.buffer->copyFrom (chan, info.startSample + validStart,
+ buffer,
+ chan, startBufferIndex,
+ validEnd - validStart);
+ }
+ else
+ {
+ const int initialSize = buffer.getNumSamples() - startBufferIndex;
+
+ info.buffer->copyFrom (chan, info.startSample + validStart,
+ buffer,
+ chan, startBufferIndex,
+ initialSize);
+
+ info.buffer->copyFrom (chan, info.startSample + validStart + initialSize,
+ buffer,
+ chan, 0,
+ (validEnd - validStart) - initialSize);
+ }
+ }
+ }
+
+ nextPlayPos += info.numSamples;
+ }
+
+ SharedBufferingAudioSourceThread* const thread = SharedBufferingAudioSourceThread::getInstanceWithoutCreating();
+
+ if (thread != 0)
+ thread->notify();
+}
+
+int BufferingAudioSource::getNextReadPosition() const
+{
+ return (source->isLooping() && nextPlayPos > 0)
+ ? nextPlayPos % source->getTotalLength()
+ : nextPlayPos;
+}
+
+void BufferingAudioSource::setNextReadPosition (int newPosition)
+{
+ const ScopedLock sl (bufferStartPosLock);
+
+ nextPlayPos = newPosition;
+
+ SharedBufferingAudioSourceThread* const thread = SharedBufferingAudioSourceThread::getInstanceWithoutCreating();
+
+ if (thread != 0)
+ thread->notify();
+}
+
+bool BufferingAudioSource::readNextBufferChunk()
+{
+ bufferStartPosLock.enter();
+
+ if (wasSourceLooping != isLooping())
+ {
+ wasSourceLooping = isLooping();
+ bufferValidStart = 0;
+ bufferValidEnd = 0;
+ }
+
+ int newBVS = jmax (0, nextPlayPos);
+ int newBVE = newBVS + buffer.getNumSamples() - 4;
+ int sectionToReadStart = 0;
+ int sectionToReadEnd = 0;
+
+ const int maxChunkSize = 2048;
+
+ if (newBVS < bufferValidStart || newBVS >= bufferValidEnd)
+ {
+ newBVE = jmin (newBVE, newBVS + maxChunkSize);
+
+ sectionToReadStart = newBVS;
+ sectionToReadEnd = newBVE;
+
+ bufferValidStart = 0;
+ bufferValidEnd = 0;
+ }
+ else if (abs (newBVS - bufferValidStart) > 512
+ || abs (newBVE - bufferValidEnd) > 512)
+ {
+ newBVE = jmin (newBVE, bufferValidEnd + maxChunkSize);
+
+ sectionToReadStart = bufferValidEnd;
+ sectionToReadEnd = newBVE;
+
+ bufferValidStart = newBVS;
+ bufferValidEnd = jmin (bufferValidEnd, newBVE);
+ }
+
+ bufferStartPosLock.exit();
+
+ if (sectionToReadStart != sectionToReadEnd)
+ {
+ const int bufferIndexStart = sectionToReadStart % buffer.getNumSamples();
+ const int bufferIndexEnd = sectionToReadEnd % buffer.getNumSamples();
+
+ if (bufferIndexStart < bufferIndexEnd)
+ {
+ readBufferSection (sectionToReadStart,
+ sectionToReadEnd - sectionToReadStart,
+ bufferIndexStart);
+ }
+ else
+ {
+ const int initialSize = buffer.getNumSamples() - bufferIndexStart;
+
+ readBufferSection (sectionToReadStart,
+ initialSize,
+ bufferIndexStart);
+
+ readBufferSection (sectionToReadStart + initialSize,
+ (sectionToReadEnd - sectionToReadStart) - initialSize,
+ 0);
+ }
+
+ const ScopedLock sl2 (bufferStartPosLock);
+
+ bufferValidStart = newBVS;
+ bufferValidEnd = newBVE;
+
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+}
+
+void BufferingAudioSource::readBufferSection (int start, int length, int bufferOffset)
+{
+ if (source->getNextReadPosition() != start)
+ source->setNextReadPosition (start);
+
+ AudioSourceChannelInfo info;
+ info.buffer = &buffer;
+ info.startSample = bufferOffset;
+ info.numSamples = length;
+
+ source->getNextAudioBlock (info);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_BufferingAudioSource.cpp *********/
+
+/********* Start of inlined file: juce_ChannelRemappingAudioSource.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ChannelRemappingAudioSource::ChannelRemappingAudioSource (AudioSource* const source_,
+ const bool deleteSourceWhenDeleted_)
+ : requiredNumberOfChannels (2),
+ source (source_),
+ deleteSourceWhenDeleted (deleteSourceWhenDeleted_),
+ buffer (2, 16)
+{
+ remappedInfo.buffer = &buffer;
+ remappedInfo.startSample = 0;
+}
+
+ChannelRemappingAudioSource::~ChannelRemappingAudioSource()
+{
+ if (deleteSourceWhenDeleted)
+ delete source;
+}
+
+void ChannelRemappingAudioSource::setNumberOfChannelsToProduce (const int requiredNumberOfChannels_) throw()
+{
+ const ScopedLock sl (lock);
+ requiredNumberOfChannels = requiredNumberOfChannels_;
+}
+
+void ChannelRemappingAudioSource::clearAllMappings() throw()
+{
+ const ScopedLock sl (lock);
+
+ remappedInputs.clear();
+ remappedOutputs.clear();
+}
+
+void ChannelRemappingAudioSource::setInputChannelMapping (const int destIndex, const int sourceIndex) throw()
+{
+ const ScopedLock sl (lock);
+
+ while (remappedInputs.size() < destIndex)
+ remappedInputs.add (-1);
+
+ remappedInputs.set (destIndex, sourceIndex);
+}
+
+void ChannelRemappingAudioSource::setOutputChannelMapping (const int sourceIndex, const int destIndex) throw()
+{
+ const ScopedLock sl (lock);
+
+ while (remappedOutputs.size() < sourceIndex)
+ remappedOutputs.add (-1);
+
+ remappedOutputs.set (sourceIndex, destIndex);
+}
+
+int ChannelRemappingAudioSource::getRemappedInputChannel (const int inputChannelIndex) const throw()
+{
+ const ScopedLock sl (lock);
+
+ if (inputChannelIndex >= 0 && inputChannelIndex < remappedInputs.size())
+ return remappedInputs.getUnchecked (inputChannelIndex);
+
+ return -1;
+}
+
+int ChannelRemappingAudioSource::getRemappedOutputChannel (const int outputChannelIndex) const throw()
+{
+ const ScopedLock sl (lock);
+
+ if (outputChannelIndex >= 0 && outputChannelIndex < remappedOutputs.size())
+ return remappedOutputs .getUnchecked (outputChannelIndex);
+
+ return -1;
+}
+
+void ChannelRemappingAudioSource::prepareToPlay (int samplesPerBlockExpected, double sampleRate)
+{
+ source->prepareToPlay (samplesPerBlockExpected, sampleRate);
+}
+
+void ChannelRemappingAudioSource::releaseResources()
+{
+ source->releaseResources();
+}
+
+void ChannelRemappingAudioSource::getNextAudioBlock (const AudioSourceChannelInfo& bufferToFill)
+{
+ const ScopedLock sl (lock);
+
+ buffer.setSize (requiredNumberOfChannels, bufferToFill.numSamples, false, false, true);
+
+ const int numChans = bufferToFill.buffer->getNumChannels();
+
+ int i;
+ for (i = 0; i < buffer.getNumChannels(); ++i)
+ {
+ const int remappedChan = getRemappedInputChannel (i);
+
+ if (remappedChan >= 0 && remappedChan < numChans)
+ {
+ buffer.copyFrom (i, 0, *bufferToFill.buffer,
+ remappedChan,
+ bufferToFill.startSample,
+ bufferToFill.numSamples);
+ }
+ else
+ {
+ buffer.clear (i, 0, bufferToFill.numSamples);
+ }
+ }
+
+ remappedInfo.numSamples = bufferToFill.numSamples;
+
+ source->getNextAudioBlock (remappedInfo);
+
+ bufferToFill.clearActiveBufferRegion();
+
+ for (i = 0; i < requiredNumberOfChannels; ++i)
+ {
+ const int remappedChan = getRemappedOutputChannel (i);
+
+ if (remappedChan >= 0 && remappedChan < numChans)
+ {
+ bufferToFill.buffer->addFrom (remappedChan, bufferToFill.startSample,
+ buffer, i, 0, bufferToFill.numSamples);
+
+ }
+ }
+}
+
+XmlElement* ChannelRemappingAudioSource::createXml() const throw()
+{
+ XmlElement* e = new XmlElement (T("MAPPINGS"));
+
+ String ins, outs;
+ int i;
+
+ const ScopedLock sl (lock);
+
+ for (i = 0; i < remappedInputs.size(); ++i)
+ ins << remappedInputs.getUnchecked(i) << T(' ');
+
+ for (i = 0; i < remappedOutputs.size(); ++i)
+ outs << remappedOutputs.getUnchecked(i) << T(' ');
+
+ e->setAttribute (T("inputs"), ins.trimEnd());
+ e->setAttribute (T("outputs"), outs.trimEnd());
+
+ return e;
+}
+
+void ChannelRemappingAudioSource::restoreFromXml (const XmlElement& e) throw()
+{
+ if (e.hasTagName (T("MAPPINGS")))
+ {
+ const ScopedLock sl (lock);
+
+ clearAllMappings();
+
+ StringArray ins, outs;
+ ins.addTokens (e.getStringAttribute (T("inputs")), false);
+ outs.addTokens (e.getStringAttribute (T("outputs")), false);
+
+ int i;
+ for (i = 0; i < ins.size(); ++i)
+ remappedInputs.add (ins[i].getIntValue());
+
+ for (i = 0; i < outs.size(); ++i)
+ remappedOutputs.add (outs[i].getIntValue());
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ChannelRemappingAudioSource.cpp *********/
+
+/********* Start of inlined file: juce_IIRFilterAudioSource.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+IIRFilterAudioSource::IIRFilterAudioSource (AudioSource* const inputSource,
+ const bool deleteInputWhenDeleted_)
+ : input (inputSource),
+ deleteInputWhenDeleted (deleteInputWhenDeleted_)
+{
+ jassert (inputSource != 0);
+
+ for (int i = 2; --i >= 0;)
+ iirFilters.add (new IIRFilter());
+}
+
+IIRFilterAudioSource::~IIRFilterAudioSource()
+{
+ if (deleteInputWhenDeleted)
+ delete input;
+}
+
+void IIRFilterAudioSource::setFilterParameters (const IIRFilter& newSettings)
+{
+ for (int i = iirFilters.size(); --i >= 0;)
+ iirFilters.getUnchecked(i)->copyCoefficientsFrom (newSettings);
+}
+
+void IIRFilterAudioSource::prepareToPlay (int samplesPerBlockExpected, double sampleRate)
+{
+ input->prepareToPlay (samplesPerBlockExpected, sampleRate);
+
+ for (int i = iirFilters.size(); --i >= 0;)
+ iirFilters.getUnchecked(i)->reset();
+}
+
+void IIRFilterAudioSource::releaseResources()
+{
+ input->releaseResources();
+}
+
+void IIRFilterAudioSource::getNextAudioBlock (const AudioSourceChannelInfo& bufferToFill)
+{
+ input->getNextAudioBlock (bufferToFill);
+
+ const int numChannels = bufferToFill.buffer->getNumChannels();
+
+ while (numChannels > iirFilters.size())
+ iirFilters.add (new IIRFilter (*iirFilters.getUnchecked (0)));
+
+ for (int i = 0; i < numChannels; ++i)
+ iirFilters.getUnchecked(i)
+ ->processSamples (bufferToFill.buffer->getSampleData (i, bufferToFill.startSample),
+ bufferToFill.numSamples);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_IIRFilterAudioSource.cpp *********/
+
+/********* Start of inlined file: juce_MixerAudioSource.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+MixerAudioSource::MixerAudioSource()
+ : tempBuffer (2, 0),
+ currentSampleRate (0.0),
+ bufferSizeExpected (0)
+{
+}
+
+MixerAudioSource::~MixerAudioSource()
+{
+ removeAllInputs();
+}
+
+void MixerAudioSource::addInputSource (AudioSource* input, const bool deleteWhenRemoved)
+{
+ if (input != 0 && ! inputs.contains (input))
+ {
+ lock.enter();
+ double localRate = currentSampleRate;
+ int localBufferSize = bufferSizeExpected;
+ lock.exit();
+
+ if (localRate != 0.0)
+ input->prepareToPlay (localBufferSize, localRate);
+
+ const ScopedLock sl (lock);
+
+ inputsToDelete.setBit (inputs.size(), deleteWhenRemoved);
+ inputs.add (input);
+ }
+}
+
+void MixerAudioSource::removeInputSource (AudioSource* input, const bool deleteInput)
+{
+ if (input != 0)
+ {
+ lock.enter();
+ const int index = inputs.indexOf ((void*) input);
+
+ if (index >= 0)
+ {
+ inputsToDelete.shiftBits (index, 1);
+ inputs.remove (index);
+ }
+
+ lock.exit();
+
+ if (index >= 0)
+ {
+ input->releaseResources();
+
+ if (deleteInput)
+ delete input;
+ }
+ }
+}
+
+void MixerAudioSource::removeAllInputs()
+{
+ lock.enter();
+ VoidArray inputsCopy (inputs);
+ BitArray inputsToDeleteCopy (inputsToDelete);
+ inputs.clear();
+ lock.exit();
+
+ for (int i = inputsCopy.size(); --i >= 0;)
+ if (inputsToDeleteCopy[i])
+ delete (AudioSource*) inputsCopy[i];
+}
+
+void MixerAudioSource::prepareToPlay (int samplesPerBlockExpected, double sampleRate)
+{
+ tempBuffer.setSize (2, samplesPerBlockExpected);
+
+ const ScopedLock sl (lock);
+
+ currentSampleRate = sampleRate;
+ bufferSizeExpected = samplesPerBlockExpected;
+
+ for (int i = inputs.size(); --i >= 0;)
+ ((AudioSource*) inputs.getUnchecked(i))->prepareToPlay (samplesPerBlockExpected,
+ sampleRate);
+}
+
+void MixerAudioSource::releaseResources()
+{
+ const ScopedLock sl (lock);
+
+ for (int i = inputs.size(); --i >= 0;)
+ ((AudioSource*) inputs.getUnchecked(i))->releaseResources();
+
+ tempBuffer.setSize (2, 0);
+
+ currentSampleRate = 0;
+ bufferSizeExpected = 0;
+}
+
+void MixerAudioSource::getNextAudioBlock (const AudioSourceChannelInfo& info)
+{
+ const ScopedLock sl (lock);
+
+ if (inputs.size() > 0)
+ {
+ ((AudioSource*) inputs.getUnchecked(0))->getNextAudioBlock (info);
+
+ if (inputs.size() > 1)
+ {
+ tempBuffer.setSize (jmax (1, info.buffer->getNumChannels()),
+ info.buffer->getNumSamples());
+
+ AudioSourceChannelInfo info2;
+ info2.buffer = &tempBuffer;
+ info2.numSamples = info.numSamples;
+ info2.startSample = 0;
+
+ for (int i = 1; i < inputs.size(); ++i)
+ {
+ ((AudioSource*) inputs.getUnchecked(i))->getNextAudioBlock (info2);
+
+ for (int chan = 0; chan < info.buffer->getNumChannels(); ++chan)
+ info.buffer->addFrom (chan, info.startSample, tempBuffer, chan, 0, info.numSamples);
+ }
+ }
+ }
+ else
+ {
+ info.clearActiveBufferRegion();
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_MixerAudioSource.cpp *********/
+
+/********* Start of inlined file: juce_ResamplingAudioSource.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ResamplingAudioSource::ResamplingAudioSource (AudioSource* const inputSource,
+ const bool deleteInputWhenDeleted_)
+ : input (inputSource),
+ deleteInputWhenDeleted (deleteInputWhenDeleted_),
+ ratio (1.0),
+ lastRatio (1.0),
+ buffer (2, 0),
+ sampsInBuffer (0)
+{
+ jassert (input != 0);
+}
+
+ResamplingAudioSource::~ResamplingAudioSource()
+{
+ if (deleteInputWhenDeleted)
+ delete input;
+}
+
+void ResamplingAudioSource::setResamplingRatio (const double samplesInPerOutputSample)
+{
+ jassert (samplesInPerOutputSample > 0);
+
+ const ScopedLock sl (ratioLock);
+ ratio = jmax (0.0, samplesInPerOutputSample);
+}
+
+void ResamplingAudioSource::prepareToPlay (int samplesPerBlockExpected,
+ double sampleRate)
+{
+ const ScopedLock sl (ratioLock);
+
+ input->prepareToPlay (samplesPerBlockExpected, sampleRate);
+
+ buffer.setSize (2, roundDoubleToInt (samplesPerBlockExpected * ratio) + 32);
+ buffer.clear();
+ sampsInBuffer = 0;
+ bufferPos = 0;
+ subSampleOffset = 0.0;
+
+ createLowPass (ratio);
+ resetFilters();
+}
+
+void ResamplingAudioSource::releaseResources()
+{
+ input->releaseResources();
+ buffer.setSize (2, 0);
+}
+
+void ResamplingAudioSource::getNextAudioBlock (const AudioSourceChannelInfo& info)
+{
+ const ScopedLock sl (ratioLock);
+
+ if (lastRatio != ratio)
+ {
+ createLowPass (ratio);
+ lastRatio = ratio;
+ }
+
+ const int sampsNeeded = roundDoubleToInt (info.numSamples * ratio) + 2;
+
+ int bufferSize = buffer.getNumSamples();
+
+ if (bufferSize < sampsNeeded + 8)
+ {
+ bufferPos %= bufferSize;
+ bufferSize = sampsNeeded + 32;
+ buffer.setSize (buffer.getNumChannels(), bufferSize, true, true);
+ }
+
+ bufferPos %= bufferSize;
+
+ int endOfBufferPos = bufferPos + sampsInBuffer;
+
+ while (sampsNeeded > sampsInBuffer)
+ {
+ endOfBufferPos %= bufferSize;
+
+ int numToDo = jmin (sampsNeeded - sampsInBuffer,
+ bufferSize - endOfBufferPos);
+
+ AudioSourceChannelInfo readInfo;
+ readInfo.buffer = &buffer;
+ readInfo.numSamples = numToDo;
+ readInfo.startSample = endOfBufferPos;
+
+ input->getNextAudioBlock (readInfo);
+
+ if (ratio > 1.0)
+ {
+ // for down-sampling, pre-apply the filter..
+
+ for (int i = jmin (2, info.buffer->getNumChannels()); --i >= 0;)
+ applyFilter (buffer.getSampleData (i, endOfBufferPos), numToDo, filterStates[i]);
+ }
+
+ sampsInBuffer += numToDo;
+ endOfBufferPos += numToDo;
+ }
+
+ float* dl = info.buffer->getSampleData (0, info.startSample);
+ float* dr = (info.buffer->getNumChannels() > 1) ? info.buffer->getSampleData (1, info.startSample) : 0;
+
+ const float* const bl = buffer.getSampleData (0, 0);
+ const float* const br = buffer.getSampleData (1, 0);
+
+ int nextPos = (bufferPos + 1) % bufferSize;
+
+ for (int m = info.numSamples; --m >= 0;)
+ {
+ const float alpha = (float) subSampleOffset;
+ const float invAlpha = 1.0f - alpha;
+
+ *dl++ = bl [bufferPos] * invAlpha + bl [nextPos] * alpha;
+
+ if (dr != 0)
+ *dr++ = br [bufferPos] * invAlpha + br [nextPos] * alpha;
+
+ subSampleOffset += ratio;
+
+ jassert (sampsInBuffer > 0);
+
+ while (subSampleOffset >= 1.0)
+ {
+ if (++bufferPos >= bufferSize)
+ bufferPos = 0;
+
+ --sampsInBuffer;
+
+ nextPos = (bufferPos + 1) % bufferSize;
+ subSampleOffset -= 1.0;
+ }
+ }
+
+ if (ratio < 1.0)
+ {
+ // for up-sampling, apply the filter after transposing..
+
+ for (int i = jmin (2, info.buffer->getNumChannels()); --i >= 0;)
+ applyFilter (info.buffer->getSampleData (i, info.startSample), info.numSamples, filterStates[i]);
+ }
+
+ jassert (sampsInBuffer >= 0);
+}
+
+void ResamplingAudioSource::createLowPass (const double ratio)
+{
+ const double proportionalRate = (ratio > 1.0) ? 0.5 / ratio
+ : 0.5 * ratio;
+
+ const double n = 1.0 / tan (double_Pi * jmax (0.001, proportionalRate));
+ const double nSquared = n * n;
+ const double c1 = 1.0 / (1.0 + sqrt (2.0) * n + nSquared);
+
+ setFilterCoefficients (c1,
+ c1 * 2.0f,
+ c1,
+ 1.0,
+ c1 * 2.0 * (1.0 - nSquared),
+ c1 * (1.0 - sqrt (2.0) * n + nSquared));
+}
+
+void ResamplingAudioSource::setFilterCoefficients (double c1, double c2, double c3, double c4, double c5, double c6)
+{
+ const double a = 1.0 / c4;
+
+ c1 *= a;
+ c2 *= a;
+ c3 *= a;
+ c5 *= a;
+ c6 *= a;
+
+ coefficients[0] = c1;
+ coefficients[1] = c2;
+ coefficients[2] = c3;
+ coefficients[3] = c4;
+ coefficients[4] = c5;
+ coefficients[5] = c6;
+}
+
+void ResamplingAudioSource::resetFilters()
+{
+ zeromem (filterStates, sizeof (filterStates));
+}
+
+void ResamplingAudioSource::applyFilter (float* samples, int num, FilterState& fs)
+{
+ while (--num >= 0)
+ {
+ const double in = *samples;
+
+ double out = coefficients[0] * in
+ + coefficients[1] * fs.x1
+ + coefficients[2] * fs.x2
+ - coefficients[4] * fs.y1
+ - coefficients[5] * fs.y2;
+
+#if JUCE_INTEL
+ if (! (out < -1.0e-8 || out > 1.0e-8))
+ out = 0;
+#endif
+
+ fs.x2 = fs.x1;
+ fs.x1 = in;
+ fs.y2 = fs.y1;
+ fs.y1 = out;
+
+ *samples++ = (float) out;
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ResamplingAudioSource.cpp *********/
+
+/********* Start of inlined file: juce_ToneGeneratorAudioSource.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ToneGeneratorAudioSource::ToneGeneratorAudioSource()
+ : frequency (1000.0),
+ sampleRate (44100.0),
+ currentPhase (0.0),
+ phasePerSample (0.0),
+ amplitude (0.5f)
+{
+}
+
+ToneGeneratorAudioSource::~ToneGeneratorAudioSource()
+{
+}
+
+void ToneGeneratorAudioSource::setAmplitude (const float newAmplitude)
+{
+ amplitude = newAmplitude;
+}
+
+void ToneGeneratorAudioSource::setFrequency (const double newFrequencyHz)
+{
+ frequency = newFrequencyHz;
+ phasePerSample = 0.0;
+}
+
+void ToneGeneratorAudioSource::prepareToPlay (int /*samplesPerBlockExpected*/,
+ double sampleRate_)
+{
+ currentPhase = 0.0;
+ phasePerSample = 0.0;
+ sampleRate = sampleRate_;
+}
+
+void ToneGeneratorAudioSource::releaseResources()
+{
+}
+
+void ToneGeneratorAudioSource::getNextAudioBlock (const AudioSourceChannelInfo& info)
+{
+ if (phasePerSample == 0.0)
+ phasePerSample = double_Pi * 2.0 / (sampleRate / frequency);
+
+ for (int i = 0; i < info.numSamples; ++i)
+ {
+ const float sample = amplitude * (float) sin (currentPhase);
+ currentPhase += phasePerSample;
+
+ for (int j = info.buffer->getNumChannels(); --j >= 0;)
+ *info.buffer->getSampleData (j, info.startSample + i) = sample;
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ToneGeneratorAudioSource.cpp *********/
+
+/********* Start of inlined file: juce_AudioDeviceManager.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+AudioDeviceManager::AudioDeviceManager()
+ : currentAudioDevice (0),
+ currentCallback (0),
+ numInputChansNeeded (0),
+ numOutputChansNeeded (2),
+ lastExplicitSettings (0),
+ listNeedsScanning (true),
+ useInputNames (false),
+ enabledMidiInputs (4),
+ midiCallbacks (4),
+ midiCallbackDevices (4),
+ defaultMidiOutput (0),
+ cpuUsageMs (0),
+ timeToCpuScale (0)
+{
+ callbackHandler.owner = this;
+
+ AudioIODeviceType::createDeviceTypes (availableDeviceTypes);
+}
+
+AudioDeviceManager::~AudioDeviceManager()
+{
+ stopDevice();
+ deleteAndZero (currentAudioDevice);
+ deleteAndZero (defaultMidiOutput);
+ delete lastExplicitSettings;
+}
+
+const String AudioDeviceManager::initialise (const int numInputChannelsNeeded,
+ const int numOutputChannelsNeeded,
+ const XmlElement* const e,
+ const bool selectDefaultDeviceOnFailure,
+ const String& preferredDefaultDeviceName)
+{
+ if (listNeedsScanning)
+ refreshDeviceList();
+
+ numInputChansNeeded = numInputChannelsNeeded;
+ numOutputChansNeeded = numOutputChannelsNeeded;
+
+ if (e != 0 && e->hasTagName (T("DEVICESETUP")))
+ {
+ lastExplicitSettings = new XmlElement (*e);
+
+ BitArray ins, outs;
+ ins.parseString (e->getStringAttribute (T("audioDeviceInChans"), T("11")), 2);
+ outs.parseString (e->getStringAttribute (T("audioDeviceOutChans"), T("11")), 2);
+
+ String error (setAudioDevice (e->getStringAttribute (T("audioDeviceName")),
+ e->getIntAttribute (T("audioDeviceBufferSize")),
+ e->getDoubleAttribute (T("audioDeviceRate")),
+ e->hasAttribute (T("audioDeviceInChans")) ? &ins : 0,
+ e->hasAttribute (T("audioDeviceOutChans")) ? &outs : 0,
+ true));
+
+ StringArray enabledMidiIns;
+ forEachXmlChildElementWithTagName (*e, c, T("MIDIINPUT"))
+ enabledMidiIns.add (c->getStringAttribute (T("name")));
+
+ const StringArray allMidiIns (MidiInput::getDevices());
+
+ for (int i = allMidiIns.size(); --i >= 0;)
+ setMidiInputEnabled (allMidiIns[i], enabledMidiIns.contains (allMidiIns[i]));
+
+ if (error.isNotEmpty() && selectDefaultDeviceOnFailure)
+ error = initialise (numInputChannelsNeeded, numOutputChannelsNeeded, 0,
+ false, preferredDefaultDeviceName);
+
+ setDefaultMidiOutput (e->getStringAttribute (T("defaultMidiOutput")));
+
+ return error;
+ }
+ else
+ {
+ setInputDeviceNamesUsed (numOutputChannelsNeeded == 0);
+
+ String defaultDevice;
+
+ if (preferredDefaultDeviceName.isNotEmpty())
+ {
+ for (int i = 0; i < availableDeviceTypes.size(); ++i)
+ {
+ const StringArray devs (availableDeviceTypes.getUnchecked(i)->getDeviceNames());
+
+ for (int j = 0; j < devs.size(); ++j)
+ {
+ if (devs[j].matchesWildcard (preferredDefaultDeviceName, true))
+ {
+ defaultDevice = devs[j];
+ break;
+ }
+ }
+ }
+ }
+
+ if (defaultDevice.isEmpty() && availableDeviceTypes [0] != 0)
+ defaultDevice = availableDeviceTypes[0]->getDefaultDeviceName (numOutputChannelsNeeded == 0,
+ numInputChannelsNeeded,
+ numOutputChannelsNeeded);
+
+ return setAudioDevice (defaultDevice, 0, 0, 0, 0, false);
+ }
+}
+
+XmlElement* AudioDeviceManager::createStateXml() const
+{
+ return lastExplicitSettings != 0 ? new XmlElement (*lastExplicitSettings) : 0;
+}
+
+const StringArray AudioDeviceManager::getAvailableAudioDeviceNames() const
+{
+ if (listNeedsScanning)
+ refreshDeviceList();
+
+ StringArray names;
+
+ for (int i = 0; i < availableDeviceTypes.size(); ++i)
+ names.addArray (availableDeviceTypes[i]->getDeviceNames (useInputNames));
+
+ return names;
+}
+
+void AudioDeviceManager::refreshDeviceList() const
+{
+ listNeedsScanning = false;
+
+ for (int i = 0; i < availableDeviceTypes.size(); ++i)
+ availableDeviceTypes[i]->scanForDevices();
+}
+
+void AudioDeviceManager::setInputDeviceNamesUsed (const bool useInputNames_)
+{
+ useInputNames = useInputNames_;
+ sendChangeMessage (this);
+}
+
+void AudioDeviceManager::addDeviceNamesToComboBox (ComboBox& combo) const
+{
+ int n = 0;
+
+ for (int i = 0; i < availableDeviceTypes.size(); ++i)
+ {
+ AudioIODeviceType* const type = availableDeviceTypes[i];
+
+ if (availableDeviceTypes.size() > 1)
+ combo.addSectionHeading (type->getTypeName() + T(" devices:"));
+
+ const StringArray names (type->getDeviceNames (useInputNames));
+
+ for (int j = 0; j < names.size(); ++j)
+ combo.addItem (names[j], ++n);
+
+ combo.addSeparator();
+ }
+
+ combo.addItem (TRANS("<< no audio device >>"), -1);
+}
+
+const String AudioDeviceManager::getCurrentAudioDeviceName() const
+{
+ if (currentAudioDevice != 0)
+ return currentAudioDevice->getName();
+
+ return String::empty;
+}
+
+const String AudioDeviceManager::setAudioDevice (const String& deviceNameToUse,
+ int blockSizeToUse,
+ double sampleRateToUse,
+ const BitArray* inChans,
+ const BitArray* outChans,
+ const bool treatAsChosenDevice)
+{
+ stopDevice();
+
+ String error;
+
+ if (deviceNameToUse.isNotEmpty())
+ {
+ const StringArray devNames (getAvailableAudioDeviceNames());
+
+ int index = devNames.indexOf (deviceNameToUse, true);
+
+ if (index >= 0)
+ {
+ if (currentAudioDevice == 0
+ || currentAudioDevice->getLastError().isNotEmpty()
+ || ! deviceNameToUse.equalsIgnoreCase (currentAudioDevice->getName()))
+ {
+ // change of device..
+ deleteAndZero (currentAudioDevice);
+
+ int n = 0;
+
+ for (int i = 0; i < availableDeviceTypes.size(); ++i)
+ {
+ AudioIODeviceType* const type = availableDeviceTypes[i];
+ const StringArray names (type->getDeviceNames (useInputNames));
+
+ if (index >= n && index < n + names.size())
+ {
+ currentAudioDevice = type->createDevice (deviceNameToUse);
+ break;
+ }
+
+ n += names.size();
+ }
+
+ error = currentAudioDevice->getLastError();
+
+ if (error.isNotEmpty())
+ {
+ deleteAndZero (currentAudioDevice);
+ return error;
+ }
+
+ inputChannels.clear();
+ inputChannels.setRange (0, numInputChansNeeded, true);
+ outputChannels.clear();
+ outputChannels.setRange (0, numOutputChansNeeded, true);
+ }
+
+ if (inChans != 0)
+ inputChannels = *inChans;
+
+ if (outChans != 0)
+ outputChannels = *outChans;
+
+ error = restartDevice (blockSizeToUse,
+ sampleRateToUse,
+ inputChannels,
+ outputChannels);
+
+ if (error.isNotEmpty())
+ {
+ deleteAndZero (currentAudioDevice);
+ }
+ }
+ else
+ {
+ deleteAndZero (currentAudioDevice);
+ error << "No such device: " << deviceNameToUse;
+ }
+ }
+ else
+ {
+ deleteAndZero (currentAudioDevice);
+ }
+
+ if (treatAsChosenDevice && error.isEmpty())
+ updateXml();
+
+ return error;
+}
+
+const String AudioDeviceManager::restartDevice (int blockSizeToUse,
+ double sampleRateToUse,
+ const BitArray& inChans,
+ const BitArray& outChans)
+{
+ stopDevice();
+
+ inputChannels = inChans;
+ outputChannels = outChans;
+
+ if (sampleRateToUse > 0)
+ {
+ bool ok = false;
+
+ for (int i = currentAudioDevice->getNumSampleRates(); --i >= 0;)
+ {
+ const double sr = currentAudioDevice->getSampleRate (i);
+
+ if (sr == sampleRateToUse)
+ ok = true;
+ }
+
+ if (! ok)
+ sampleRateToUse = 0;
+ }
+
+ if (sampleRateToUse == 0)
+ {
+ double lowestAbove44 = 0.0;
+
+ for (int i = currentAudioDevice->getNumSampleRates(); --i >= 0;)
+ {
+ const double sr = currentAudioDevice->getSampleRate (i);
+
+ if (sr >= 44100.0 && (lowestAbove44 == 0 || sr < lowestAbove44))
+ lowestAbove44 = sr;
+ }
+
+ if (lowestAbove44 == 0.0)
+ sampleRateToUse = currentAudioDevice->getSampleRate (0);
+ else
+ sampleRateToUse = lowestAbove44;
+ }
+
+ const String error (currentAudioDevice->open (inChans, outChans,
+ sampleRateToUse, blockSizeToUse));
+
+ if (error.isEmpty())
+ currentAudioDevice->start (&callbackHandler);
+
+ sendChangeMessage (this);
+ return error;
+}
+
+void AudioDeviceManager::stopDevice()
+{
+ if (currentAudioDevice != 0)
+ currentAudioDevice->stop();
+}
+
+void AudioDeviceManager::closeAudioDevice()
+{
+ if (currentAudioDevice != 0)
+ {
+ lastRunningDevice = currentAudioDevice->getName();
+ lastRunningBlockSize = currentAudioDevice->getCurrentBufferSizeSamples();
+ lastRunningSampleRate = currentAudioDevice->getCurrentSampleRate();
+ lastRunningIns = inputChannels;
+ lastRunningOuts = outputChannels;
+
+ stopDevice();
+
+ setAudioDevice (String::empty, 0, 0, 0, 0, false);
+ }
+}
+
+void AudioDeviceManager::restartLastAudioDevice()
+{
+ if (currentAudioDevice == 0)
+ {
+ if (lastRunningDevice.isEmpty())
+ {
+ // This method will only reload the last device that was running
+ // before closeAudioDevice() was called - you need to actually open
+ // one first, with setAudioDevice().
+ jassertfalse
+ return;
+ }
+
+ setAudioDevice (lastRunningDevice,
+ lastRunningBlockSize,
+ lastRunningSampleRate,
+ &lastRunningIns,
+ &lastRunningOuts,
+ false);
+ }
+}
+
+void AudioDeviceManager::setInputChannels (const BitArray& newEnabledChannels,
+ const bool treatAsChosenDevice)
+{
+ if (currentAudioDevice != 0
+ && newEnabledChannels != inputChannels)
+ {
+ setAudioDevice (currentAudioDevice->getName(),
+ currentAudioDevice->getCurrentBufferSizeSamples(),
+ currentAudioDevice->getCurrentSampleRate(),
+ &newEnabledChannels, 0,
+ treatAsChosenDevice);
+ }
+}
+
+void AudioDeviceManager::setOutputChannels (const BitArray& newEnabledChannels,
+ const bool treatAsChosenDevice)
+{
+ if (currentAudioDevice != 0
+ && newEnabledChannels != outputChannels)
+ {
+ setAudioDevice (currentAudioDevice->getName(),
+ currentAudioDevice->getCurrentBufferSizeSamples(),
+ currentAudioDevice->getCurrentSampleRate(),
+ 0, &newEnabledChannels,
+ treatAsChosenDevice);
+ }
+}
+
+void AudioDeviceManager::updateXml()
+{
+ delete lastExplicitSettings;
+
+ lastExplicitSettings = new XmlElement (T("DEVICESETUP"));
+
+ lastExplicitSettings->setAttribute (T("audioDeviceName"), getCurrentAudioDeviceName());
+
+ if (currentAudioDevice != 0)
+ {
+ lastExplicitSettings->setAttribute (T("audioDeviceRate"), currentAudioDevice->getCurrentSampleRate());
+
+ if (currentAudioDevice->getDefaultBufferSize() != currentAudioDevice->getCurrentBufferSizeSamples())
+ lastExplicitSettings->setAttribute (T("audioDeviceBufferSize"), currentAudioDevice->getCurrentBufferSizeSamples());
+
+ lastExplicitSettings->setAttribute (T("audioDeviceInChans"), inputChannels.toString (2));
+ lastExplicitSettings->setAttribute (T("audioDeviceOutChans"), outputChannels.toString (2));
+ }
+
+ for (int i = 0; i < enabledMidiInputs.size(); ++i)
+ {
+ XmlElement* const m = new XmlElement (T("MIDIINPUT"));
+ m->setAttribute (T("name"), enabledMidiInputs[i]->getName());
+
+ lastExplicitSettings->addChildElement (m);
+ }
+
+ if (defaultMidiOutputName.isNotEmpty())
+ lastExplicitSettings->setAttribute (T("defaultMidiOutput"), defaultMidiOutputName);
+}
+
+void AudioDeviceManager::setAudioCallback (AudioIODeviceCallback* newCallback)
+{
+ if (newCallback != currentCallback)
+ {
+ AudioIODeviceCallback* lastCallback = currentCallback;
+
+ audioCallbackLock.enter();
+ currentCallback = 0;
+ audioCallbackLock.exit();
+
+ if (currentAudioDevice != 0)
+ {
+ if (lastCallback != 0)
+ lastCallback->audioDeviceStopped();
+
+ if (newCallback != 0)
+ newCallback->audioDeviceAboutToStart (currentAudioDevice);
+ }
+
+ currentCallback = newCallback;
+ }
+}
+
+void AudioDeviceManager::audioDeviceIOCallbackInt (const float** inputChannelData,
+ int totalNumInputChannels,
+ float** outputChannelData,
+ int totalNumOutputChannels,
+ int numSamples)
+{
+ const ScopedLock sl (audioCallbackLock);
+
+ if (currentCallback != 0)
+ {
+ const double callbackStartTime = Time::getMillisecondCounterHiRes();
+
+ currentCallback->audioDeviceIOCallback (inputChannelData,
+ totalNumInputChannels,
+ outputChannelData,
+ totalNumOutputChannels,
+ numSamples);
+
+ const double msTaken = Time::getMillisecondCounterHiRes() - callbackStartTime;
+ const double filterAmount = 0.2;
+ cpuUsageMs += filterAmount * (msTaken - cpuUsageMs);
+ }
+ else
+ {
+ for (int i = 0; i < totalNumOutputChannels; ++i)
+ if (outputChannelData [i] != 0)
+ zeromem (outputChannelData[i], sizeof (float) * numSamples);
+ }
+}
+
+void AudioDeviceManager::audioDeviceAboutToStartInt (AudioIODevice* const device)
+{
+ cpuUsageMs = 0;
+
+ const double sampleRate = device->getCurrentSampleRate();
+ const int blockSize = device->getCurrentBufferSizeSamples();
+
+ if (sampleRate > 0.0 && blockSize > 0)
+ {
+ const double msPerBlock = 1000.0 * blockSize / sampleRate;
+ timeToCpuScale = (msPerBlock > 0.0) ? (1.0 / msPerBlock) : 0.0;
+ }
+
+ if (currentCallback != 0)
+ currentCallback->audioDeviceAboutToStart (device);
+
+ sendChangeMessage (this);
+}
+
+void AudioDeviceManager::audioDeviceStoppedInt()
+{
+ cpuUsageMs = 0;
+ timeToCpuScale = 0;
+ sendChangeMessage (this);
+
+ if (currentCallback != 0)
+ currentCallback->audioDeviceStopped();
+}
+
+double AudioDeviceManager::getCpuUsage() const
+{
+ return jlimit (0.0, 1.0, timeToCpuScale * cpuUsageMs);
+}
+
+void AudioDeviceManager::setMidiInputEnabled (const String& name,
+ const bool enabled)
+{
+ if (enabled != isMidiInputEnabled (name))
+ {
+ if (enabled)
+ {
+ const int index = MidiInput::getDevices().indexOf (name);
+
+ if (index >= 0)
+ {
+ MidiInput* const min = MidiInput::openDevice (index, &callbackHandler);
+
+ if (min != 0)
+ {
+ enabledMidiInputs.add (min);
+ min->start();
+ }
+ }
+ }
+ else
+ {
+ for (int i = enabledMidiInputs.size(); --i >= 0;)
+ if (enabledMidiInputs[i]->getName() == name)
+ enabledMidiInputs.remove (i);
+ }
+
+ updateXml();
+ sendChangeMessage (this);
+ }
+}
+
+bool AudioDeviceManager::isMidiInputEnabled (const String& name) const
+{
+ for (int i = enabledMidiInputs.size(); --i >= 0;)
+ if (enabledMidiInputs[i]->getName() == name)
+ return true;
+
+ return false;
+}
+
+void AudioDeviceManager::addMidiInputCallback (const String& name,
+ MidiInputCallback* callback)
+{
+ removeMidiInputCallback (callback);
+
+ if (name.isEmpty())
+ {
+ midiCallbacks.add (callback);
+ midiCallbackDevices.add (0);
+ }
+ else
+ {
+ for (int i = enabledMidiInputs.size(); --i >= 0;)
+ {
+ if (enabledMidiInputs[i]->getName() == name)
+ {
+ const ScopedLock sl (midiCallbackLock);
+
+ if (! midiCallbacks.contains (callback))
+ {
+ midiCallbacks.add (callback);
+ midiCallbackDevices.add (enabledMidiInputs[i]);
+ }
+
+ break;
+ }
+ }
+ }
+}
+
+void AudioDeviceManager::removeMidiInputCallback (MidiInputCallback* callback)
+{
+ const ScopedLock sl (midiCallbackLock);
+
+ const int index = midiCallbacks.indexOf (callback);
+ midiCallbacks.remove (index);
+ midiCallbackDevices.remove (index);
+}
+
+void AudioDeviceManager::handleIncomingMidiMessageInt (MidiInput* source,
+ const MidiMessage& message)
+{
+ if (! message.isActiveSense())
+ {
+ const bool isDefaultSource = (source == 0 || source == enabledMidiInputs.getFirst());
+
+ const ScopedLock sl (midiCallbackLock);
+
+ for (int i = midiCallbackDevices.size(); --i >= 0;)
+ {
+ MidiInput* const md = midiCallbackDevices.getUnchecked(i);
+
+ if (md == source || (md == 0 && isDefaultSource))
+ midiCallbacks.getUnchecked(i)->handleIncomingMidiMessage (source, message);
+ }
+ }
+}
+
+void AudioDeviceManager::setDefaultMidiOutput (const String& deviceName)
+{
+ if (defaultMidiOutputName != deviceName)
+ {
+ deleteAndZero (defaultMidiOutput);
+ defaultMidiOutputName = deviceName;
+
+ if (deviceName.isNotEmpty())
+ defaultMidiOutput = MidiOutput::openDevice (MidiOutput::getDevices().indexOf (deviceName));
+
+ updateXml();
+ sendChangeMessage (this);
+ }
+}
+
+void AudioDeviceManager::CallbackHandler::audioDeviceIOCallback (const float** inputChannelData,
+ int totalNumInputChannels,
+ float** outputChannelData,
+ int totalNumOutputChannels,
+ int numSamples)
+{
+ owner->audioDeviceIOCallbackInt (inputChannelData, totalNumInputChannels, outputChannelData, totalNumOutputChannels, numSamples);
+}
+
+void AudioDeviceManager::CallbackHandler::audioDeviceAboutToStart (AudioIODevice* device)
+{
+ owner->audioDeviceAboutToStartInt (device);
+}
+
+void AudioDeviceManager::CallbackHandler::audioDeviceStopped()
+{
+ owner->audioDeviceStoppedInt();
+}
+
+void AudioDeviceManager::CallbackHandler::handleIncomingMidiMessage (MidiInput* source, const MidiMessage& message)
+{
+ owner->handleIncomingMidiMessageInt (source, message);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_AudioDeviceManager.cpp *********/
+
+/********* Start of inlined file: juce_AudioIODevice.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+AudioIODevice::AudioIODevice (const String& deviceName, const String& typeName_)
+ : name (deviceName),
+ typeName (typeName_)
+{
+}
+
+AudioIODevice::~AudioIODevice()
+{
+}
+
+bool AudioIODevice::hasControlPanel() const
+{
+ return false;
+}
+
+bool AudioIODevice::showControlPanel()
+{
+ jassertfalse // this should only be called for devices which return true from
+ // their hasControlPanel() method.
+ return false;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_AudioIODevice.cpp *********/
+
+/********* Start of inlined file: juce_AudioIODeviceType.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+AudioIODeviceType::AudioIODeviceType (const tchar* const name)
+ : typeName (name)
+{
+}
+
+AudioIODeviceType::~AudioIODeviceType()
+{
+}
+
+extern AudioIODeviceType* juce_createDefaultAudioIODeviceType();
+
+#if JUCE_WIN32 && JUCE_ASIO
+ extern AudioIODeviceType* juce_createASIOAudioIODeviceType();
+#endif
+
+#if JUCE_WIN32 && JUCE_WDM_AUDIO
+ extern AudioIODeviceType* juce_createWDMAudioIODeviceType();
+#endif
+
+void AudioIODeviceType::createDeviceTypes (OwnedArray & list)
+{
+ AudioIODeviceType* const defaultDeviceType = juce_createDefaultAudioIODeviceType();
+
+ if (defaultDeviceType != 0)
+ list.add (defaultDeviceType);
+
+#if JUCE_WIN32 && JUCE_ASIO
+ list.add (juce_createASIOAudioIODeviceType());
+#endif
+
+#if JUCE_WIN32 && JUCE_WDM_AUDIO
+ list.add (juce_createWDMAudioIODeviceType());
+#endif
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_AudioIODeviceType.cpp *********/
+
+/********* Start of inlined file: juce_MidiOutput.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+MidiOutput::MidiOutput() throw()
+ : Thread ("midi out"),
+ internal (0),
+ firstMessage (0)
+{
+}
+
+MidiOutput::PendingMessage::PendingMessage (const uint8* const data,
+ const int len,
+ const double sampleNumber) throw()
+ : message (data, len, sampleNumber)
+{
+}
+
+void MidiOutput::sendBlockOfMessages (const MidiBuffer& buffer,
+ const double millisecondCounterToStartAt,
+ double samplesPerSecondForBuffer) throw()
+{
+ // You've got to call startBackgroundThread() for this to actually work..
+ jassert (isThreadRunning());
+
+ // this needs to be a value in the future - RTFM for this method!
+ jassert (millisecondCounterToStartAt > 0);
+
+ samplesPerSecondForBuffer *= 0.001;
+
+ MidiBuffer::Iterator i (buffer);
+
+ const uint8* data;
+ int len, time;
+
+ while (i.getNextEvent (data, len, time))
+ {
+ const double eventTime = millisecondCounterToStartAt + samplesPerSecondForBuffer * time;
+
+ PendingMessage* const m
+ = new PendingMessage (data, len, eventTime);
+
+ const ScopedLock sl (lock);
+
+ if (firstMessage == 0 || firstMessage->message.getTimeStamp() > eventTime)
+ {
+ m->next = firstMessage;
+ firstMessage = m;
+ }
+ else
+ {
+ PendingMessage* mm = firstMessage;
+
+ while (mm->next != 0 && mm->next->message.getTimeStamp() <= eventTime)
+ mm = mm->next;
+
+ m->next = mm->next;
+ mm->next = m;
+ }
+ }
+
+ notify();
+}
+
+void MidiOutput::clearAllPendingMessages() throw()
+{
+ const ScopedLock sl (lock);
+
+ while (firstMessage != 0)
+ {
+ PendingMessage* const m = firstMessage;
+ firstMessage = firstMessage->next;
+ delete m;
+ }
+}
+
+void MidiOutput::startBackgroundThread() throw()
+{
+ startThread (9);
+}
+
+void MidiOutput::stopBackgroundThread() throw()
+{
+ stopThread (5000);
+}
+
+void MidiOutput::run()
+{
+ while (! threadShouldExit())
+ {
+ uint32 now = Time::getMillisecondCounter();
+ uint32 eventTime = 0;
+ uint32 timeToWait = 500;
+
+ lock.enter();
+ PendingMessage* message = firstMessage;
+
+ if (message != 0)
+ {
+ eventTime = roundDoubleToInt (message->message.getTimeStamp());
+
+ if (eventTime > now + 20)
+ {
+ timeToWait = jmax (10, eventTime - now - 100);
+ message = 0;
+ }
+ else
+ {
+ firstMessage = message->next;
+ }
+ }
+
+ lock.exit();
+
+ if (message != 0)
+ {
+ if (eventTime > now)
+ {
+ Time::waitForMillisecondCounter (eventTime);
+
+ if (threadShouldExit())
+ break;
+ }
+
+ if (eventTime > now - 200)
+ sendMessageNow (message->message);
+
+ delete message;
+ }
+ else
+ {
+ jassert (timeToWait < 1000 * 30);
+ wait (timeToWait);
+ }
+ }
+
+ clearAllPendingMessages();
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_MidiOutput.cpp *********/
+
+/********* Start of inlined file: juce_AudioDataConverters.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+void AudioDataConverters::convertFloatToInt16LE (const float* source, void* dest, int numSamples, const int destBytesPerSample)
+{
+ const double maxVal = (double) 0x7fff;
+ char* intData = (char*) dest;
+
+ for (int i = 0; i < numSamples; ++i)
+ {
+ *(uint16*)intData = swapIfBigEndian ((uint16) (short) roundDoubleToInt (jlimit (-maxVal, maxVal, maxVal * source[i])));
+ intData += destBytesPerSample;
+ }
+}
+
+void AudioDataConverters::convertFloatToInt16BE (const float* source, void* dest, int numSamples, const int destBytesPerSample)
+{
+ const double maxVal = (double) 0x7fff;
+ char* intData = (char*) dest;
+
+ for (int i = 0; i < numSamples; ++i)
+ {
+ *(uint16*)intData = swapIfLittleEndian ((uint16) (short) roundDoubleToInt (jlimit (-maxVal, maxVal, maxVal * source[i])));
+ intData += destBytesPerSample;
+ }
+}
+
+void AudioDataConverters::convertFloatToInt24LE (const float* source, void* dest, int numSamples, const int destBytesPerSample)
+{
+ const double maxVal = (double) 0x7fffff;
+ char* intData = (char*) dest;
+
+ for (int i = 0; i < numSamples; ++i)
+ {
+ littleEndian24BitToChars ((uint32) roundDoubleToInt (jlimit (-maxVal, maxVal, maxVal * source[i])), intData);
+ intData += destBytesPerSample;
+ }
+}
+
+void AudioDataConverters::convertFloatToInt24BE (const float* source, void* dest, int numSamples, const int destBytesPerSample)
+{
+ const double maxVal = (double) 0x7fffff;
+ char* intData = (char*) dest;
+
+ for (int i = 0; i < numSamples; ++i)
+ {
+ bigEndian24BitToChars ((uint32) roundDoubleToInt (jlimit (-maxVal, maxVal, maxVal * source[i])), intData);
+ intData += destBytesPerSample;
+ }
+}
+
+void AudioDataConverters::convertFloatToInt32LE (const float* source, void* dest, int numSamples, const int destBytesPerSample)
+{
+ const double maxVal = (double) 0x7fffffff;
+ char* intData = (char*) dest;
+
+ for (int i = 0; i < numSamples; ++i)
+ {
+ *(uint32*)intData = swapIfBigEndian ((uint32) roundDoubleToInt (jlimit (-maxVal, maxVal, maxVal * source[i])));
+ intData += destBytesPerSample;
+ }
+}
+
+void AudioDataConverters::convertFloatToInt32BE (const float* source, void* dest, int numSamples, const int destBytesPerSample)
+{
+ const double maxVal = (double) 0x7fffffff;
+ char* intData = (char*) dest;
+
+ for (int i = 0; i < numSamples; ++i)
+ {
+ *(uint32*)intData = swapIfLittleEndian ((uint32) roundDoubleToInt (jlimit (-maxVal, maxVal, maxVal * source[i])));
+ intData += destBytesPerSample;
+ }
+}
+
+void AudioDataConverters::convertFloatToFloat32LE (const float* source, void* dest, int numSamples, const int destBytesPerSample)
+{
+ char* d = (char*) dest;
+
+ for (int i = 0; i < numSamples; ++i)
+ {
+ *(float*)d = source[i];
+
+#if JUCE_BIG_ENDIAN
+ *(uint32*)d = swapByteOrder (*(uint32*)d);
+#endif
+
+ d += destBytesPerSample;
+ }
+}
+
+void AudioDataConverters::convertFloatToFloat32BE (const float* source, void* dest, int numSamples, const int destBytesPerSample)
+{
+ char* d = (char*) dest;
+
+ for (int i = 0; i < numSamples; ++i)
+ {
+ *(float*)d = source[i];
+
+#if JUCE_LITTLE_ENDIAN
+ *(uint32*)d = swapByteOrder (*(uint32*)d);
+#endif
+
+ d += destBytesPerSample;
+ }
+}
+
+void AudioDataConverters::convertInt16LEToFloat (const void* const source, float* const dest, int numSamples, const int srcBytesPerSample)
+{
+ const float scale = 1.0f / 0x7fff;
+ const char* intData = (const char*) source;
+
+ for (int i = 0; i < numSamples; ++i)
+ {
+ dest[i] = scale * (short) swapIfBigEndian (*(uint16*)intData);
+ intData += srcBytesPerSample;
+ }
+}
+
+void AudioDataConverters::convertInt16BEToFloat (const void* const source, float* const dest, int numSamples, const int srcBytesPerSample)
+{
+ const float scale = 1.0f / 0x7fff;
+ const char* intData = (const char*) source;
+
+ for (int i = 0; i < numSamples; ++i)
+ {
+ dest[i] = scale * (short) swapIfLittleEndian (*(uint16*)intData);
+ intData += srcBytesPerSample;
+ }
+}
+
+void AudioDataConverters::convertInt24LEToFloat (const void* const source, float* const dest, int numSamples, const int srcBytesPerSample)
+{
+ const float scale = 1.0f / 0x7fffff;
+ const char* intData = (const char*) source;
+
+ for (int i = 0; i < numSamples; ++i)
+ {
+ dest[i] = scale * (short) littleEndian24Bit (intData);
+ intData += srcBytesPerSample;
+ }
+}
+
+void AudioDataConverters::convertInt24BEToFloat (const void* const source, float* const dest, int numSamples, const int srcBytesPerSample)
+{
+ const float scale = 1.0f / 0x7fffff;
+ const char* intData = (const char*) source;
+
+ for (int i = 0; i < numSamples; ++i)
+ {
+ dest[i] = scale * (short) bigEndian24Bit (intData);
+ intData += srcBytesPerSample;
+ }
+}
+
+void AudioDataConverters::convertInt32LEToFloat (const void* const source, float* const dest, int numSamples, const int srcBytesPerSample)
+{
+ const float scale = 1.0f / 0x7fffffff;
+ const char* intData = (const char*) source;
+
+ for (int i = 0; i < numSamples; ++i)
+ {
+ dest[i] = scale * (int) swapIfBigEndian (*(uint32*) intData);
+ intData += srcBytesPerSample;
+ }
+}
+
+void AudioDataConverters::convertInt32BEToFloat (const void* const source, float* const dest, int numSamples, const int srcBytesPerSample)
+{
+ const float scale = 1.0f / 0x7fffffff;
+ const char* intData = (const char*) source;
+
+ for (int i = 0; i < numSamples; ++i)
+ {
+ dest[i] = scale * (int) (swapIfLittleEndian (*(uint32*) intData));
+ intData += srcBytesPerSample;
+ }
+}
+
+void AudioDataConverters::convertFloat32LEToFloat (const void* const source, float* const dest, int numSamples, const int srcBytesPerSample)
+{
+ const char* s = (const char*) source;
+
+ for (int i = 0; i < numSamples; ++i)
+ {
+ dest[i] = *(float*)s;
+
+#if JUCE_BIG_ENDIAN
+ uint32* const d = (uint32*) (dest + i);
+ *d = swapByteOrder (*d);
+#endif
+
+ s += srcBytesPerSample;
+ }
+}
+
+void AudioDataConverters::convertFloat32BEToFloat (const void* const source, float* const dest, int numSamples, const int srcBytesPerSample)
+{
+ const char* s = (const char*) source;
+
+ for (int i = 0; i < numSamples; ++i)
+ {
+ dest[i] = *(float*)s;
+
+#if JUCE_LITTLE_ENDIAN
+ uint32* const d = (uint32*) (dest + i);
+ *d = swapByteOrder (*d);
+#endif
+
+ s += srcBytesPerSample;
+ }
+}
+
+void AudioDataConverters::convertFloatToFormat (const DataFormat destFormat,
+ const float* const source,
+ void* const dest,
+ const int numSamples)
+{
+ switch (destFormat)
+ {
+ case int16LE:
+ convertFloatToInt16LE (source, dest, numSamples);
+ break;
+
+ case int16BE:
+ convertFloatToInt16BE (source, dest, numSamples);
+ break;
+
+ case int24LE:
+ convertFloatToInt24LE (source, dest, numSamples);
+ break;
+
+ case int24BE:
+ convertFloatToInt24BE (source, dest, numSamples);
+ break;
+
+ case int32LE:
+ convertFloatToInt32LE (source, dest, numSamples);
+ break;
+
+ case int32BE:
+ convertFloatToInt32BE (source, dest, numSamples);
+ break;
+
+ case float32LE:
+ convertFloatToFloat32LE (source, dest, numSamples);
+ break;
+
+ case float32BE:
+ convertFloatToFloat32BE (source, dest, numSamples);
+ break;
+
+ default:
+ jassertfalse
+ break;
+ }
+}
+
+void AudioDataConverters::convertFormatToFloat (const DataFormat sourceFormat,
+ const void* const source,
+ float* const dest,
+ const int numSamples)
+{
+ switch (sourceFormat)
+ {
+ case int16LE:
+ convertInt16LEToFloat (source, dest, numSamples);
+ break;
+
+ case int16BE:
+ convertInt16BEToFloat (source, dest, numSamples);
+ break;
+
+ case int24LE:
+ convertInt24LEToFloat (source, dest, numSamples);
+ break;
+
+ case int24BE:
+ convertInt24BEToFloat (source, dest, numSamples);
+ break;
+
+ case int32LE:
+ convertInt32LEToFloat (source, dest, numSamples);
+ break;
+
+ case int32BE:
+ convertInt32BEToFloat (source, dest, numSamples);
+ break;
+
+ case float32LE:
+ convertFloat32LEToFloat (source, dest, numSamples);
+ break;
+
+ case float32BE:
+ convertFloat32BEToFloat (source, dest, numSamples);
+ break;
+
+ default:
+ jassertfalse
+ break;
+ }
+}
+
+void AudioDataConverters::interleaveSamples (const float** const source,
+ float* const dest,
+ const int numSamples,
+ const int numChannels)
+{
+ for (int chan = 0; chan < numChannels; ++chan)
+ {
+ int i = chan;
+ const float* src = source [chan];
+
+ for (int j = 0; j < numSamples; ++j)
+ {
+ dest [i] = src [j];
+ i += numChannels;
+ }
+ }
+}
+
+void AudioDataConverters::deinterleaveSamples (const float* const source,
+ float** const dest,
+ const int numSamples,
+ const int numChannels)
+{
+ for (int chan = 0; chan < numChannels; ++chan)
+ {
+ int i = chan;
+ float* dst = dest [chan];
+
+ for (int j = 0; j < numSamples; ++j)
+ {
+ dst [j] = source [i];
+ i += numChannels;
+ }
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_AudioDataConverters.cpp *********/
+
+/********* Start of inlined file: juce_AudioSampleBuffer.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+AudioSampleBuffer::AudioSampleBuffer (const int numChannels_,
+ const int numSamples) throw()
+ : numChannels (numChannels_),
+ size (numSamples)
+{
+ jassert (numSamples >= 0);
+ jassert (numChannels_ > 0 && numChannels_ <= maxNumAudioSampleBufferChannels);
+
+ allocatedBytes = numChannels * numSamples * sizeof (float) + 32;
+ allocatedData = (float*) juce_malloc (allocatedBytes);
+
+ float* chan = allocatedData;
+ for (int i = 0; i < numChannels_; ++i)
+ {
+ channels[i] = chan;
+ chan += numSamples;
+ }
+
+ channels [numChannels_] = 0;
+}
+
+AudioSampleBuffer::AudioSampleBuffer (float** dataToReferTo,
+ const int numChannels_,
+ const int numSamples) throw()
+ : numChannels (numChannels_),
+ size (numSamples),
+ allocatedBytes (0),
+ allocatedData (0)
+{
+ jassert (((unsigned int) numChannels_) <= (unsigned int) maxNumAudioSampleBufferChannels);
+
+ for (int i = 0; i < numChannels_; ++i)
+ {
+ // you have to pass in the same number of valid pointers as numChannels
+ jassert (dataToReferTo[i] != 0);
+
+ channels[i] = dataToReferTo[i];
+ }
+
+ channels [numChannels_] = 0;
+}
+
+void AudioSampleBuffer::setDataToReferTo (float** dataToReferTo,
+ const int numChannels_,
+ const int numSamples) throw()
+{
+ jassert (((unsigned int) numChannels_) <= (unsigned int) maxNumAudioSampleBufferChannels);
+
+ juce_free (allocatedData);
+ allocatedData = 0;
+ allocatedBytes = 0;
+
+ numChannels = numChannels_;
+ size = numSamples;
+
+ for (int i = 0; i < numChannels_; ++i)
+ {
+ // you have to pass in the same number of valid pointers as numChannels
+ jassert (dataToReferTo[i] != 0);
+
+ channels[i] = dataToReferTo[i];
+ }
+
+ channels [numChannels_] = 0;
+}
+
+AudioSampleBuffer::AudioSampleBuffer (const AudioSampleBuffer& other) throw()
+ : numChannels (other.numChannels),
+ size (other.size)
+{
+ if (other.allocatedData != 0)
+ {
+ allocatedBytes = numChannels * size * sizeof (float) + 32;
+ allocatedData = (float*) juce_malloc (allocatedBytes);
+
+ memcpy (allocatedData, other.allocatedData, allocatedBytes);
+
+ float* chan = allocatedData;
+ for (int i = 0; i < numChannels; ++i)
+ {
+ channels[i] = chan;
+ chan += size;
+ }
+
+ channels [numChannels] = 0;
+ }
+ else
+ {
+ allocatedData = 0;
+ allocatedBytes = 0;
+
+ memcpy (channels, other.channels, sizeof (channels));
+ }
+}
+
+const AudioSampleBuffer& AudioSampleBuffer::operator= (const AudioSampleBuffer& other) throw()
+{
+ if (this != &other)
+ {
+ setSize (other.getNumChannels(), other.getNumSamples(), false, false, false);
+
+ const int numBytes = size * sizeof (float);
+
+ for (int i = 0; i < numChannels; ++i)
+ memcpy (channels[i], other.channels[i], numBytes);
+ }
+
+ return *this;
+}
+
+AudioSampleBuffer::~AudioSampleBuffer() throw()
+{
+ juce_free (allocatedData);
+}
+
+float* AudioSampleBuffer::getSampleData (const int channelNumber,
+ const int sampleOffset) const throw()
+{
+ jassert (((unsigned int) channelNumber) < (unsigned int) numChannels);
+ jassert (((unsigned int) sampleOffset) < (unsigned int) size);
+
+ return channels [channelNumber] + sampleOffset;
+}
+
+void AudioSampleBuffer::setSize (const int newNumChannels,
+ const int newNumSamples,
+ const bool keepExistingContent,
+ const bool clearExtraSpace,
+ const bool avoidReallocating) throw()
+{
+ jassert (newNumChannels > 0 && newNumChannels <= maxNumAudioSampleBufferChannels);
+
+ if (newNumSamples != size || newNumChannels != numChannels)
+ {
+ const int newTotalBytes = newNumChannels * newNumSamples * sizeof (float) + 32;
+
+ if (keepExistingContent)
+ {
+ float* const newData = (clearExtraSpace) ? (float*) juce_calloc (newTotalBytes)
+ : (float*) juce_malloc (newTotalBytes);
+
+ const int sizeToCopy = sizeof (float) * jmin (newNumSamples, size);
+
+ for (int i = jmin (newNumChannels, numChannels); --i >= 0;)
+ {
+ memcpy (newData + i * newNumSamples,
+ channels[i],
+ sizeToCopy);
+ }
+
+ juce_free (allocatedData);
+
+ allocatedData = newData;
+ allocatedBytes = newTotalBytes;
+ }
+ else
+ {
+ if (avoidReallocating && allocatedBytes >= newTotalBytes)
+ {
+ if (clearExtraSpace)
+ zeromem (allocatedData, newTotalBytes);
+ }
+ else
+ {
+ juce_free (allocatedData);
+
+ allocatedData = (clearExtraSpace) ? (float*) juce_calloc (newTotalBytes)
+ : (float*) juce_malloc (newTotalBytes);
+ allocatedBytes = newTotalBytes;
+ }
+ }
+
+ size = newNumSamples;
+ numChannels = newNumChannels;
+
+ float* chan = allocatedData;
+ for (int i = 0; i < newNumChannels; ++i)
+ {
+ channels[i] = chan;
+ chan += size;
+ }
+
+ channels [newNumChannels] = 0;
+ }
+}
+
+void AudioSampleBuffer::clear() throw()
+{
+ for (int i = 0; i < numChannels; ++i)
+ zeromem (channels[i], size * sizeof (float));
+}
+
+void AudioSampleBuffer::clear (const int startSample,
+ const int numSamples) throw()
+{
+ jassert (startSample >= 0 && startSample + numSamples <= size);
+
+ for (int i = 0; i < numChannels; ++i)
+ zeromem (channels [i] + startSample, numSamples * sizeof (float));
+}
+
+void AudioSampleBuffer::clear (const int channel,
+ const int startSample,
+ const int numSamples) throw()
+{
+ jassert (((unsigned int) channel) < (unsigned int) numChannels);
+ jassert (startSample >= 0 && startSample + numSamples <= size);
+
+ zeromem (channels [channel] + startSample, numSamples * sizeof (float));
+}
+
+void AudioSampleBuffer::applyGain (const int channel,
+ const int startSample,
+ int numSamples,
+ const float gain) throw()
+{
+ jassert (((unsigned int) channel) < (unsigned int) numChannels);
+ jassert (startSample >= 0 && startSample + numSamples <= size);
+
+ if (gain != 1.0f)
+ {
+ float* d = channels [channel] + startSample;
+
+ if (gain == 0.0f)
+ {
+ zeromem (d, sizeof (float) * numSamples);
+ }
+ else
+ {
+ while (--numSamples >= 0)
+ *d++ *= gain;
+ }
+ }
+}
+
+void AudioSampleBuffer::applyGainRamp (const int channel,
+ const int startSample,
+ int numSamples,
+ float startGain,
+ float endGain) throw()
+{
+ if (startGain == endGain)
+ {
+ applyGain (channel, startSample, numSamples, startGain);
+ }
+ else
+ {
+ jassert (((unsigned int) channel) < (unsigned int) numChannels);
+ jassert (startSample >= 0 && startSample + numSamples <= size);
+
+ const float increment = (endGain - startGain) / numSamples;
+ float* d = channels [channel] + startSample;
+
+ while (--numSamples >= 0)
+ {
+ *d++ *= startGain;
+ startGain += increment;
+ }
+ }
+}
+
+void AudioSampleBuffer::applyGain (const int startSample,
+ const int numSamples,
+ const float gain) throw()
+{
+ for (int i = 0; i < numChannels; ++i)
+ applyGain (i, startSample, numSamples, gain);
+}
+
+void AudioSampleBuffer::addFrom (const int destChannel,
+ const int destStartSample,
+ const AudioSampleBuffer& source,
+ const int sourceChannel,
+ const int sourceStartSample,
+ int numSamples,
+ const float gain) throw()
+{
+ jassert (&source != this || sourceChannel != destChannel);
+ jassert (((unsigned int) destChannel) < (unsigned int) numChannels);
+ jassert (destStartSample >= 0 && destStartSample + numSamples <= size);
+ jassert (((unsigned int) sourceChannel) < (unsigned int) source.numChannels);
+ jassert (sourceStartSample >= 0 && sourceStartSample + numSamples <= source.size);
+
+ if (gain != 0.0f && numSamples > 0)
+ {
+ float* d = channels [destChannel] + destStartSample;
+ const float* s = source.channels [sourceChannel] + sourceStartSample;
+
+ if (gain != 1.0f)
+ {
+ while (--numSamples >= 0)
+ *d++ += gain * *s++;
+ }
+ else
+ {
+ while (--numSamples >= 0)
+ *d++ += *s++;
+ }
+ }
+}
+
+void AudioSampleBuffer::addFrom (const int destChannel,
+ const int destStartSample,
+ const float* source,
+ int numSamples,
+ const float gain) throw()
+{
+ jassert (((unsigned int) destChannel) < (unsigned int) numChannels);
+ jassert (destStartSample >= 0 && destStartSample + numSamples <= size);
+ jassert (source != 0);
+
+ if (gain != 0.0f && numSamples > 0)
+ {
+ float* d = channels [destChannel] + destStartSample;
+
+ if (gain != 1.0f)
+ {
+ while (--numSamples >= 0)
+ *d++ += gain * *source++;
+ }
+ else
+ {
+ while (--numSamples >= 0)
+ *d++ += *source++;
+ }
+ }
+}
+
+void AudioSampleBuffer::addFromWithRamp (const int destChannel,
+ const int destStartSample,
+ const float* source,
+ int numSamples,
+ float startGain,
+ const float endGain) throw()
+{
+ jassert (((unsigned int) destChannel) < (unsigned int) numChannels);
+ jassert (destStartSample >= 0 && destStartSample + numSamples <= size);
+ jassert (source != 0);
+
+ if (startGain == endGain)
+ {
+ addFrom (destChannel,
+ destStartSample,
+ source,
+ numSamples,
+ startGain);
+ }
+ else
+ {
+ if (numSamples > 0 && (startGain != 0.0f || endGain != 0.0f))
+ {
+ const float increment = (endGain - startGain) / numSamples;
+ float* d = channels [destChannel] + destStartSample;
+
+ while (--numSamples >= 0)
+ {
+ *d++ += startGain * *source++;
+ startGain += increment;
+ }
+ }
+ }
+}
+
+void AudioSampleBuffer::copyFrom (const int destChannel,
+ const int destStartSample,
+ const AudioSampleBuffer& source,
+ const int sourceChannel,
+ const int sourceStartSample,
+ int numSamples) throw()
+{
+ jassert (&source != this || sourceChannel != destChannel);
+ jassert (((unsigned int) destChannel) < (unsigned int) numChannels);
+ jassert (destStartSample >= 0 && destStartSample + numSamples <= size);
+ jassert (((unsigned int) sourceChannel) < (unsigned int) source.numChannels);
+ jassert (sourceStartSample >= 0 && sourceStartSample + numSamples <= source.size);
+
+ if (numSamples > 0)
+ {
+ memcpy (channels [destChannel] + destStartSample,
+ source.channels [sourceChannel] + sourceStartSample,
+ sizeof (float) * numSamples);
+ }
+}
+
+void AudioSampleBuffer::copyFrom (const int destChannel,
+ const int destStartSample,
+ const float* source,
+ int numSamples) throw()
+{
+ jassert (((unsigned int) destChannel) < (unsigned int) numChannels);
+ jassert (destStartSample >= 0 && destStartSample + numSamples <= size);
+ jassert (source != 0);
+
+ if (numSamples > 0)
+ {
+ memcpy (channels [destChannel] + destStartSample,
+ source,
+ sizeof (float) * numSamples);
+ }
+}
+
+void AudioSampleBuffer::findMinMax (const int channel,
+ const int startSample,
+ int numSamples,
+ float& minVal,
+ float& maxVal) const throw()
+{
+ jassert (((unsigned int) channel) < (unsigned int) numChannels);
+ jassert (startSample >= 0 && startSample + numSamples <= size);
+
+ if (numSamples <= 0)
+ {
+ minVal = 0.0f;
+ maxVal = 0.0f;
+ }
+ else
+ {
+ const float* d = channels [channel] + startSample;
+
+ float mn = *d++;
+ float mx = mn;
+
+ while (--numSamples > 0) // (> 0 rather than >= 0 because we've already taken the first sample)
+ {
+ const float samp = *d++;
+
+ if (samp > mx)
+ mx = samp;
+
+ if (samp < mn)
+ mn = samp;
+ }
+
+ maxVal = mx;
+ minVal = mn;
+ }
+}
+
+float AudioSampleBuffer::getMagnitude (const int channel,
+ const int startSample,
+ const int numSamples) const throw()
+{
+ jassert (((unsigned int) channel) < (unsigned int) numChannels);
+ jassert (startSample >= 0 && startSample + numSamples <= size);
+
+ float mn, mx;
+ findMinMax (channel, startSample, numSamples, mn, mx);
+
+ return jmax (mn, -mn, mx, -mx);
+}
+
+float AudioSampleBuffer::getMagnitude (const int startSample,
+ const int numSamples) const throw()
+{
+ float mag = 0.0f;
+
+ for (int i = 0; i < numChannels; ++i)
+ mag = jmax (mag, getMagnitude (i, startSample, numSamples));
+
+ return mag;
+}
+
+float AudioSampleBuffer::getRMSLevel (const int channel,
+ const int startSample,
+ const int numSamples) const throw()
+{
+ jassert (((unsigned int) channel) < (unsigned int) numChannels);
+ jassert (startSample >= 0 && startSample + numSamples <= size);
+
+ if (numSamples <= 0 || channel < 0 || channel >= numChannels)
+ return 0.0f;
+
+ const float* const data = channels [channel] + startSample;
+ double sum = 0.0;
+
+ for (int i = 0; i < numSamples; ++i)
+ {
+ const float sample = data [i];
+ sum += sample * sample;
+ }
+
+ return (float) sqrt (sum / numSamples);
+}
+
+void AudioSampleBuffer::readFromAudioReader (AudioFormatReader* reader,
+ const int startSample,
+ const int numSamples,
+ const int readerStartSample,
+ const bool useLeftChan,
+ const bool useRightChan) throw()
+{
+ jassert (reader != 0);
+ jassert (startSample >= 0 && startSample + numSamples <= size);
+
+ if (numSamples > 0)
+ {
+ int* chans[3];
+
+ if (useLeftChan == useRightChan)
+ {
+ chans[0] = (int*) getSampleData (0, startSample);
+ chans[1] = (reader->numChannels > 1 && getNumChannels() > 1) ? (int*) getSampleData (1, startSample) : 0;
+ }
+ else if (useLeftChan || (reader->numChannels == 1))
+ {
+ chans[0] = (int*) getSampleData (0, startSample);
+ chans[1] = 0;
+ }
+ else if (useRightChan)
+ {
+ chans[0] = 0;
+ chans[1] = (int*) getSampleData (0, startSample);
+ }
+
+ chans[2] = 0;
+
+ reader->read (chans, readerStartSample, numSamples);
+
+ if (! reader->usesFloatingPointData)
+ {
+ for (int j = 0; j < 2; ++j)
+ {
+ float* const d = (float*) (chans[j]);
+
+ if (d != 0)
+ {
+ const float multiplier = 1.0f / 0x7fffffff;
+
+ for (int i = 0; i < numSamples; ++i)
+ d[i] = *(int*)(d + i) * multiplier;
+ }
+ }
+ }
+
+ if (numChannels > 1 && (chans[0] == 0 || chans[1] == 0))
+ {
+ // if this is a stereo buffer and the source was mono, dupe the first channel..
+ memcpy (getSampleData (1, startSample),
+ getSampleData (0, startSample),
+ sizeof (float) * numSamples);
+ }
+ }
+}
+
+void AudioSampleBuffer::writeToAudioWriter (AudioFormatWriter* writer,
+ const int startSample,
+ const int numSamples) const throw()
+{
+ jassert (startSample >= 0 && startSample + numSamples <= size);
+
+ if (numSamples > 0)
+ {
+ int* chans [3];
+
+ if (writer->isFloatingPoint())
+ {
+ chans[0] = (int*) getSampleData (0, startSample);
+
+ if (numChannels > 1)
+ chans[1] = (int*) getSampleData (1, startSample);
+ else
+ chans[1] = 0;
+
+ chans[2] = 0;
+ writer->write ((const int**) chans, numSamples);
+ }
+ else
+ {
+ chans[0] = (int*) juce_malloc (sizeof (int) * numSamples * 2);
+
+ if (numChannels > 1)
+ chans[1] = chans[0] + numSamples;
+ else
+ chans[1] = 0;
+
+ chans[2] = 0;
+
+ for (int j = 0; j < 2; ++j)
+ {
+ int* const dest = chans[j];
+
+ if (dest != 0)
+ {
+ const float* const src = channels [j] + startSample;
+
+ for (int i = 0; i < numSamples; ++i)
+ {
+ const double samp = src[i];
+
+ if (samp <= -1.0)
+ dest[i] = INT_MIN;
+ else if (samp >= 1.0)
+ dest[i] = INT_MAX;
+ else
+ dest[i] = roundDoubleToInt (INT_MAX * samp);
+ }
+ }
+ }
+
+ writer->write ((const int**) chans, numSamples);
+
+ juce_free (chans[0]);
+ }
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_AudioSampleBuffer.cpp *********/
+
+/********* Start of inlined file: juce_IIRFilter.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+IIRFilter::IIRFilter() throw()
+ : active (false)
+{
+ reset();
+}
+
+IIRFilter::IIRFilter (const IIRFilter& other) throw()
+ : active (other.active)
+{
+ const ScopedLock sl (other.processLock);
+ memcpy (coefficients, other.coefficients, sizeof (coefficients));
+ reset();
+}
+
+IIRFilter::~IIRFilter() throw()
+{
+}
+
+void IIRFilter::reset() throw()
+{
+ const ScopedLock sl (processLock);
+
+ x1 = 0;
+ x2 = 0;
+ y1 = 0;
+ y2 = 0;
+}
+
+void IIRFilter::processSamples (float* const samples,
+ const int numSamples) throw()
+{
+ const ScopedLock sl (processLock);
+
+ if (active)
+ {
+ for (int i = 0; i < numSamples; ++i)
+ {
+ const float in = samples[i];
+
+ float out = coefficients[0] * in
+ + coefficients[1] * x1
+ + coefficients[2] * x2
+ - coefficients[4] * y1
+ - coefficients[5] * y2;
+
+#if JUCE_INTEL
+ if (! (out < -1.0e-8 || out > 1.0e-8))
+ out = 0;
+#endif
+
+ x2 = x1;
+ x1 = in;
+ y2 = y1;
+ y1 = out;
+
+ samples[i] = out;
+ }
+ }
+}
+
+void IIRFilter::makeLowPass (const double sampleRate,
+ const double frequency) throw()
+{
+ jassert (sampleRate > 0);
+
+ const double n = 1.0 / tan (double_Pi * frequency / sampleRate);
+ const double nSquared = n * n;
+ const double c1 = 1.0 / (1.0 + sqrt (2.0) * n + nSquared);
+
+ setCoefficients (c1,
+ c1 * 2.0f,
+ c1,
+ 1.0,
+ c1 * 2.0 * (1.0 - nSquared),
+ c1 * (1.0 - sqrt (2.0) * n + nSquared));
+}
+
+void IIRFilter::makeHighPass (const double sampleRate,
+ const double frequency) throw()
+{
+ const double n = tan (double_Pi * frequency / sampleRate);
+ const double nSquared = n * n;
+ const double c1 = 1.0 / (1.0 + sqrt (2.0) * n + nSquared);
+
+ setCoefficients (c1,
+ c1 * -2.0f,
+ c1,
+ 1.0,
+ c1 * 2.0 * (nSquared - 1.0),
+ c1 * (1.0 - sqrt (2.0) * n + nSquared));
+}
+
+void IIRFilter::makeLowShelf (const double sampleRate,
+ const double cutOffFrequency,
+ const double Q,
+ const float gainFactor) throw()
+{
+ jassert (sampleRate > 0);
+ jassert (Q > 0);
+
+ const double A = jmax (0.0f, gainFactor);
+ const double aminus1 = A - 1.0;
+ const double aplus1 = A + 1.0;
+ const double omega = (double_Pi * 2.0 * jmax (cutOffFrequency, 2.0)) / sampleRate;
+ const double coso = cos (omega);
+ const double beta = sin (omega) * sqrt (A) / Q;
+ const double aminus1TimesCoso = aminus1 * coso;
+
+ setCoefficients (A * (aplus1 - aminus1TimesCoso + beta),
+ A * 2.0 * (aminus1 - aplus1 * coso),
+ A * (aplus1 - aminus1TimesCoso - beta),
+ aplus1 + aminus1TimesCoso + beta,
+ -2.0 * (aminus1 + aplus1 * coso),
+ aplus1 + aminus1TimesCoso - beta);
+}
+
+void IIRFilter::makeHighShelf (const double sampleRate,
+ const double cutOffFrequency,
+ const double Q,
+ const float gainFactor) throw()
+{
+ jassert (sampleRate > 0);
+ jassert (Q > 0);
+
+ const double A = jmax (0.0f, gainFactor);
+ const double aminus1 = A - 1.0;
+ const double aplus1 = A + 1.0;
+ const double omega = (double_Pi * 2.0 * jmax (cutOffFrequency, 2.0)) / sampleRate;
+ const double coso = cos (omega);
+ const double beta = sin (omega) * sqrt (A) / Q;
+ const double aminus1TimesCoso = aminus1 * coso;
+
+ setCoefficients (A * (aplus1 + aminus1TimesCoso + beta),
+ A * -2.0 * (aminus1 + aplus1 * coso),
+ A * (aplus1 + aminus1TimesCoso - beta),
+ aplus1 - aminus1TimesCoso + beta,
+ 2.0 * (aminus1 - aplus1 * coso),
+ aplus1 - aminus1TimesCoso - beta);
+}
+
+void IIRFilter::makeBandPass (const double sampleRate,
+ const double centreFrequency,
+ const double Q,
+ const float gainFactor) throw()
+{
+ jassert (sampleRate > 0);
+ jassert (Q > 0);
+
+ const double A = jmax (0.0f, gainFactor);
+ const double omega = (double_Pi * 2.0 * jmax (centreFrequency, 2.0)) / sampleRate;
+ const double alpha = 0.5 * sin (omega) / Q;
+ const double c2 = -2.0 * cos (omega);
+ const double alphaTimesA = alpha * A;
+ const double alphaOverA = alpha / A;
+
+ setCoefficients (1.0 + alphaTimesA,
+ c2,
+ 1.0 - alphaTimesA,
+ 1.0 + alphaOverA,
+ c2,
+ 1.0 - alphaOverA);
+}
+
+void IIRFilter::makeInactive() throw()
+{
+ const ScopedLock sl (processLock);
+ active = false;
+}
+
+void IIRFilter::copyCoefficientsFrom (const IIRFilter& other) throw()
+{
+ const ScopedLock sl (processLock);
+
+ memcpy (coefficients, other.coefficients, sizeof (coefficients));
+ active = other.active;
+}
+
+void IIRFilter::setCoefficients (double c1,
+ double c2,
+ double c3,
+ double c4,
+ double c5,
+ double c6) throw()
+{
+ const double a = 1.0 / c4;
+
+ c1 *= a;
+ c2 *= a;
+ c3 *= a;
+ c5 *= a;
+ c6 *= a;
+
+ const ScopedLock sl (processLock);
+
+ coefficients[0] = (float) c1;
+ coefficients[1] = (float) c2;
+ coefficients[2] = (float) c3;
+ coefficients[3] = (float) c4;
+ coefficients[4] = (float) c5;
+ coefficients[5] = (float) c6;
+
+ active = true;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_IIRFilter.cpp *********/
+
+/********* Start of inlined file: juce_MidiBuffer.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+MidiBuffer::MidiBuffer() throw()
+ : ArrayAllocationBase (32),
+ bytesUsed (0)
+{
+}
+
+MidiBuffer::MidiBuffer (const MidiBuffer& other) throw()
+ : ArrayAllocationBase (32),
+ bytesUsed (other.bytesUsed)
+{
+ ensureAllocatedSize (bytesUsed);
+ memcpy (elements, other.elements, bytesUsed);
+}
+
+const MidiBuffer& MidiBuffer::operator= (const MidiBuffer& other) throw()
+{
+ if (this != &other)
+ {
+ bytesUsed = other.bytesUsed;
+ ensureAllocatedSize (bytesUsed);
+
+ if (bytesUsed > 0)
+ memcpy (elements, other.elements, bytesUsed);
+ }
+
+ return *this;
+}
+
+MidiBuffer::~MidiBuffer() throw()
+{
+}
+
+void MidiBuffer::clear() throw()
+{
+ bytesUsed = 0;
+}
+
+void MidiBuffer::clear (const int startSample,
+ const int numSamples) throw()
+{
+ uint8* const start = findEventAfter (elements, startSample - 1);
+ uint8* const end = findEventAfter (start, startSample + numSamples - 1);
+
+ if (end > start)
+ {
+ const size_t bytesToMove = (size_t) (bytesUsed - (end - elements));
+
+ if (bytesToMove > 0)
+ memmove (start, end, bytesToMove);
+
+ bytesUsed -= (int) (end - start);
+ }
+}
+
+void MidiBuffer::addEvent (const MidiMessage& m,
+ const int sampleNumber) throw()
+{
+ addEvent (m.getRawData(), m.getRawDataSize(), sampleNumber);
+}
+
+static int findActualEventLength (const uint8* const data,
+ const int maxBytes) throw()
+{
+ unsigned int byte = (unsigned int) *data;
+
+ int size = 0;
+
+ if (byte == 0xf0 || byte == 0xf7)
+ {
+ const uint8* d = data + 1;
+
+ while (d < data + maxBytes)
+ if (*d++ == 0xf7)
+ break;
+
+ size = (int) (d - data);
+ }
+ else if (byte == 0xff)
+ {
+ int n;
+ const int bytesLeft = MidiMessage::readVariableLengthVal (data + 1, n);
+ size = jmin (maxBytes, n + 2 + bytesLeft);
+ }
+ else if (byte >= 0x80)
+ {
+ size = jmin (maxBytes, MidiMessage::getMessageLengthFromFirstByte ((uint8) byte));
+ }
+
+ return size;
+}
+
+void MidiBuffer::addEvent (const uint8* const newData,
+ const int maxBytes,
+ const int sampleNumber) throw()
+{
+ const int numBytes = findActualEventLength (newData, maxBytes);
+
+ if (numBytes > 0)
+ {
+ ensureAllocatedSize (bytesUsed + numBytes + 6);
+
+ uint8* d = findEventAfter (elements, sampleNumber);
+ const size_t bytesToMove = (size_t) (bytesUsed - (d - elements));
+
+ if (bytesToMove > 0)
+ memmove (d + numBytes + 6,
+ d,
+ bytesToMove);
+
+ *(int*) d = sampleNumber;
+ d += 4;
+ *(uint16*) d = (uint16) numBytes;
+ d += 2;
+
+ memcpy (d, newData, numBytes);
+
+ bytesUsed += numBytes + 6;
+ }
+}
+
+void MidiBuffer::addEvents (const MidiBuffer& otherBuffer,
+ const int startSample,
+ const int numSamples,
+ const int sampleDeltaToAdd) throw()
+{
+ Iterator i (otherBuffer);
+ i.setNextSamplePosition (startSample);
+
+ const uint8* data;
+ int size, position;
+
+ while (i.getNextEvent (data, size, position)
+ && (position < startSample + numSamples || numSamples < 0))
+ {
+ addEvent (data, size, position + sampleDeltaToAdd);
+ }
+}
+
+bool MidiBuffer::isEmpty() const throw()
+{
+ return bytesUsed == 0;
+}
+
+int MidiBuffer::getNumEvents() const throw()
+{
+ int n = 0;
+ const uint8* d = elements;
+ const uint8* const end = elements + bytesUsed;
+
+ while (d < end)
+ {
+ d += 4;
+ d += 2 + *(const uint16*) d;
+ ++n;
+ }
+
+ return n;
+}
+
+int MidiBuffer::getFirstEventTime() const throw()
+{
+ return (bytesUsed > 0) ? *(const int*) elements : 0;
+}
+
+int MidiBuffer::getLastEventTime() const throw()
+{
+ if (bytesUsed == 0)
+ return 0;
+
+ const uint8* d = elements;
+ const uint8* const endData = d + bytesUsed;
+
+ for (;;)
+ {
+ const uint8* nextOne = d + 6 + * (const uint16*) (d + 4);
+
+ if (nextOne >= endData)
+ return *(const int*) d;
+
+ d = nextOne;
+ }
+}
+
+uint8* MidiBuffer::findEventAfter (uint8* d, const int samplePosition) const throw()
+{
+ const uint8* const endData = elements + bytesUsed;
+
+ while (d < endData && *(int*) d <= samplePosition)
+ {
+ d += 4;
+ d += 2 + *(uint16*) d;
+ }
+
+ return d;
+}
+
+MidiBuffer::Iterator::Iterator (const MidiBuffer& buffer) throw()
+ : buffer (buffer),
+ data (buffer.elements)
+{
+}
+
+MidiBuffer::Iterator::~Iterator() throw()
+{
+}
+
+void MidiBuffer::Iterator::setNextSamplePosition (const int samplePosition) throw()
+{
+ data = buffer.elements;
+ const uint8* dataEnd = buffer.elements + buffer.bytesUsed;
+
+ while (data < dataEnd && *(int*) data < samplePosition)
+ {
+ data += 4;
+ data += 2 + *(uint16*) data;
+ }
+}
+
+bool MidiBuffer::Iterator::getNextEvent (const uint8* &midiData,
+ int& numBytes,
+ int& samplePosition) throw()
+{
+ if (data >= buffer.elements + buffer.bytesUsed)
+ return false;
+
+ samplePosition = *(int*) data;
+ data += 4;
+ numBytes = *(uint16*) data;
+ data += 2;
+ midiData = data;
+ data += numBytes;
+
+ return true;
+}
+
+bool MidiBuffer::Iterator::getNextEvent (MidiMessage& result,
+ int& samplePosition) throw()
+{
+ if (data >= buffer.elements + buffer.bytesUsed)
+ return false;
+
+ samplePosition = *(int*) data;
+ data += 4;
+ const int numBytes = *(uint16*) data;
+ data += 2;
+ result = MidiMessage (data, numBytes, samplePosition);
+ data += numBytes;
+
+ return true;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_MidiBuffer.cpp *********/
+
+/********* Start of inlined file: juce_MidiFile.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+struct TempoInfo
+{
+ double bpm, timestamp;
+};
+
+struct TimeSigInfo
+{
+ int numerator, denominator;
+ double timestamp;
+};
+
+MidiFile::MidiFile() throw()
+ : numTracks (0),
+ timeFormat ((short)(unsigned short)0xe728)
+{
+}
+
+MidiFile::~MidiFile() throw()
+{
+ clear();
+}
+
+void MidiFile::clear() throw()
+{
+ while (numTracks > 0)
+ delete tracks [--numTracks];
+}
+
+int MidiFile::getNumTracks() const throw()
+{
+ return numTracks;
+}
+
+const MidiMessageSequence* MidiFile::getTrack (const int index) const throw()
+{
+ return (((unsigned int) index) < (unsigned int) numTracks) ? tracks[index] : 0;
+}
+
+void MidiFile::addTrack (const MidiMessageSequence& trackSequence) throw()
+{
+ jassert (numTracks < numElementsInArray (tracks));
+
+ if (numTracks < numElementsInArray (tracks))
+ tracks [numTracks++] = new MidiMessageSequence (trackSequence);
+}
+
+short MidiFile::getTimeFormat() const throw()
+{
+ return timeFormat;
+}
+
+void MidiFile::setTicksPerQuarterNote (const int ticks) throw()
+{
+ timeFormat = (short)ticks;
+}
+
+void MidiFile::setSmpteTimeFormat (const int framesPerSecond,
+ const int subframeResolution) throw()
+{
+ timeFormat = (short) (((-framesPerSecond) << 8) | subframeResolution);
+}
+
+void MidiFile::findAllTempoEvents (MidiMessageSequence& tempoChangeEvents) const
+{
+ for (int i = numTracks; --i >= 0;)
+ {
+ const int numEvents = tracks[i]->getNumEvents();
+
+ for (int j = 0; j < numEvents; ++j)
+ {
+ const MidiMessage& m = tracks[i]->getEventPointer (j)->message;
+
+ if (m.isTempoMetaEvent())
+ tempoChangeEvents.addEvent (m);
+ }
+ }
+}
+
+void MidiFile::findAllTimeSigEvents (MidiMessageSequence& timeSigEvents) const
+{
+ for (int i = numTracks; --i >= 0;)
+ {
+ const int numEvents = tracks[i]->getNumEvents();
+
+ for (int j = 0; j < numEvents; ++j)
+ {
+ const MidiMessage& m = tracks[i]->getEventPointer (j)->message;
+
+ if (m.isTimeSignatureMetaEvent())
+ timeSigEvents.addEvent (m);
+ }
+ }
+}
+
+double MidiFile::getLastTimestamp() const
+{
+ double t = 0.0;
+
+ for (int i = numTracks; --i >= 0;)
+ t = jmax (t, tracks[i]->getEndTime());
+
+ return t;
+}
+
+static bool parseMidiHeader (const char* &data,
+ short& timeFormat,
+ short& fileType,
+ short& numberOfTracks)
+{
+ unsigned int ch = (int) bigEndianInt (data);
+ data += 4;
+
+ if (ch != bigEndianInt ("MThd"))
+ {
+ bool ok = false;
+
+ if (ch == bigEndianInt ("RIFF"))
+ {
+ for (int i = 0; i < 8; ++i)
+ {
+ ch = bigEndianInt (data);
+ data += 4;
+
+ if (ch == bigEndianInt ("MThd"))
+ {
+ ok = true;
+ break;
+ }
+ }
+ }
+
+ if (! ok)
+ return false;
+ }
+
+ unsigned int bytesRemaining = bigEndianInt (data);
+ data += 4;
+ fileType = (short)bigEndianShort (data);
+ data += 2;
+ numberOfTracks = (short)bigEndianShort (data);
+ data += 2;
+ timeFormat = (short)bigEndianShort (data);
+ data += 2;
+ bytesRemaining -= 6;
+ data += bytesRemaining;
+
+ return true;
+}
+
+bool MidiFile::readFrom (InputStream& sourceStream)
+{
+ clear();
+ MemoryBlock data;
+
+ const int maxSensibleMidiFileSize = 2 * 1024 * 1024;
+
+ // (put a sanity-check on the file size, as midi files are generally small)
+ if (sourceStream.readIntoMemoryBlock (data, maxSensibleMidiFileSize))
+ {
+ int size = data.getSize();
+ const char* d = (char*) data.getData();
+ short fileType, expectedTracks;
+
+ if (size > 16 && parseMidiHeader (d, timeFormat, fileType, expectedTracks))
+ {
+ size -= (int) (d - (char*) data.getData());
+
+ int track = 0;
+
+ while (size > 0 && track < expectedTracks)
+ {
+ const int chunkType = (int)bigEndianInt (d);
+ d += 4;
+ const int chunkSize = (int)bigEndianInt (d);
+ d += 4;
+
+ if (chunkSize <= 0)
+ break;
+
+ if (size < 0)
+ return false;
+
+ if (chunkType == (int)bigEndianInt ("MTrk"))
+ {
+ readNextTrack (d, chunkSize);
+ }
+
+ size -= chunkSize + 8;
+ d += chunkSize;
+ ++track;
+ }
+
+ return true;
+ }
+ }
+
+ return false;
+}
+
+// a comparator that puts all the note-offs before note-ons that have the same time
+int MidiFile::compareElements (const MidiMessageSequence::MidiEventHolder* const first,
+ const MidiMessageSequence::MidiEventHolder* const second) throw()
+{
+ const double diff = (first->message.getTimeStamp() - second->message.getTimeStamp());
+
+ if (diff == 0)
+ {
+ if (first->message.isNoteOff() && second->message.isNoteOn())
+ return -1;
+ else if (first->message.isNoteOn() && second->message.isNoteOff())
+ return 1;
+ else
+ return 0;
+ }
+ else
+ {
+ return (diff > 0) ? 1 : -1;
+ }
+}
+
+void MidiFile::readNextTrack (const char* data, int size)
+{
+ double time = 0;
+ char lastStatusByte = 0;
+
+ MidiMessageSequence result;
+
+ while (size > 0)
+ {
+ int bytesUsed;
+ const int delay = MidiMessage::readVariableLengthVal ((const uint8*) data, bytesUsed);
+ data += bytesUsed;
+ size -= bytesUsed;
+ time += delay;
+
+ int messSize = 0;
+ const MidiMessage mm ((const uint8*) data, size, messSize, lastStatusByte, time);
+
+ if (messSize <= 0)
+ break;
+
+ size -= messSize;
+ data += messSize;
+
+ result.addEvent (mm);
+
+ const char firstByte = *(mm.getRawData());
+ if ((firstByte & 0xf0) != 0xf0)
+ lastStatusByte = firstByte;
+ }
+
+ // use a sort that puts all the note-offs before note-ons that have the same time
+ result.list.sort (*this, true);
+
+ result.updateMatchedPairs();
+
+ addTrack (result);
+}
+
+static double convertTicksToSeconds (const double time,
+ const MidiMessageSequence& tempoEvents,
+ const int timeFormat)
+{
+ if (timeFormat > 0)
+ {
+ int numer = 4, denom = 4;
+ double tempoTime = 0.0, correctedTempoTime = 0.0;
+ const double tickLen = 1.0 / (timeFormat & 0x7fff);
+ double secsPerTick = 0.5 * tickLen;
+ const int numEvents = tempoEvents.getNumEvents();
+
+ for (int i = 0; i < numEvents; ++i)
+ {
+ const MidiMessage& m = tempoEvents.getEventPointer(i)->message;
+
+ if (time <= m.getTimeStamp())
+ break;
+
+ if (timeFormat > 0)
+ {
+ correctedTempoTime = correctedTempoTime
+ + (m.getTimeStamp() - tempoTime) * secsPerTick;
+ }
+ else
+ {
+ correctedTempoTime = tickLen * m.getTimeStamp() / (((timeFormat & 0x7fff) >> 8) * (timeFormat & 0xff));
+ }
+
+ tempoTime = m.getTimeStamp();
+
+ if (m.isTempoMetaEvent())
+ secsPerTick = tickLen * m.getTempoSecondsPerQuarterNote();
+ else if (m.isTimeSignatureMetaEvent())
+ m.getTimeSignatureInfo (numer, denom);
+
+ while (i + 1 < numEvents)
+ {
+ const MidiMessage& m2 = tempoEvents.getEventPointer(i + 1)->message;
+ if (m2.getTimeStamp() == tempoTime)
+ {
+ ++i;
+
+ if (m2.isTempoMetaEvent())
+ secsPerTick = tickLen * m2.getTempoSecondsPerQuarterNote();
+ else if (m2.isTimeSignatureMetaEvent())
+ m2.getTimeSignatureInfo (numer, denom);
+ }
+ else
+ {
+ break;
+ }
+ }
+
+ }
+
+ return correctedTempoTime + (time - tempoTime) * secsPerTick;
+ }
+ else
+ {
+ return time / (((timeFormat & 0x7fff) >> 8) * (timeFormat & 0xff));
+ }
+}
+
+void MidiFile::convertTimestampTicksToSeconds()
+{
+ MidiMessageSequence tempoEvents;
+ findAllTempoEvents (tempoEvents);
+ findAllTimeSigEvents (tempoEvents);
+
+ for (int i = 0; i < numTracks; ++i)
+ {
+ MidiMessageSequence& ms = *tracks[i];
+
+ for (int j = ms.getNumEvents(); --j >= 0;)
+ {
+ MidiMessage& m = ms.getEventPointer(j)->message;
+
+ m.setTimeStamp (convertTicksToSeconds (m.getTimeStamp(),
+ tempoEvents,
+ timeFormat));
+ }
+ }
+}
+
+static void writeVariableLengthInt (OutputStream& out, unsigned int v)
+{
+ unsigned int buffer = v & 0x7F;
+
+ while ((v >>= 7) != 0)
+ {
+ buffer <<= 8;
+ buffer |= ((v & 0x7F) | 0x80);
+ }
+
+ for (;;)
+ {
+ out.writeByte ((char) buffer);
+
+ if (buffer & 0x80)
+ buffer >>= 8;
+ else
+ break;
+ }
+}
+
+bool MidiFile::writeTo (OutputStream& out)
+{
+ out.writeIntBigEndian ((int) bigEndianInt ("MThd"));
+ out.writeIntBigEndian (6);
+ out.writeShortBigEndian (1); // type
+ out.writeShortBigEndian (numTracks);
+ out.writeShortBigEndian (timeFormat);
+
+ for (int i = 0; i < numTracks; ++i)
+ writeTrack (out, i);
+
+ out.flush();
+
+ return true;
+}
+
+void MidiFile::writeTrack (OutputStream& mainOut,
+ const int trackNum)
+{
+ MemoryOutputStream out;
+
+ const MidiMessageSequence& ms = *tracks[trackNum];
+
+ int lastTick = 0;
+ char lastStatusByte = 0;
+
+ for (int i = 0; i < ms.getNumEvents(); ++i)
+ {
+ const MidiMessage& mm = ms.getEventPointer(i)->message;
+
+ const int tick = roundDoubleToInt (mm.getTimeStamp());
+ const int delta = jmax (0, tick - lastTick);
+ writeVariableLengthInt (out, delta);
+ lastTick = tick;
+
+ const char statusByte = *(mm.getRawData());
+
+ if ((statusByte == lastStatusByte)
+ && ((statusByte & 0xf0) != 0xf0)
+ && i > 0
+ && mm.getRawDataSize() > 1)
+ {
+ out.write (mm.getRawData() + 1, mm.getRawDataSize() - 1);
+ }
+ else
+ {
+ out.write (mm.getRawData(), mm.getRawDataSize());
+ }
+
+ lastStatusByte = statusByte;
+ }
+
+ out.writeByte (0);
+ const MidiMessage m (MidiMessage::endOfTrack());
+ out.write (m.getRawData(),
+ m.getRawDataSize());
+
+ mainOut.writeIntBigEndian ((int)bigEndianInt ("MTrk"));
+ mainOut.writeIntBigEndian (out.getDataSize());
+ mainOut.write (out.getData(), out.getDataSize());
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_MidiFile.cpp *********/
+
+/********* Start of inlined file: juce_MidiKeyboardState.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+MidiKeyboardState::MidiKeyboardState()
+ : listeners (2)
+{
+ zeromem (noteStates, sizeof (noteStates));
+}
+
+MidiKeyboardState::~MidiKeyboardState()
+{
+}
+
+void MidiKeyboardState::reset()
+{
+ const ScopedLock sl (lock);
+ zeromem (noteStates, sizeof (noteStates));
+ eventsToAdd.clear();
+}
+
+bool MidiKeyboardState::isNoteOn (const int midiChannel, const int n) const throw()
+{
+ jassert (midiChannel >= 0 && midiChannel <= 16);
+
+ return ((unsigned int) n) < 128
+ && (noteStates[n] & (1 << (midiChannel - 1))) != 0;
+}
+
+bool MidiKeyboardState::isNoteOnForChannels (const int midiChannelMask, const int n) const throw()
+{
+ return ((unsigned int) n) < 128
+ && (noteStates[n] & midiChannelMask) != 0;
+}
+
+void MidiKeyboardState::noteOn (const int midiChannel, const int midiNoteNumber, const float velocity)
+{
+ jassert (midiChannel >= 0 && midiChannel <= 16);
+ jassert (((unsigned int) midiNoteNumber) < 128);
+
+ const ScopedLock sl (lock);
+
+ if (((unsigned int) midiNoteNumber) < 128)
+ {
+ const int timeNow = (int) Time::getMillisecondCounter();
+ eventsToAdd.addEvent (MidiMessage::noteOn (midiChannel, midiNoteNumber, velocity), timeNow);
+ eventsToAdd.clear (0, timeNow - 500);
+
+ noteOnInternal (midiChannel, midiNoteNumber, velocity);
+ }
+}
+
+void MidiKeyboardState::noteOnInternal (const int midiChannel, const int midiNoteNumber, const float velocity)
+{
+ if (((unsigned int) midiNoteNumber) < 128)
+ {
+ noteStates [midiNoteNumber] |= (1 << (midiChannel - 1));
+
+ for (int i = listeners.size(); --i >= 0;)
+ ((MidiKeyboardStateListener*) listeners.getUnchecked(i))
+ ->handleNoteOn (this, midiChannel, midiNoteNumber, velocity);
+ }
+}
+
+void MidiKeyboardState::noteOff (const int midiChannel, const int midiNoteNumber)
+{
+ const ScopedLock sl (lock);
+
+ if (isNoteOn (midiChannel, midiNoteNumber))
+ {
+ const int timeNow = (int) Time::getMillisecondCounter();
+ eventsToAdd.addEvent (MidiMessage::noteOff (midiChannel, midiNoteNumber), timeNow);
+ eventsToAdd.clear (0, timeNow - 500);
+
+ noteOffInternal (midiChannel, midiNoteNumber);
+ }
+}
+
+void MidiKeyboardState::noteOffInternal (const int midiChannel, const int midiNoteNumber)
+{
+ if (isNoteOn (midiChannel, midiNoteNumber))
+ {
+ noteStates [midiNoteNumber] &= ~(1 << (midiChannel - 1));
+
+ for (int i = listeners.size(); --i >= 0;)
+ ((MidiKeyboardStateListener*) listeners.getUnchecked(i))
+ ->handleNoteOff (this, midiChannel, midiNoteNumber);
+ }
+}
+
+void MidiKeyboardState::allNotesOff (const int midiChannel)
+{
+ const ScopedLock sl (lock);
+
+ if (midiChannel <= 0)
+ {
+ for (int i = 1; i <= 16; ++i)
+ allNotesOff (i);
+ }
+ else
+ {
+ for (int i = 0; i < 128; ++i)
+ noteOff (midiChannel, i);
+ }
+}
+
+void MidiKeyboardState::processNextMidiEvent (const MidiMessage& message)
+{
+ if (message.isNoteOn())
+ {
+ noteOnInternal (message.getChannel(), message.getNoteNumber(), message.getFloatVelocity());
+ }
+ else if (message.isNoteOff())
+ {
+ noteOffInternal (message.getChannel(), message.getNoteNumber());
+ }
+ else if (message.isAllNotesOff())
+ {
+ for (int i = 0; i < 128; ++i)
+ noteOffInternal (message.getChannel(), i);
+ }
+}
+
+void MidiKeyboardState::processNextMidiBuffer (MidiBuffer& buffer,
+ const int startSample,
+ const int numSamples,
+ const bool injectIndirectEvents)
+{
+ MidiBuffer::Iterator i (buffer);
+ MidiMessage message (0xf4, 0.0);
+ int time;
+
+ const ScopedLock sl (lock);
+
+ while (i.getNextEvent (message, time))
+ processNextMidiEvent (message);
+
+ if (injectIndirectEvents)
+ {
+ MidiBuffer::Iterator i2 (eventsToAdd);
+ const int firstEventToAdd = eventsToAdd.getFirstEventTime();
+ const double scaleFactor = numSamples / (double) (eventsToAdd.getLastEventTime() + 1 - firstEventToAdd);
+
+ while (i2.getNextEvent (message, time))
+ {
+ const int pos = jlimit (0, numSamples - 1, roundDoubleToInt ((time - firstEventToAdd) * scaleFactor));
+ buffer.addEvent (message, startSample + pos);
+ }
+ }
+
+ eventsToAdd.clear();
+}
+
+void MidiKeyboardState::addListener (MidiKeyboardStateListener* const listener) throw()
+{
+ const ScopedLock sl (lock);
+ listeners.addIfNotAlreadyThere (listener);
+}
+
+void MidiKeyboardState::removeListener (MidiKeyboardStateListener* const listener) throw()
+{
+ const ScopedLock sl (lock);
+ listeners.removeValue (listener);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_MidiKeyboardState.cpp *********/
+
+/********* Start of inlined file: juce_MidiMessage.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+int MidiMessage::readVariableLengthVal (const uint8* data,
+ int& numBytesUsed) throw()
+{
+ numBytesUsed = 0;
+ int v = 0;
+ int i;
+
+ do
+ {
+ i = (int) *data++;
+
+ if (++numBytesUsed > 6)
+ break;
+
+ v = (v << 7) + (i & 0x7f);
+
+ } while (i & 0x80);
+
+ return v;
+}
+
+int MidiMessage::getMessageLengthFromFirstByte (const uint8 firstByte) throw()
+{
+ // this method only works for valid starting bytes of a short midi message
+ jassert (firstByte >= 0x80
+ && firstByte != 0xff
+ && firstByte != 0xf0
+ && firstByte != 0xf7);
+
+ static const char messageLengths[] =
+ {
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
+ 1, 2, 3, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1
+ };
+
+ return messageLengths [firstByte & 0x7f];
+}
+
+MidiMessage::MidiMessage (const uint8* const d,
+ const int dataSize,
+ const double t) throw()
+ : timeStamp (t),
+ message (0),
+ size (dataSize)
+{
+ jassert (dataSize > 0);
+
+ if (dataSize <= 4)
+ data = (uint8*) &message;
+ else
+ data = (uint8*) juce_malloc (dataSize);
+
+ memcpy (data, d, dataSize);
+
+ // check that the length matches the data..
+ jassert (size > 3 || *d >= 0xf0 || getMessageLengthFromFirstByte (*d) == size);
+}
+
+MidiMessage::MidiMessage (const int byte1,
+ const double t) throw()
+ : timeStamp (t),
+ data ((uint8*) &message),
+ size (1)
+{
+ data[0] = (uint8) byte1;
+
+ // check that the length matches the data..
+ jassert (byte1 >= 0xf0 || getMessageLengthFromFirstByte ((uint8) byte1) == 1);
+}
+
+MidiMessage::MidiMessage (const int byte1,
+ const int byte2,
+ const double t) throw()
+ : timeStamp (t),
+ data ((uint8*) &message),
+ size (2)
+{
+ data[0] = (uint8) byte1;
+ data[1] = (uint8) byte2;
+
+ // check that the length matches the data..
+ jassert (byte1 >= 0xf0 || getMessageLengthFromFirstByte ((uint8) byte1) == 2);
+}
+
+MidiMessage::MidiMessage (const int byte1,
+ const int byte2,
+ const int byte3,
+ const double t) throw()
+ : timeStamp (t),
+ data ((uint8*) &message),
+ size (3)
+{
+ data[0] = (uint8) byte1;
+ data[1] = (uint8) byte2;
+ data[2] = (uint8) byte3;
+
+ // check that the length matches the data..
+ jassert (byte1 >= 0xf0 || getMessageLengthFromFirstByte ((uint8) byte1) == 3);
+}
+
+MidiMessage::MidiMessage (const MidiMessage& other) throw()
+ : timeStamp (other.timeStamp),
+ message (other.message),
+ size (other.size)
+{
+ if (other.data != (uint8*) &other.message)
+ {
+ data = (uint8*) juce_malloc (size);
+ memcpy (data, other.data, size);
+ }
+ else
+ {
+ data = (uint8*) &message;
+ }
+}
+
+MidiMessage::MidiMessage (const MidiMessage& other,
+ const double newTimeStamp) throw()
+ : timeStamp (newTimeStamp),
+ message (other.message),
+ size (other.size)
+{
+ if (other.data != (uint8*) &other.message)
+ {
+ data = (uint8*) juce_malloc (size);
+ memcpy (data, other.data, size);
+ }
+ else
+ {
+ data = (uint8*) &message;
+ }
+}
+
+MidiMessage::MidiMessage (const uint8* src,
+ int sz,
+ int& numBytesUsed,
+ const uint8 lastStatusByte,
+ double t) throw()
+ : timeStamp (t),
+ data ((uint8*) &message),
+ message (0)
+{
+ unsigned int byte = (unsigned int) *src;
+
+ if (byte < 0x80)
+ {
+ byte = (unsigned int) (uint8) lastStatusByte;
+ numBytesUsed = -1;
+ }
+ else
+ {
+ numBytesUsed = 0;
+ --sz;
+ ++src;
+ }
+
+ if (byte >= 0x80)
+ {
+ if (byte == 0xf0)
+ {
+ const uint8* d = (const uint8*) src;
+
+ while (d < src + sz)
+ {
+ if (*d >= 0x80) // stop if we hit a status byte, and don't include it in this message
+ {
+ if (*d == 0xf7) // include an 0xf7 if we hit one
+ ++d;
+
+ break;
+ }
+
+ ++d;
+ }
+
+ size = 1 + (int) (d - src);
+
+ data = (uint8*) juce_malloc (size);
+ *data = (uint8) byte;
+ memcpy (data + 1, src, size - 1);
+ }
+ else if (byte == 0xff)
+ {
+ int n;
+ const int bytesLeft = readVariableLengthVal (src + 1, n);
+ size = jmin (sz + 1, n + 2 + bytesLeft);
+
+ data = (uint8*) juce_malloc (size);
+ *data = (uint8) byte;
+ memcpy (data + 1, src, size - 1);
+ }
+ else
+ {
+ size = getMessageLengthFromFirstByte ((uint8) byte);
+ *data = (uint8) byte;
+
+ if (size > 1)
+ {
+ data[1] = src[0];
+
+ if (size > 2)
+ data[2] = src[1];
+ }
+ }
+
+ numBytesUsed += size;
+ }
+ else
+ {
+ message = 0;
+ size = 0;
+ }
+}
+
+const MidiMessage& MidiMessage::operator= (const MidiMessage& other) throw()
+{
+ if (this == &other)
+ return *this;
+
+ timeStamp = other.timeStamp;
+ size = other.size;
+ message = other.message;
+
+ if (data != (uint8*) &message)
+ juce_free (data);
+
+ if (other.data != (uint8*) &other.message)
+ {
+ data = (uint8*) juce_malloc (size);
+ memcpy (data, other.data, size);
+ }
+ else
+ {
+ data = (uint8*) &message;
+ }
+
+ return *this;
+}
+
+MidiMessage::~MidiMessage() throw()
+{
+ if (data != (uint8*) &message)
+ juce_free (data);
+}
+
+int MidiMessage::getChannel() const throw()
+{
+ if ((data[0] & 0xf0) != 0xf0)
+ return (data[0] & 0xf) + 1;
+ else
+ return 0;
+}
+
+bool MidiMessage::isForChannel (const int channel) const throw()
+{
+ return ((data[0] & 0xf) == channel - 1)
+ && ((data[0] & 0xf0) != 0xf0);
+}
+
+void MidiMessage::setChannel (const int channel) throw()
+{
+ if ((data[0] & 0xf0) != (uint8) 0xf0)
+ data[0] = (uint8) ((data[0] & (uint8)0xf0)
+ | (uint8)(channel - 1));
+}
+
+bool MidiMessage::isNoteOn() const throw()
+{
+ return ((data[0] & 0xf0) == 0x90)
+ && (data[2] != 0);
+}
+
+bool MidiMessage::isNoteOff() const throw()
+{
+ return ((data[0] & 0xf0) == 0x80)
+ || ((data[2] == 0) && ((data[0] & 0xf0) == 0x90));
+}
+
+bool MidiMessage::isNoteOnOrOff() const throw()
+{
+ const int d = data[0] & 0xf0;
+ return (d == 0x90) || (d == 0x80);
+}
+
+int MidiMessage::getNoteNumber() const throw()
+{
+ return data[1];
+}
+
+void MidiMessage::setNoteNumber (const int newNoteNumber) throw()
+{
+ if (isNoteOnOrOff())
+ data[1] = (uint8) jlimit (0, 127, newNoteNumber);
+}
+
+uint8 MidiMessage::getVelocity() const throw()
+{
+ if (isNoteOnOrOff())
+ return data[2];
+ else
+ return 0;
+}
+
+float MidiMessage::getFloatVelocity() const throw()
+{
+ return getVelocity() * (1.0f / 127.0f);
+}
+
+void MidiMessage::setVelocity (const float newVelocity) throw()
+{
+ if (isNoteOnOrOff())
+ data[2] = (uint8) jlimit (0, 0x7f, roundFloatToInt (newVelocity * 127.0f));
+}
+
+void MidiMessage::multiplyVelocity (const float scaleFactor) throw()
+{
+ if (isNoteOnOrOff())
+ data[2] = (uint8) jlimit (0, 0x7f, roundFloatToInt (scaleFactor * data[2]));
+}
+
+bool MidiMessage::isAftertouch() const throw()
+{
+ return (data[0] & 0xf0) == 0xa0;
+}
+
+int MidiMessage::getAfterTouchValue() const throw()
+{
+ return data[2];
+}
+
+const MidiMessage MidiMessage::aftertouchChange (const int channel,
+ const int noteNum,
+ const int aftertouchValue) throw()
+{
+ jassert (channel > 0 && channel <= 16);
+ jassert (((unsigned int) noteNum) <= 127);
+ jassert (((unsigned int) aftertouchValue) <= 127);
+
+ return MidiMessage (0xa0 | jlimit (0, 15, channel - 1),
+ noteNum & 0x7f,
+ aftertouchValue & 0x7f);
+}
+
+bool MidiMessage::isChannelPressure() const throw()
+{
+ return (data[0] & 0xf0) == 0xd0;
+}
+
+int MidiMessage::getChannelPressureValue() const throw()
+{
+ jassert (isChannelPressure());
+
+ return data[1];
+}
+
+const MidiMessage MidiMessage::channelPressureChange (const int channel,
+ const int pressure) throw()
+{
+ jassert (channel > 0 && channel <= 16);
+ jassert (((unsigned int) pressure) <= 127);
+
+ return MidiMessage (0xd0 | jlimit (0, 15, channel - 1),
+ pressure & 0x7f);
+}
+
+bool MidiMessage::isProgramChange() const throw()
+{
+ return (data[0] & 0xf0) == 0xc0;
+}
+
+int MidiMessage::getProgramChangeNumber() const throw()
+{
+ return data[1];
+}
+
+const MidiMessage MidiMessage::programChange (const int channel,
+ const int programNumber) throw()
+{
+ jassert (channel > 0 && channel <= 16);
+
+ return MidiMessage (0xc0 | jlimit (0, 15, channel - 1),
+ programNumber & 0x7f);
+}
+
+bool MidiMessage::isPitchWheel() const throw()
+{
+ return (data[0] & 0xf0) == 0xe0;
+}
+
+int MidiMessage::getPitchWheelValue() const throw()
+{
+ return data[1] | (data[2] << 7);
+}
+
+const MidiMessage MidiMessage::pitchWheel (const int channel,
+ const int position) throw()
+{
+ jassert (channel > 0 && channel <= 16);
+ jassert (((unsigned int) position) <= 0x3fff);
+
+ return MidiMessage (0xe0 | jlimit (0, 15, channel - 1),
+ position & 127,
+ (position >> 7) & 127);
+}
+
+bool MidiMessage::isController() const throw()
+{
+ return (data[0] & 0xf0) == 0xb0;
+}
+
+int MidiMessage::getControllerNumber() const throw()
+{
+ jassert (isController());
+
+ return data[1];
+}
+
+int MidiMessage::getControllerValue() const throw()
+{
+ jassert (isController());
+
+ return data[2];
+}
+
+const MidiMessage MidiMessage::controllerEvent (const int channel,
+ const int controllerType,
+ const int value) throw()
+{
+ // the channel must be between 1 and 16 inclusive
+ jassert (channel > 0 && channel <= 16);
+
+ return MidiMessage (0xb0 | jlimit (0, 15, channel - 1),
+ controllerType & 127,
+ value & 127);
+}
+
+const MidiMessage MidiMessage::noteOn (const int channel,
+ const int noteNumber,
+ const float velocity) throw()
+{
+ return noteOn (channel, noteNumber, (uint8)(velocity * 127.0f));
+}
+
+const MidiMessage MidiMessage::noteOn (const int channel,
+ const int noteNumber,
+ const uint8 velocity) throw()
+{
+ jassert (channel > 0 && channel <= 16);
+ jassert (((unsigned int) noteNumber) <= 127);
+
+ return MidiMessage (0x90 | jlimit (0, 15, channel - 1),
+ noteNumber & 127,
+ jlimit (0, 127, roundFloatToInt (velocity)));
+}
+
+const MidiMessage MidiMessage::noteOff (const int channel,
+ const int noteNumber) throw()
+{
+ jassert (channel > 0 && channel <= 16);
+ jassert (((unsigned int) noteNumber) <= 127);
+
+ return MidiMessage (0x80 | jlimit (0, 15, channel - 1), noteNumber & 127, 0);
+}
+
+const MidiMessage MidiMessage::allNotesOff (const int channel) throw()
+{
+ jassert (channel > 0 && channel <= 16);
+
+ return controllerEvent (channel, 123, 0);
+}
+
+bool MidiMessage::isAllNotesOff() const throw()
+{
+ return (data[0] & 0xf0) == 0xb0
+ && data[1] == 123;
+}
+
+const MidiMessage MidiMessage::allSoundOff (const int channel) throw()
+{
+ return controllerEvent (channel, 120, 0);
+}
+
+bool MidiMessage::isAllSoundOff() const throw()
+{
+ return (data[0] & 0xf0) == 0xb0
+ && data[1] == 120;
+}
+
+const MidiMessage MidiMessage::allControllersOff (const int channel) throw()
+{
+ return controllerEvent (channel, 121, 0);
+}
+
+const MidiMessage MidiMessage::masterVolume (const float volume) throw()
+{
+ const int vol = jlimit (0, 0x3fff, roundFloatToInt (volume * 0x4000));
+
+ uint8 buf[8];
+ buf[0] = 0xf0;
+ buf[1] = 0x7f;
+ buf[2] = 0x7f;
+ buf[3] = 0x04;
+ buf[4] = 0x01;
+ buf[5] = (uint8) (vol & 0x7f);
+ buf[6] = (uint8) (vol >> 7);
+ buf[7] = 0xf7;
+
+ return MidiMessage (buf, 8);
+}
+
+bool MidiMessage::isSysEx() const throw()
+{
+ return *data == 0xf0;
+}
+
+const MidiMessage MidiMessage::createSysExMessage (const uint8* sysexData,
+ const int dataSize) throw()
+{
+ MemoryBlock mm (dataSize + 2);
+ uint8* const m = (uint8*) mm.getData();
+
+ m[0] = 0xf0;
+ memcpy (m + 1, sysexData, dataSize);
+ m[dataSize + 1] = 0xf7;
+
+ return MidiMessage (m, dataSize + 2);
+}
+
+const uint8* MidiMessage::getSysExData() const throw()
+{
+ return (isSysEx()) ? getRawData() + 1
+ : 0;
+}
+
+int MidiMessage::getSysExDataSize() const throw()
+{
+ return (isSysEx()) ? size - 2
+ : 0;
+}
+
+bool MidiMessage::isMetaEvent() const throw()
+{
+ return *data == 0xff;
+}
+
+bool MidiMessage::isActiveSense() const throw()
+{
+ return *data == 0xfe;
+}
+
+int MidiMessage::getMetaEventType() const throw()
+{
+ if (*data != 0xff)
+ return -1;
+ else
+ return data[1];
+}
+
+int MidiMessage::getMetaEventLength() const throw()
+{
+ if (*data == 0xff)
+ {
+ int n;
+ return jmin (size - 2, readVariableLengthVal (data + 2, n));
+ }
+
+ return 0;
+}
+
+const uint8* MidiMessage::getMetaEventData() const throw()
+{
+ int n;
+ const uint8* d = data + 2;
+ readVariableLengthVal (d, n);
+ return d + n;
+}
+
+bool MidiMessage::isTrackMetaEvent() const throw()
+{
+ return getMetaEventType() == 0;
+}
+
+bool MidiMessage::isEndOfTrackMetaEvent() const throw()
+{
+ return getMetaEventType() == 47;
+}
+
+bool MidiMessage::isTextMetaEvent() const throw()
+{
+ const int t = getMetaEventType();
+
+ return t > 0 && t < 16;
+}
+
+const String MidiMessage::getTextFromTextMetaEvent() const throw()
+{
+ return String ((const char*) getMetaEventData(),
+ getMetaEventLength());
+}
+
+bool MidiMessage::isTrackNameEvent() const throw()
+{
+ return (data[1] == 3)
+ && (*data == 0xff);
+}
+
+bool MidiMessage::isTempoMetaEvent() const throw()
+{
+ return (data[1] == 81)
+ && (*data == 0xff);
+}
+
+bool MidiMessage::isMidiChannelMetaEvent() const throw()
+{
+ return (data[1] == 0x20)
+ && (*data == 0xff)
+ && (data[2] == 1);
+}
+
+int MidiMessage::getMidiChannelMetaEventChannel() const throw()
+{
+ return data[3] + 1;
+}
+
+double MidiMessage::getTempoSecondsPerQuarterNote() const throw()
+{
+ if (! isTempoMetaEvent())
+ return 0.0;
+
+ const uint8* const d = getMetaEventData();
+
+ return (((unsigned int) d[0] << 16)
+ | ((unsigned int) d[1] << 8)
+ | d[2])
+ / 1000000.0;
+}
+
+double MidiMessage::getTempoMetaEventTickLength (const short timeFormat) const throw()
+{
+ if (timeFormat > 0)
+ {
+ if (! isTempoMetaEvent())
+ return 0.5 / timeFormat;
+
+ return getTempoSecondsPerQuarterNote() / timeFormat;
+ }
+ else
+ {
+ const int frameCode = (-timeFormat) >> 8;
+ double framesPerSecond;
+
+ switch (frameCode)
+ {
+ case 24: framesPerSecond = 24.0; break;
+ case 25: framesPerSecond = 25.0; break;
+ case 29: framesPerSecond = 29.97; break;
+ case 30: framesPerSecond = 30.0; break;
+ default: framesPerSecond = 30.0; break;
+ }
+
+ return (1.0 / framesPerSecond) / (timeFormat & 0xff);
+ }
+}
+
+const MidiMessage MidiMessage::tempoMetaEvent (int microsecondsPerQuarterNote) throw()
+{
+ uint8 d[8];
+ d[0] = 0xff;
+ d[1] = 81;
+ d[2] = 3;
+ d[3] = (uint8) (microsecondsPerQuarterNote >> 16);
+ d[4] = (uint8) ((microsecondsPerQuarterNote >> 8) & 0xff);
+ d[5] = (uint8) (microsecondsPerQuarterNote & 0xff);
+
+ return MidiMessage (d, 6, 0.0);
+}
+
+bool MidiMessage::isTimeSignatureMetaEvent() const throw()
+{
+ return (data[1] == 0x58)
+ && (*data == (uint8) 0xff);
+}
+
+void MidiMessage::getTimeSignatureInfo (int& numerator,
+ int& denominator) const throw()
+{
+ if (isTimeSignatureMetaEvent())
+ {
+ const uint8* const d = getMetaEventData();
+ numerator = d[0];
+ denominator = 1 << d[1];
+ }
+ else
+ {
+ numerator = 4;
+ denominator = 4;
+ }
+}
+
+const MidiMessage MidiMessage::timeSignatureMetaEvent (const int numerator,
+ const int denominator) throw()
+{
+ uint8 d[8];
+ d[0] = 0xff;
+ d[1] = 0x58;
+ d[2] = 0x04;
+ d[3] = (uint8) numerator;
+
+ int n = 1;
+ int powerOfTwo = 0;
+
+ while (n < denominator)
+ {
+ n <<= 1;
+ ++powerOfTwo;
+ }
+
+ d[4] = (uint8) powerOfTwo;
+ d[5] = 0x01;
+ d[6] = 96;
+
+ return MidiMessage (d, 7, 0.0);
+}
+
+const MidiMessage MidiMessage::midiChannelMetaEvent (const int channel) throw()
+{
+ uint8 d[8];
+ d[0] = 0xff;
+ d[1] = 0x20;
+ d[2] = 0x01;
+ d[3] = (uint8) jlimit (0, 0xff, channel - 1);
+
+ return MidiMessage (d, 4, 0.0);
+}
+
+bool MidiMessage::isKeySignatureMetaEvent() const throw()
+{
+ return getMetaEventType() == 89;
+}
+
+int MidiMessage::getKeySignatureNumberOfSharpsOrFlats() const throw()
+{
+ return (int) *getMetaEventData();
+}
+
+const MidiMessage MidiMessage::endOfTrack() throw()
+{
+ return MidiMessage (0xff, 0x2f, 0, 0.0);
+}
+
+bool MidiMessage::isSongPositionPointer() const throw()
+{
+ return *data == 0xf2;
+}
+
+int MidiMessage::getSongPositionPointerMidiBeat() const throw()
+{
+ return data[1] | (data[2] << 7);
+}
+
+const MidiMessage MidiMessage::songPositionPointer (const int positionInMidiBeats) throw()
+{
+ return MidiMessage (0xf2,
+ positionInMidiBeats & 127,
+ (positionInMidiBeats >> 7) & 127);
+}
+
+bool MidiMessage::isMidiStart() const throw()
+{
+ return *data == 0xfa;
+}
+
+const MidiMessage MidiMessage::midiStart() throw()
+{
+ return MidiMessage (0xfa);
+}
+
+bool MidiMessage::isMidiContinue() const throw()
+{
+ return *data == 0xfb;
+}
+
+const MidiMessage MidiMessage::midiContinue() throw()
+{
+ return MidiMessage (0xfb);
+}
+
+bool MidiMessage::isMidiStop() const throw()
+{
+ return *data == 0xfc;
+}
+
+const MidiMessage MidiMessage::midiStop() throw()
+{
+ return MidiMessage (0xfc);
+}
+
+bool MidiMessage::isMidiClock() const throw()
+{
+ return *data == 0xf8;
+}
+
+const MidiMessage MidiMessage::midiClock() throw()
+{
+ return MidiMessage (0xf8);
+}
+
+bool MidiMessage::isQuarterFrame() const throw()
+{
+ return *data == 0xf1;
+}
+
+int MidiMessage::getQuarterFrameSequenceNumber() const throw()
+{
+ return ((int) data[1]) >> 4;
+}
+
+int MidiMessage::getQuarterFrameValue() const throw()
+{
+ return ((int) data[1]) & 0x0f;
+}
+
+const MidiMessage MidiMessage::quarterFrame (const int sequenceNumber,
+ const int value) throw()
+{
+ return MidiMessage (0xf1, (sequenceNumber << 4) | value);
+}
+
+bool MidiMessage::isFullFrame() const throw()
+{
+ return data[0] == 0xf0
+ && data[1] == 0x7f
+ && size >= 10
+ && data[3] == 0x01
+ && data[4] == 0x01;
+}
+
+void MidiMessage::getFullFrameParameters (int& hours,
+ int& minutes,
+ int& seconds,
+ int& frames,
+ MidiMessage::SmpteTimecodeType& timecodeType) const throw()
+{
+ jassert (isFullFrame());
+
+ timecodeType = (SmpteTimecodeType) (data[5] >> 5);
+ hours = data[5] & 0x1f;
+ minutes = data[6];
+ seconds = data[7];
+ frames = data[8];
+}
+
+const MidiMessage MidiMessage::fullFrame (const int hours,
+ const int minutes,
+ const int seconds,
+ const int frames,
+ MidiMessage::SmpteTimecodeType timecodeType)
+{
+ uint8 d[10];
+ d[0] = 0xf0;
+ d[1] = 0x7f;
+ d[2] = 0x7f;
+ d[3] = 0x01;
+ d[4] = 0x01;
+ d[5] = (uint8) ((hours & 0x01f) | (timecodeType << 5));
+ d[6] = (uint8) minutes;
+ d[7] = (uint8) seconds;
+ d[8] = (uint8) frames;
+ d[9] = 0xf7;
+
+ return MidiMessage (d, 10, 0.0);
+}
+
+bool MidiMessage::isMidiMachineControlMessage() const throw()
+{
+ return data[0] == 0xf0
+ && data[1] == 0x7f
+ && data[3] == 0x06
+ && size > 5;
+}
+
+MidiMessage::MidiMachineControlCommand MidiMessage::getMidiMachineControlCommand() const throw()
+{
+ jassert (isMidiMachineControlMessage());
+
+ return (MidiMachineControlCommand) data[4];
+}
+
+const MidiMessage MidiMessage::midiMachineControlCommand (MidiMessage::MidiMachineControlCommand command)
+{
+ uint8 d[6];
+ d[0] = 0xf0;
+ d[1] = 0x7f;
+ d[2] = 0x00;
+ d[3] = 0x06;
+ d[4] = (uint8) command;
+ d[5] = 0xf7;
+
+ return MidiMessage (d, 6, 0.0);
+}
+
+bool MidiMessage::isMidiMachineControlGoto (int& hours,
+ int& minutes,
+ int& seconds,
+ int& frames) const throw()
+{
+ if (size >= 12
+ && data[0] == 0xf0
+ && data[1] == 0x7f
+ && data[3] == 0x06
+ && data[4] == 0x44
+ && data[5] == 0x06
+ && data[6] == 0x01)
+ {
+ hours = data[7] % 24; // (that some machines send out hours > 24)
+ minutes = data[8];
+ seconds = data[9];
+ frames = data[10];
+
+ return true;
+ }
+
+ return false;
+}
+
+const MidiMessage MidiMessage::midiMachineControlGoto (int hours,
+ int minutes,
+ int seconds,
+ int frames)
+{
+ uint8 d[12];
+ d[0] = 0xf0;
+ d[1] = 0x7f;
+ d[2] = 0x00;
+ d[3] = 0x06;
+ d[4] = 0x44;
+ d[5] = 0x06;
+ d[6] = 0x01;
+ d[7] = (uint8) hours;
+ d[8] = (uint8) minutes;
+ d[9] = (uint8) seconds;
+ d[10] = (uint8) frames;
+ d[11] = 0xf7;
+
+ return MidiMessage (d, 12, 0.0);
+}
+
+const String MidiMessage::getMidiNoteName (int note,
+ bool useSharps,
+ bool includeOctaveNumber,
+ int octaveNumForMiddleC) throw()
+{
+ static const char* const sharpNoteNames[] = { "C", "C#", "D", "D#", "E",
+ "F", "F#", "G", "G#", "A",
+ "A#", "B" };
+
+ static const char* const flatNoteNames[] = { "C", "Db", "D", "Eb", "E",
+ "F", "Gb", "G", "Ab", "A",
+ "Bb", "B" };
+
+ if (((unsigned int) note) < 128)
+ {
+ const String s ((useSharps) ? sharpNoteNames [note % 12]
+ : flatNoteNames [note % 12]);
+
+ if (includeOctaveNumber)
+ return s + String (note / 12 + (octaveNumForMiddleC - 5));
+ else
+ return s;
+ }
+
+ return String::empty;
+}
+
+const double MidiMessage::getMidiNoteInHertz (int noteNumber) throw()
+{
+ noteNumber -= 12 * 6 + 9; // now 0 = A440
+ return 440.0 * pow (2.0, noteNumber / 12.0);
+}
+
+const String MidiMessage::getGMInstrumentName (int n) throw()
+{
+ const char *names[] =
+ {
+ "Acoustic Grand Piano", "Bright Acoustic Piano", "Electric Grand Piano", "Honky-tonk Piano",
+ "Electric Piano 1", "Electric Piano 2", "Harpsichord", "Clavinet", "Celesta", "Glockenspiel",
+ "Music Box", "Vibraphone", "Marimba", "Xylophone", "Tubular Bells", "Dulcimer", "Drawbar Organ",
+ "Percussive Organ", "Rock Organ", "Church Organ", "Reed Organ", "Accordion", "Harmonica",
+ "Tango Accordion", "Acoustic Guitar (nylon)", "Acoustic Guitar (steel)", "Electric Guitar (jazz)",
+ "Electric Guitar (clean)", "Electric Guitar (mute)", "Overdriven Guitar", "Distortion Guitar",
+ "Guitar Harmonics", "Acoustic Bass", "Electric Bass (finger)", "Electric Bass (pick)",
+ "Fretless Bass", "Slap Bass 1", "Slap Bass 2", "Synth Bass 1", "Synth Bass 2", "Violin",
+ "Viola", "Cello", "Contrabass", "Tremolo Strings", "Pizzicato Strings", "Orchestral Harp",
+ "Timpani", "String Ensemble 1", "String Ensemble 2", "SynthStrings 1", "SynthStrings 2",
+ "Choir Aahs", "Voice Oohs", "Synth Voice", "Orchestra Hit", "Trumpet", "Trombone", "Tuba",
+ "Muted Trumpet", "French Horn", "Brass Section", "SynthBrass 1", "SynthBrass 2", "Soprano Sax",
+ "Alto Sax", "Tenor Sax", "Baritone Sax", "Oboe", "English Horn", "Bassoon", "Clarinet",
+ "Piccolo", "Flute", "Recorder", "Pan Flute", "Blown Bottle", "Shakuhachi", "Whistle",
+ "Ocarina", "Lead 1 (square)", "Lead 2 (sawtooth)", "Lead 3 (calliope)", "Lead 4 (chiff)",
+ "Lead 5 (charang)", "Lead 6 (voice)", "Lead 7 (fifths)", "Lead 8 (bass+lead)", "Pad 1 (new age)",
+ "Pad 2 (warm)", "Pad 3 (polysynth)", "Pad 4 (choir)", "Pad 5 (bowed)", "Pad 6 (metallic)",
+ "Pad 7 (halo)", "Pad 8 (sweep)", "FX 1 (rain)", "FX 2 (soundtrack)", "FX 3 (crystal)",
+ "FX 4 (atmosphere)", "FX 5 (brightness)", "FX 6 (goblins)", "FX 7 (echoes)", "FX 8 (sci-fi)",
+ "Sitar", "Banjo", "Shamisen", "Koto", "Kalimba", "Bag pipe", "Fiddle", "Shanai", "Tinkle Bell",
+ "Agogo", "Steel Drums", "Woodblock", "Taiko Drum", "Melodic Tom", "Synth Drum", "Reverse Cymbal",
+ "Guitar Fret Noise", "Breath Noise", "Seashore", "Bird Tweet", "Telephone Ring", "Helicopter",
+ "Applause", "Gunshot"
+ };
+
+ return (((unsigned int) n) < 128) ? names[n]
+ : (const char*)0;
+}
+
+const String MidiMessage::getGMInstrumentBankName (int n) throw()
+{
+ const char* names[] =
+ {
+ "Piano", "Chromatic Percussion", "Organ", "Guitar",
+ "Bass", "Strings", "Ensemble", "Brass",
+ "Reed", "Pipe", "Synth Lead", "Synth Pad",
+ "Synth Effects", "Ethnic", "Percussive", "Sound Effects"
+ };
+
+ return (((unsigned int) n) <= 15) ? names[n]
+ : (const char*)0;
+}
+
+const String MidiMessage::getRhythmInstrumentName (int n) throw()
+{
+ const char* names[] =
+ {
+ "Acoustic Bass Drum", "Bass Drum 1", "Side Stick", "Acoustic Snare",
+ "Hand Clap", "Electric Snare", "Low Floor Tom", "Closed Hi-Hat", "High Floor Tom",
+ "Pedal Hi-Hat", "Low Tom", "Open Hi-Hat", "Low-Mid Tom", "Hi-Mid Tom", "Crash Cymbal 1",
+ "High Tom", "Ride Cymbal 1", "Chinese Cymbal", "Ride Bell", "Tambourine", "Splash Cymbal",
+ "Cowbell", "Crash Cymbal 2", "Vibraslap", "Ride Cymbal 2", "Hi Bongo", "Low Bongo",
+ "Mute Hi Conga", "Open Hi Conga", "Low Conga", "High Timbale", "Low Timbale", "High Agogo",
+ "Low Agogo", "Cabasa", "Maracas", "Short Whistle", "Long Whistle", "Short Guiro",
+ "Long Guiro", "Claves", "Hi Wood Block", "Low Wood Block", "Mute Cuica", "Open Cuica",
+ "Mute Triangle", "Open Triangle"
+ };
+
+ return (n >= 35 && n <= 81) ? names [n - 35]
+ : (const char*)0;
+}
+
+const String MidiMessage::getControllerName (int n) throw()
+{
+ const char* names[] =
+ {
+ "Bank Select", "Modulation Wheel (coarse)", "Breath controller (coarse)",
+ 0, "Foot Pedal (coarse)", "Portamento Time (coarse)",
+ "Data Entry (coarse)", "Volume (coarse)", "Balance (coarse)",
+ 0, "Pan position (coarse)", "Expression (coarse)", "Effect Control 1 (coarse)",
+ "Effect Control 2 (coarse)", 0, 0, "General Purpose Slider 1", "General Purpose Slider 2",
+ "General Purpose Slider 3", "General Purpose Slider 4", 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, "Bank Select (fine)", "Modulation Wheel (fine)", "Breath controller (fine)",
+ 0, "Foot Pedal (fine)", "Portamento Time (fine)", "Data Entry (fine)", "Volume (fine)",
+ "Balance (fine)", 0, "Pan position (fine)", "Expression (fine)", "Effect Control 1 (fine)",
+ "Effect Control 2 (fine)", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ "Hold Pedal (on/off)", "Portamento (on/off)", "Sustenuto Pedal (on/off)", "Soft Pedal (on/off)",
+ "Legato Pedal (on/off)", "Hold 2 Pedal (on/off)", "Sound Variation", "Sound Timbre",
+ "Sound Release Time", "Sound Attack Time", "Sound Brightness", "Sound Control 6",
+ "Sound Control 7", "Sound Control 8", "Sound Control 9", "Sound Control 10",
+ "General Purpose Button 1 (on/off)", "General Purpose Button 2 (on/off)",
+ "General Purpose Button 3 (on/off)", "General Purpose Button 4 (on/off)",
+ 0, 0, 0, 0, 0, 0, 0, "Reverb Level", "Tremolo Level", "Chorus Level", "Celeste Level",
+ "Phaser Level", "Data Button increment", "Data Button decrement", "Non-registered Parameter (fine)",
+ "Non-registered Parameter (coarse)", "Registered Parameter (fine)", "Registered Parameter (coarse)",
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "All Sound Off", "All Controllers Off",
+ "Local Keyboard (on/off)", "All Notes Off", "Omni Mode Off", "Omni Mode On", "Mono Operation",
+ "Poly Operation"
+ };
+
+ return (((unsigned int) n) < 128) ? names[n]
+ : (const char*)0;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_MidiMessage.cpp *********/
+
+/********* Start of inlined file: juce_MidiMessageCollector.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+MidiMessageCollector::MidiMessageCollector()
+ : lastCallbackTime (0),
+ sampleRate (44100.0001)
+{
+}
+
+MidiMessageCollector::~MidiMessageCollector()
+{
+}
+
+void MidiMessageCollector::reset (const double sampleRate_)
+{
+ jassert (sampleRate_ > 0);
+
+ const ScopedLock sl (midiCallbackLock);
+ sampleRate = sampleRate_;
+ incomingMessages.clear();
+ lastCallbackTime = Time::getMillisecondCounterHiRes();
+}
+
+void MidiMessageCollector::addMessageToQueue (const MidiMessage& message)
+{
+ // you need to call reset() to set the correct sample rate before using this object
+ jassert (sampleRate != 44100.0001);
+
+ // the messages that come in here need to be time-stamped correctly - see MidiInput
+ // for details of what the number should be.
+ jassert (message.getTimeStamp() != 0);
+
+ const ScopedLock sl (midiCallbackLock);
+
+ const int sampleNumber
+ = (int) ((message.getTimeStamp() - 0.001 * lastCallbackTime) * sampleRate);
+
+ incomingMessages.addEvent (message, sampleNumber);
+
+ // if the messages don't get used for over a second, we'd better
+ // get rid of any old ones to avoid the queue getting too big
+ if (sampleNumber > sampleRate)
+ incomingMessages.clear (0, sampleNumber - (int) sampleRate);
+}
+
+void MidiMessageCollector::removeNextBlockOfMessages (MidiBuffer& destBuffer,
+ const int numSamples)
+{
+ // you need to call reset() to set the correct sample rate before using this object
+ jassert (sampleRate != 44100.0001);
+
+ const double timeNow = Time::getMillisecondCounterHiRes();
+ const double msElapsed = timeNow - lastCallbackTime;
+
+ const ScopedLock sl (midiCallbackLock);
+ lastCallbackTime = timeNow;
+
+ if (! incomingMessages.isEmpty())
+ {
+ int numSourceSamples = jmax (1, roundDoubleToInt (msElapsed * 0.001 * sampleRate));
+
+ int startSample = 0;
+ int scale = 1 << 16;
+
+ const uint8* midiData;
+ int numBytes, samplePosition;
+
+ MidiBuffer::Iterator iter (incomingMessages);
+
+ if (numSourceSamples > numSamples)
+ {
+ // if our list of events is longer than the buffer we're being
+ // asked for, scale them down to squeeze them all in..
+ const int maxBlockLengthToUse = numSamples << 3;
+
+ if (numSourceSamples > maxBlockLengthToUse)
+ {
+ startSample = numSourceSamples - maxBlockLengthToUse;
+ numSourceSamples = maxBlockLengthToUse;
+ iter.setNextSamplePosition (startSample);
+ }
+
+ scale = (numSamples << 10) / numSourceSamples;
+
+ while (iter.getNextEvent (midiData, numBytes, samplePosition))
+ {
+ samplePosition = ((samplePosition - startSample) * scale) >> 10;
+
+ destBuffer.addEvent (midiData, numBytes,
+ jlimit (0, numSamples - 1, samplePosition));
+ }
+ }
+ else
+ {
+ // if our event list is shorter than the number we need, put them
+ // towards the end of the buffer
+ startSample = numSamples - numSourceSamples;
+
+ while (iter.getNextEvent (midiData, numBytes, samplePosition))
+ {
+ destBuffer.addEvent (midiData, numBytes,
+ jlimit (0, numSamples - 1, samplePosition + startSample));
+ }
+ }
+
+ incomingMessages.clear();
+ }
+}
+
+void MidiMessageCollector::handleNoteOn (MidiKeyboardState*, int midiChannel, int midiNoteNumber, float velocity)
+{
+ MidiMessage m (MidiMessage::noteOn (midiChannel, midiNoteNumber, velocity));
+ m.setTimeStamp (Time::getMillisecondCounter() * 0.001);
+
+ addMessageToQueue (m);
+}
+
+void MidiMessageCollector::handleNoteOff (MidiKeyboardState*, int midiChannel, int midiNoteNumber)
+{
+ MidiMessage m (MidiMessage::noteOff (midiChannel, midiNoteNumber));
+ m.setTimeStamp (Time::getMillisecondCounter() * 0.001);
+
+ addMessageToQueue (m);
+}
+
+void MidiMessageCollector::handleIncomingMidiMessage (MidiInput*, const MidiMessage& message)
+{
+ addMessageToQueue (message);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_MidiMessageCollector.cpp *********/
+
+/********* Start of inlined file: juce_MidiMessageSequence.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+MidiMessageSequence::MidiMessageSequence()
+{
+}
+
+MidiMessageSequence::MidiMessageSequence (const MidiMessageSequence& other)
+{
+ list.ensureStorageAllocated (other.list.size());
+
+ for (int i = 0; i < other.list.size(); ++i)
+ list.add (new MidiEventHolder (other.list.getUnchecked(i)->message));
+}
+
+const MidiMessageSequence& MidiMessageSequence::operator= (const MidiMessageSequence& other)
+{
+ if (this != &other)
+ {
+ clear();
+
+ for (int i = 0; i < other.list.size(); ++i)
+ list.add (new MidiEventHolder (other.list.getUnchecked(i)->message));
+ }
+
+ return *this;
+}
+
+MidiMessageSequence::~MidiMessageSequence()
+{
+}
+
+void MidiMessageSequence::clear()
+{
+ list.clear();
+}
+
+int MidiMessageSequence::getNumEvents() const
+{
+ return list.size();
+}
+
+MidiMessageSequence::MidiEventHolder* MidiMessageSequence::getEventPointer (const int index) const
+{
+ return list [index];
+}
+
+double MidiMessageSequence::getTimeOfMatchingKeyUp (const int index) const
+{
+ const MidiEventHolder* const meh = list [index];
+
+ if (meh != 0 && meh->noteOffObject != 0)
+ return meh->noteOffObject->message.getTimeStamp();
+ else
+ return 0.0;
+}
+
+int MidiMessageSequence::getIndexOfMatchingKeyUp (const int index) const
+{
+ const MidiEventHolder* const meh = list [index];
+
+ return (meh != 0) ? list.indexOf (meh->noteOffObject) : -1;
+}
+
+int MidiMessageSequence::getIndexOf (MidiEventHolder* const event) const
+{
+ return list.indexOf (event);
+}
+
+int MidiMessageSequence::getNextIndexAtTime (const double timeStamp) const
+{
+ const int numEvents = list.size();
+
+ int i;
+ for (i = 0; i < numEvents; ++i)
+ if (list.getUnchecked(i)->message.getTimeStamp() >= timeStamp)
+ break;
+
+ return i;
+}
+
+double MidiMessageSequence::getStartTime() const
+{
+ if (list.size() > 0)
+ return list.getUnchecked(0)->message.getTimeStamp();
+ else
+ return 0;
+}
+
+double MidiMessageSequence::getEndTime() const
+{
+ if (list.size() > 0)
+ return list.getLast()->message.getTimeStamp();
+ else
+ return 0;
+}
+
+double MidiMessageSequence::getEventTime (const int index) const
+{
+ if (((unsigned int) index) < (unsigned int) list.size())
+ return list.getUnchecked (index)->message.getTimeStamp();
+
+ return 0.0;
+}
+
+void MidiMessageSequence::addEvent (const MidiMessage& newMessage,
+ double timeAdjustment)
+{
+ MidiEventHolder* const newOne = new MidiEventHolder (newMessage);
+
+ timeAdjustment += newMessage.getTimeStamp();
+ newOne->message.setTimeStamp (timeAdjustment);
+
+ int i;
+ for (i = list.size(); --i >= 0;)
+ if (list.getUnchecked(i)->message.getTimeStamp() <= timeAdjustment)
+ break;
+
+ list.insert (i + 1, newOne);
+}
+
+void MidiMessageSequence::deleteEvent (const int index,
+ const bool deleteMatchingNoteUp)
+{
+ if (((unsigned int) index) < (unsigned int) list.size())
+ {
+ if (deleteMatchingNoteUp)
+ deleteEvent (getIndexOfMatchingKeyUp (index), false);
+
+ list.remove (index);
+ }
+}
+
+void MidiMessageSequence::addSequence (const MidiMessageSequence& other,
+ double timeAdjustment,
+ double firstAllowableTime,
+ double endOfAllowableDestTimes)
+{
+ firstAllowableTime -= timeAdjustment;
+ endOfAllowableDestTimes -= timeAdjustment;
+
+ for (int i = 0; i < other.list.size(); ++i)
+ {
+ const MidiMessage& m = other.list.getUnchecked(i)->message;
+ const double t = m.getTimeStamp();
+
+ if (t >= firstAllowableTime && t < endOfAllowableDestTimes)
+ {
+ MidiEventHolder* const newOne = new MidiEventHolder (m);
+ newOne->message.setTimeStamp (timeAdjustment + t);
+
+ list.add (newOne);
+ }
+ }
+
+ sort();
+}
+
+int MidiMessageSequence::compareElements (const MidiMessageSequence::MidiEventHolder* const first,
+ const MidiMessageSequence::MidiEventHolder* const second) throw()
+{
+ const double diff = first->message.getTimeStamp()
+ - second->message.getTimeStamp();
+
+ return (diff == 0) ? 0
+ : ((diff > 0) ? 1
+ : -1);
+}
+
+void MidiMessageSequence::sort()
+{
+ list.sort (*this, true);
+}
+
+void MidiMessageSequence::updateMatchedPairs()
+{
+ for (int i = 0; i < list.size(); ++i)
+ {
+ const MidiMessage& m1 = list.getUnchecked(i)->message;
+
+ if (m1.isNoteOn())
+ {
+ list.getUnchecked(i)->noteOffObject = 0;
+ const int note = m1.getNoteNumber();
+ const int chan = m1.getChannel();
+ const int len = list.size();
+
+ for (int j = i + 1; j < len; ++j)
+ {
+ const MidiMessage& m = list.getUnchecked(j)->message;
+
+ if (m.getNoteNumber() == note && m.getChannel() == chan)
+ {
+ if (m.isNoteOff())
+ {
+ list.getUnchecked(i)->noteOffObject = list[j];
+ break;
+ }
+ else if (m.isNoteOn())
+ {
+ list.insert (j, new MidiEventHolder (MidiMessage::noteOff (chan, note)));
+ list.getUnchecked(j)->message.setTimeStamp (m.getTimeStamp());
+ list.getUnchecked(i)->noteOffObject = list[j];
+ break;
+ }
+ }
+ }
+ }
+ }
+}
+
+void MidiMessageSequence::addTimeToMessages (const double delta)
+{
+ for (int i = list.size(); --i >= 0;)
+ list.getUnchecked (i)->message.setTimeStamp (list.getUnchecked (i)->message.getTimeStamp()
+ + delta);
+}
+
+void MidiMessageSequence::extractMidiChannelMessages (const int channelNumberToExtract,
+ MidiMessageSequence& destSequence,
+ const bool alsoIncludeMetaEvents) const
+{
+ for (int i = 0; i < list.size(); ++i)
+ {
+ const MidiMessage& mm = list.getUnchecked(i)->message;
+
+ if (mm.isForChannel (channelNumberToExtract)
+ || (alsoIncludeMetaEvents && mm.isMetaEvent()))
+ {
+ destSequence.addEvent (mm);
+ }
+ }
+}
+
+void MidiMessageSequence::extractSysExMessages (MidiMessageSequence& destSequence) const
+{
+ for (int i = 0; i < list.size(); ++i)
+ {
+ const MidiMessage& mm = list.getUnchecked(i)->message;
+
+ if (mm.isSysEx())
+ destSequence.addEvent (mm);
+ }
+}
+
+void MidiMessageSequence::deleteMidiChannelMessages (const int channelNumberToRemove)
+{
+ for (int i = list.size(); --i >= 0;)
+ if (list.getUnchecked(i)->message.isForChannel (channelNumberToRemove))
+ list.remove(i);
+}
+
+void MidiMessageSequence::deleteSysExMessages()
+{
+ for (int i = list.size(); --i >= 0;)
+ if (list.getUnchecked(i)->message.isSysEx())
+ list.remove(i);
+}
+
+void MidiMessageSequence::createControllerUpdatesForTime (const int channelNumber,
+ const double time,
+ OwnedArray& dest)
+{
+ bool doneProg = false;
+ bool donePitchWheel = false;
+ Array doneControllers (32);
+
+ for (int i = list.size(); --i >= 0;)
+ {
+ const MidiMessage& mm = list.getUnchecked(i)->message;
+
+ if (mm.isForChannel (channelNumber)
+ && mm.getTimeStamp() <= time)
+ {
+ if (mm.isProgramChange())
+ {
+ if (! doneProg)
+ {
+ dest.add (new MidiMessage (mm, 0.0));
+ doneProg = true;
+ }
+ }
+ else if (mm.isController())
+ {
+ if (! doneControllers.contains (mm.getControllerNumber()))
+ {
+ dest.add (new MidiMessage (mm, 0.0));
+ doneControllers.add (mm.getControllerNumber());
+ }
+ }
+ else if (mm.isPitchWheel())
+ {
+ if (! donePitchWheel)
+ {
+ dest.add (new MidiMessage (mm, 0.0));
+ donePitchWheel = true;
+ }
+ }
+ }
+ }
+}
+
+MidiMessageSequence::MidiEventHolder::MidiEventHolder (const MidiMessage& message_)
+ : message (message_),
+ noteOffObject (0)
+{
+}
+
+MidiMessageSequence::MidiEventHolder::~MidiEventHolder()
+{
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_MidiMessageSequence.cpp *********/
+
+/********* Start of inlined file: juce_AudioPluginFormat.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+AudioPluginFormat::AudioPluginFormat() throw()
+{
+}
+
+AudioPluginFormat::~AudioPluginFormat()
+{
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_AudioPluginFormat.cpp *********/
+
+/********* Start of inlined file: juce_AudioPluginFormatManager.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+AudioPluginFormatManager::AudioPluginFormatManager() throw()
+{
+}
+
+AudioPluginFormatManager::~AudioPluginFormatManager() throw()
+{
+}
+
+juce_ImplementSingleton_SingleThreaded (AudioPluginFormatManager);
+
+void AudioPluginFormatManager::addDefaultFormats()
+{
+#ifdef JUCE_DEBUG
+ // you should only call this method once!
+ for (int i = formats.size(); --i >= 0;)
+ {
+ #if JUCE_PLUGINHOST_VST
+ jassert (dynamic_cast (formats[i]) == 0);
+ #endif
+
+ #if JUCE_PLUGINHOST_AU && JUCE_MAC
+ jassert (dynamic_cast (formats[i]) == 0);
+ #endif
+
+ #if JUCE_PLUGINHOST_DX && JUCE_WIN32
+ jassert (dynamic_cast (formats[i]) == 0);
+ #endif
+
+ #if JUCE_PLUGINHOST_LADSPA && JUCE_LINUX
+ jassert (dynamic_cast (formats[i]) == 0);
+ #endif
+ }
+#endif
+
+#if JUCE_PLUGINHOST_VST
+ formats.add (new VSTPluginFormat());
+#endif
+
+#if JUCE_PLUGINHOST_AU && JUCE_MAC
+ formats.add (new AudioUnitPluginFormat());
+#endif
+
+#if JUCE_PLUGINHOST_DX && JUCE_WIN32
+ formats.add (new DirectXPluginFormat());
+#endif
+
+#if JUCE_PLUGINHOST_LADSPA && JUCE_LINUX
+ formats.add (new LADSPAPluginFormat());
+#endif
+}
+
+int AudioPluginFormatManager::getNumFormats() throw()
+{
+ return formats.size();
+}
+
+AudioPluginFormat* AudioPluginFormatManager::getFormat (const int index) throw()
+{
+ return formats [index];
+}
+
+void AudioPluginFormatManager::addFormat (AudioPluginFormat* const format) throw()
+{
+ formats.add (format);
+}
+
+AudioPluginInstance* AudioPluginFormatManager::createPluginInstance (const PluginDescription& description,
+ String& errorMessage) const
+{
+ AudioPluginInstance* result = 0;
+
+ for (int i = 0; i < formats.size(); ++i)
+ {
+ result = formats.getUnchecked(i)->createInstanceFromDescription (description);
+
+ if (result != 0)
+ break;
+ }
+
+ if (result == 0)
+ {
+ if (description.file != File::nonexistent && ! description.file.exists())
+ errorMessage = TRANS ("This plug-in file no longer exists");
+ else
+ errorMessage = TRANS ("This plug-in failed to load correctly");
+ }
+
+ return result;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_AudioPluginFormatManager.cpp *********/
+
+/********* Start of inlined file: juce_AudioPluginInstance.cpp *********/
+#define JUCE_PLUGIN_HOST 1
+
+BEGIN_JUCE_NAMESPACE
+
+AudioPluginInstance::AudioPluginInstance()
+{
+}
+
+AudioPluginInstance::~AudioPluginInstance()
+{
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_AudioPluginInstance.cpp *********/
+
+/********* Start of inlined file: juce_KnownPluginList.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+KnownPluginList::KnownPluginList()
+{
+}
+
+KnownPluginList::~KnownPluginList()
+{
+}
+
+void KnownPluginList::clear()
+{
+ if (types.size() > 0)
+ {
+ types.clear();
+ sendChangeMessage (this);
+ }
+}
+
+PluginDescription* KnownPluginList::getTypeForFile (const File& file) const throw()
+{
+ for (int i = 0; i < types.size(); ++i)
+ if (types.getUnchecked(i)->file == file)
+ return types.getUnchecked(i);
+
+ return 0;
+}
+
+PluginDescription* KnownPluginList::getTypeForIdentifierString (const String& identifierString) const throw()
+{
+ for (int i = 0; i < types.size(); ++i)
+ if (types.getUnchecked(i)->createIdentifierString() == identifierString)
+ return types.getUnchecked(i);
+
+ return 0;
+}
+
+bool KnownPluginList::addType (const PluginDescription& type)
+{
+ for (int i = types.size(); --i >= 0;)
+ {
+ if (types.getUnchecked(i)->isDuplicateOf (type))
+ {
+ // strange - found a duplicate plugin with different info..
+ jassert (types.getUnchecked(i)->name == type.name);
+ jassert (types.getUnchecked(i)->isInstrument == type.isInstrument);
+
+ *types.getUnchecked(i) = type;
+ return false;
+ }
+ }
+
+ types.add (new PluginDescription (type));
+ sendChangeMessage (this);
+ return true;
+}
+
+void KnownPluginList::removeType (const int index) throw()
+{
+ types.remove (index);
+ sendChangeMessage (this);
+}
+
+bool KnownPluginList::isListingUpToDate (const File& possiblePluginFile) const throw()
+{
+ if (getTypeForFile (possiblePluginFile) == 0)
+ return false;
+
+ for (int i = types.size(); --i >= 0;)
+ {
+ const PluginDescription* const d = types.getUnchecked(i);
+
+ if (d->file == possiblePluginFile
+ && d->lastFileModTime != possiblePluginFile.getLastModificationTime())
+ {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+bool KnownPluginList::scanAndAddFile (const File& possiblePluginFile,
+ const bool dontRescanIfAlreadyInList,
+ OwnedArray & typesFound)
+{
+ bool addedOne = false;
+
+ if (dontRescanIfAlreadyInList
+ && getTypeForFile (possiblePluginFile) != 0)
+ {
+ bool needsRescanning = false;
+
+ for (int i = types.size(); --i >= 0;)
+ {
+ const PluginDescription* const d = types.getUnchecked(i);
+
+ if (d->file == possiblePluginFile)
+ {
+ if (d->lastFileModTime != possiblePluginFile.getLastModificationTime())
+ needsRescanning = true;
+ else
+ typesFound.add (new PluginDescription (*d));
+ }
+ }
+
+ if (! needsRescanning)
+ return false;
+ }
+
+ for (int i = 0; i < AudioPluginFormatManager::getInstance()->getNumFormats(); ++i)
+ {
+ AudioPluginFormat* const format = AudioPluginFormatManager::getInstance()->getFormat (i);
+
+ OwnedArray found;
+ format->findAllTypesForFile (found, possiblePluginFile);
+
+ for (int i = 0; i < found.size(); ++i)
+ {
+ PluginDescription* const desc = found.getUnchecked(i);
+ jassert (desc != 0);
+
+ if (addType (*desc))
+ addedOne = true;
+
+ typesFound.add (new PluginDescription (*desc));
+ }
+ }
+
+ return addedOne;
+}
+
+void KnownPluginList::scanAndAddDragAndDroppedFiles (const StringArray& files,
+ OwnedArray & typesFound)
+{
+ for (int i = 0; i < files.size(); ++i)
+ {
+ const File f (files [i]);
+
+ if (! scanAndAddFile (f, true, typesFound))
+ {
+ if (f.isDirectory())
+ {
+ StringArray s;
+
+ {
+ OwnedArray subFiles;
+ f.findChildFiles (subFiles, File::findFilesAndDirectories, false);
+
+ for (int j = 0; j < subFiles.size(); ++j)
+ s.add (subFiles.getUnchecked (j)->getFullPathName());
+ }
+
+ scanAndAddDragAndDroppedFiles (s, typesFound);
+ }
+ }
+ }
+}
+
+class PluginSorter
+{
+public:
+ KnownPluginList::SortMethod method;
+
+ PluginSorter() throw() {}
+
+ int compareElements (const PluginDescription* const first,
+ const PluginDescription* const second) const throw()
+ {
+ int diff = 0;
+
+ if (method == KnownPluginList::sortByCategory)
+ diff = first->category.compareLexicographically (second->category);
+ else if (method == KnownPluginList::sortByManufacturer)
+ diff = first->manufacturerName.compareLexicographically (second->manufacturerName);
+ else if (method == KnownPluginList::sortByFileSystemLocation)
+ diff = first->file.getParentDirectory().getFullPathName().compare (second->file.getParentDirectory().getFullPathName());
+
+ if (diff == 0)
+ diff = first->name.compareLexicographically (second->name);
+
+ return diff;
+ }
+};
+
+void KnownPluginList::sort (const SortMethod method)
+{
+ if (method != defaultOrder)
+ {
+ PluginSorter sorter;
+ sorter.method = method;
+ types.sort (sorter, true);
+
+ sendChangeMessage (this);
+ }
+}
+
+XmlElement* KnownPluginList::createXml() const
+{
+ XmlElement* const e = new XmlElement (T("KNOWNPLUGINS"));
+
+ for (int i = 0; i < types.size(); ++i)
+ e->addChildElement (types.getUnchecked(i)->createXml());
+
+ return e;
+}
+
+void KnownPluginList::recreateFromXml (const XmlElement& xml)
+{
+ clear();
+
+ if (xml.hasTagName (T("KNOWNPLUGINS")))
+ {
+ forEachXmlChildElement (xml, e)
+ {
+ PluginDescription info;
+
+ if (info.loadFromXml (*e))
+ addType (info);
+ }
+ }
+}
+
+const int menuIdBase = 0x324503f4;
+
+// This is used to turn a bunch of paths into a nested menu structure.
+struct PluginFilesystemTree
+{
+private:
+ String folder;
+ OwnedArray subFolders;
+ Array plugins;
+
+ void addPlugin (PluginDescription* const pd, const String& path)
+ {
+ if (path.isEmpty())
+ {
+ plugins.add (pd);
+ }
+ else
+ {
+ const String firstSubFolder (path.upToFirstOccurrenceOf (T("/"), false, false));
+ const String remainingPath (path.fromFirstOccurrenceOf (T("/"), false, false));
+
+ for (int i = subFolders.size(); --i >= 0;)
+ {
+ if (subFolders.getUnchecked(i)->folder.equalsIgnoreCase (firstSubFolder))
+ {
+ subFolders.getUnchecked(i)->addPlugin (pd, remainingPath);
+ return;
+ }
+ }
+
+ PluginFilesystemTree* const newFolder = new PluginFilesystemTree();
+ newFolder->folder = firstSubFolder;
+ subFolders.add (newFolder);
+
+ newFolder->addPlugin (pd, remainingPath);
+ }
+ }
+
+ // removes any deeply nested folders that don't contain any actual plugins
+ void optimise()
+ {
+ for (int i = subFolders.size(); --i >= 0;)
+ {
+ PluginFilesystemTree* const sub = subFolders.getUnchecked(i);
+
+ sub->optimise();
+
+ if (sub->plugins.size() == 0)
+ {
+ for (int j = 0; j < sub->subFolders.size(); ++j)
+ subFolders.add (sub->subFolders.getUnchecked(j));
+
+ sub->subFolders.clear (false);
+ subFolders.remove (i);
+ }
+ }
+ }
+
+public:
+ void buildTree (const Array & allPlugins)
+ {
+ for (int i = 0; i < allPlugins.size(); ++i)
+ {
+ String path (allPlugins.getUnchecked(i)->file.getParentDirectory().getFullPathName());
+
+ if (path.substring (1, 2) == T(":"))
+ path = path.substring (2);
+
+ path = path.replaceCharacter (T('\\'), T('/'));
+
+ addPlugin (allPlugins.getUnchecked(i), path);
+ }
+
+ optimise();
+ }
+
+ void addToMenu (PopupMenu& m, const OwnedArray & allPlugins) const
+ {
+ int i;
+ for (i = 0; i < subFolders.size(); ++i)
+ {
+ const PluginFilesystemTree* const sub = subFolders.getUnchecked(i);
+
+ PopupMenu subMenu;
+ sub->addToMenu (subMenu, allPlugins);
+ m.addSubMenu (sub->folder, subMenu);
+ }
+
+ for (i = 0; i < plugins.size(); ++i)
+ {
+ PluginDescription* const plugin = plugins.getUnchecked(i);
+
+ m.addItem (allPlugins.indexOf (plugin) + menuIdBase,
+ plugin->name, true, false);
+ }
+ }
+};
+
+void KnownPluginList::addToMenu (PopupMenu& menu, const SortMethod sortMethod) const
+{
+ Array sorted;
+
+ {
+ PluginSorter sorter;
+ sorter.method = sortMethod;
+
+ for (int i = 0; i < types.size(); ++i)
+ sorted.addSorted (sorter, types.getUnchecked(i));
+ }
+
+ if (sortMethod == sortByCategory
+ || sortMethod == sortByManufacturer)
+ {
+ String lastSubMenuName;
+ PopupMenu sub;
+
+ for (int i = 0; i < sorted.size(); ++i)
+ {
+ const PluginDescription* const pd = sorted.getUnchecked(i);
+ String thisSubMenuName (sortMethod == sortByCategory ? pd->category
+ : pd->manufacturerName);
+
+ if (thisSubMenuName.trim().isEmpty())
+ thisSubMenuName = T("Other");
+
+ if (thisSubMenuName != lastSubMenuName)
+ {
+ if (sub.getNumItems() > 0)
+ {
+ menu.addSubMenu (lastSubMenuName, sub);
+ sub.clear();
+ }
+
+ lastSubMenuName = thisSubMenuName;
+ }
+
+ sub.addItem (types.indexOf (pd) + menuIdBase, pd->name, true, false);
+ }
+
+ if (sub.getNumItems() > 0)
+ menu.addSubMenu (lastSubMenuName, sub);
+ }
+ else if (sortMethod == sortByFileSystemLocation)
+ {
+ PluginFilesystemTree root;
+ root.buildTree (sorted);
+ root.addToMenu (menu, types);
+ }
+ else
+ {
+ for (int i = 0; i < sorted.size(); ++i)
+ {
+ const PluginDescription* const pd = sorted.getUnchecked(i);
+ menu.addItem (types.indexOf (pd) + menuIdBase, pd->name, true, false);
+ }
+ }
+}
+
+int KnownPluginList::getIndexChosenByMenu (const int menuResultCode) const
+{
+ const int i = menuResultCode - menuIdBase;
+
+ return (((unsigned int) i) < (unsigned int) types.size()) ? i : -1;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_KnownPluginList.cpp *********/
+
+/********* Start of inlined file: juce_PluginDescription.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+PluginDescription::PluginDescription() throw()
+ : uid (0),
+ isInstrument (false),
+ numInputChannels (0),
+ numOutputChannels (0)
+{
+}
+
+PluginDescription::~PluginDescription() throw()
+{
+}
+
+PluginDescription::PluginDescription (const PluginDescription& other) throw()
+ : name (other.name),
+ pluginFormatName (other.pluginFormatName),
+ category (other.category),
+ manufacturerName (other.manufacturerName),
+ version (other.version),
+ file (other.file),
+ lastFileModTime (other.lastFileModTime),
+ uid (other.uid),
+ isInstrument (other.isInstrument),
+ numInputChannels (other.numInputChannels),
+ numOutputChannels (other.numOutputChannels)
+{
+}
+
+const PluginDescription& PluginDescription::operator= (const PluginDescription& other) throw()
+{
+ name = other.name;
+ pluginFormatName = other.pluginFormatName;
+ category = other.category;
+ manufacturerName = other.manufacturerName;
+ version = other.version;
+ file = other.file;
+ uid = other.uid;
+ isInstrument = other.isInstrument;
+ lastFileModTime = other.lastFileModTime;
+ numInputChannels = other.numInputChannels;
+ numOutputChannels = other.numOutputChannels;
+
+ return *this;
+}
+
+bool PluginDescription::isDuplicateOf (const PluginDescription& other) const
+{
+ return file == other.file
+ && uid == other.uid;
+}
+
+const String PluginDescription::createIdentifierString() const throw()
+{
+ return pluginFormatName
+ + T("-") + name
+ + T("-") + String::toHexString (file.getFileName().hashCode())
+ + T("-") + String::toHexString (uid);
+}
+
+XmlElement* PluginDescription::createXml() const
+{
+ XmlElement* const e = new XmlElement (T("PLUGIN"));
+ e->setAttribute (T("name"), name);
+ e->setAttribute (T("format"), pluginFormatName);
+ e->setAttribute (T("category"), category);
+ e->setAttribute (T("manufacturer"), manufacturerName);
+ e->setAttribute (T("version"), version);
+ e->setAttribute (T("file"), file.getFullPathName());
+ e->setAttribute (T("uid"), String::toHexString (uid));
+ e->setAttribute (T("isInstrument"), isInstrument);
+ e->setAttribute (T("fileTime"), String::toHexString (lastFileModTime.toMilliseconds()));
+ e->setAttribute (T("numInputs"), numInputChannels);
+ e->setAttribute (T("numOutputs"), numOutputChannels);
+
+ return e;
+}
+
+bool PluginDescription::loadFromXml (const XmlElement& xml)
+{
+ if (xml.hasTagName (T("PLUGIN")))
+ {
+ name = xml.getStringAttribute (T("name"));
+ pluginFormatName = xml.getStringAttribute (T("format"));
+ category = xml.getStringAttribute (T("category"));
+ manufacturerName = xml.getStringAttribute (T("manufacturer"));
+ version = xml.getStringAttribute (T("version"));
+ file = File (xml.getStringAttribute (T("file")));
+ uid = xml.getStringAttribute (T("uid")).getHexValue32();
+ isInstrument = xml.getBoolAttribute (T("isInstrument"), false);
+ lastFileModTime = Time (xml.getStringAttribute (T("fileTime")).getHexValue64());
+ numInputChannels = xml.getIntAttribute (T("numInputs"));
+ numOutputChannels = xml.getIntAttribute (T("numOutputs"));
+
+ return true;
+ }
+
+ return false;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_PluginDescription.cpp *********/
+
+/********* Start of inlined file: juce_PluginDirectoryScanner.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+PluginDirectoryScanner::PluginDirectoryScanner (KnownPluginList& listToAddTo,
+ AudioPluginFormat& formatToLookFor,
+ FileSearchPath directoriesToSearch,
+ const bool recursive,
+ const File& deadMansPedalFile_)
+ : list (listToAddTo),
+ format (formatToLookFor),
+ deadMansPedalFile (deadMansPedalFile_),
+ nextIndex (0),
+ progress (0)
+{
+ directoriesToSearch.removeRedundantPaths();
+
+ for (int j = 0; j < directoriesToSearch.getNumPaths(); ++j)
+ recursiveFileSearch (directoriesToSearch [j], recursive);
+
+ // If any plugins have crashed recently when being loaded, move them to the
+ // end of the list to give the others a chance to load correctly..
+ const StringArray crashedPlugins (getDeadMansPedalFile());
+
+ for (int i = 0; i < crashedPlugins.size(); ++i)
+ {
+ const File f (crashedPlugins[i]);
+
+ for (int j = filesToScan.size(); --j >= 0;)
+ if (f == *filesToScan.getUnchecked (j))
+ filesToScan.move (j, -1);
+ }
+}
+
+void PluginDirectoryScanner::recursiveFileSearch (const File& dir, const bool recursive)
+{
+ // avoid allowing the dir iterator to be recursive, because we want to avoid letting it delve inside
+ // .component or .vst directories.
+ DirectoryIterator iter (dir, false, "*", File::findFilesAndDirectories);
+
+ while (iter.next())
+ {
+ const File f (iter.getFile());
+ bool isPlugin = false;
+
+ if (format.fileMightContainThisPluginType (f))
+ {
+ isPlugin = true;
+ filesToScan.add (new File (f));
+ }
+
+ if (recursive && (! isPlugin) && f.isDirectory())
+ recursiveFileSearch (f, true);
+ }
+}
+
+PluginDirectoryScanner::~PluginDirectoryScanner()
+{
+}
+
+const File PluginDirectoryScanner::getNextPluginFileThatWillBeScanned() const throw()
+{
+ File* const file = filesToScan [nextIndex];
+
+ if (file != 0)
+ return *file;
+
+ return File::nonexistent;
+}
+
+bool PluginDirectoryScanner::scanNextFile (const bool dontRescanIfAlreadyInList)
+{
+ File* const file = filesToScan [nextIndex];
+
+ if (file != 0)
+ {
+ if (! list.isListingUpToDate (*file))
+ {
+ OwnedArray typesFound;
+
+ // Add this plugin to the end of the dead-man's pedal list in case it crashes...
+ StringArray crashedPlugins (getDeadMansPedalFile());
+ crashedPlugins.removeString (file->getFullPathName());
+ crashedPlugins.add (file->getFullPathName());
+ setDeadMansPedalFile (crashedPlugins);
+
+ list.scanAndAddFile (*file,
+ dontRescanIfAlreadyInList,
+ typesFound);
+
+ // Managed to load without crashing, so remove it from the dead-man's-pedal..
+ crashedPlugins.removeString (file->getFullPathName());
+ setDeadMansPedalFile (crashedPlugins);
+
+ if (typesFound.size() == 0)
+ failedFiles.add (file->getFullPathName());
+ }
+
+ ++nextIndex;
+ progress = nextIndex / (float) filesToScan.size();
+ }
+
+ return nextIndex < filesToScan.size();
+}
+
+const StringArray PluginDirectoryScanner::getDeadMansPedalFile() throw()
+{
+ StringArray lines;
+
+ if (deadMansPedalFile != File::nonexistent)
+ {
+ lines.addLines (deadMansPedalFile.loadFileAsString());
+ lines.removeEmptyStrings();
+ }
+
+ return lines;
+}
+
+void PluginDirectoryScanner::setDeadMansPedalFile (const StringArray& newContents) throw()
+{
+ if (deadMansPedalFile != File::nonexistent)
+ deadMansPedalFile.replaceWithText (newContents.joinIntoString ("\n"), true, true);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_PluginDirectoryScanner.cpp *********/
+
+/********* Start of inlined file: juce_PluginListComponent.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+PluginListComponent::PluginListComponent (KnownPluginList& listToEdit,
+ const File& deadMansPedalFile_,
+ PropertiesFile* const propertiesToUse_)
+ : list (listToEdit),
+ deadMansPedalFile (deadMansPedalFile_),
+ propertiesToUse (propertiesToUse_)
+{
+ addAndMakeVisible (listBox = new ListBox (String::empty, this));
+
+ addAndMakeVisible (optionsButton = new TextButton ("Options..."));
+ optionsButton->addButtonListener (this);
+ optionsButton->setTriggeredOnMouseDown (true);
+
+ setSize (400, 600);
+ list.addChangeListener (this);
+}
+
+PluginListComponent::~PluginListComponent()
+{
+ list.removeChangeListener (this);
+ deleteAllChildren();
+}
+
+void PluginListComponent::resized()
+{
+ listBox->setBounds (0, 0, getWidth(), getHeight() - 30);
+ optionsButton->changeWidthToFitText (24);
+ optionsButton->setTopLeftPosition (8, getHeight() - 28);
+}
+
+void PluginListComponent::changeListenerCallback (void*)
+{
+ listBox->updateContent();
+ listBox->repaint();
+}
+
+int PluginListComponent::getNumRows()
+{
+ return list.getNumTypes();
+}
+
+void PluginListComponent::paintListBoxItem (int row,
+ Graphics& g,
+ int width, int height,
+ bool rowIsSelected)
+{
+ if (rowIsSelected)
+ g.fillAll (findColour (TextEditor::highlightColourId));
+
+ const PluginDescription* const pd = list.getType (row);
+
+ if (pd != 0)
+ {
+ GlyphArrangement ga;
+ ga.addCurtailedLineOfText (Font (height * 0.7f, Font::bold), pd->name, 8.0f, height * 0.8f, width - 10.0f, true);
+
+ g.setColour (Colours::black);
+ ga.draw (g);
+
+ float x, y, r, b;
+ ga.getBoundingBox (0, -1, x, y, r, b, false);
+
+ String desc;
+ desc << pd->pluginFormatName
+ << (pd->isInstrument ? " instrument" : " effect")
+ << " - "
+ << pd->numInputChannels << (pd->numInputChannels == 1 ? " in" : " ins")
+ << " / "
+ << pd->numOutputChannels << (pd->numOutputChannels == 1 ? " out" : " outs");
+
+ if (pd->manufacturerName.isNotEmpty())
+ desc << " - " << pd->manufacturerName;
+
+ if (pd->version.isNotEmpty())
+ desc << " - " << pd->version;
+
+ if (pd->category.isNotEmpty())
+ desc << " - category: '" << pd->category << '\'';
+
+ g.setColour (Colours::grey);
+
+ ga.clear();
+ ga.addCurtailedLineOfText (Font (height * 0.6f), desc, r + 10.0f, height * 0.8f, width - r - 12.0f, true);
+ ga.draw (g);
+ }
+}
+
+void PluginListComponent::deleteKeyPressed (int lastRowSelected)
+{
+ list.removeType (lastRowSelected);
+}
+
+void PluginListComponent::buttonClicked (Button* b)
+{
+ if (optionsButton == b)
+ {
+ PopupMenu menu;
+ menu.addItem (1, TRANS("Clear list"));
+ menu.addItem (5, TRANS("Remove selected plugin from list"), listBox->getNumSelectedRows() > 0);
+ menu.addItem (6, TRANS("Show folder containing selected plugin"), listBox->getNumSelectedRows() > 0);
+ menu.addItem (7, TRANS("Remove any plugins whose files no longer exist"));
+ menu.addSeparator();
+ menu.addItem (2, TRANS("Sort alphabetically"));
+ menu.addItem (3, TRANS("Sort by category"));
+ menu.addItem (4, TRANS("Sort by manufacturer"));
+ menu.addSeparator();
+
+ for (int i = 0; i < AudioPluginFormatManager::getInstance()->getNumFormats(); ++i)
+ {
+ AudioPluginFormat* const format = AudioPluginFormatManager::getInstance()->getFormat (i);
+
+ if (format->getDefaultLocationsToSearch().getNumPaths() > 0)
+ menu.addItem (10 + i, "Scan for new or updated " + format->getName() + " plugins...");
+ }
+
+ const int r = menu.showAt (optionsButton);
+
+ if (r == 1)
+ {
+ list.clear();
+ }
+ else if (r == 2)
+ {
+ list.sort (KnownPluginList::sortAlphabetically);
+ }
+ else if (r == 3)
+ {
+ list.sort (KnownPluginList::sortByCategory);
+ }
+ else if (r == 4)
+ {
+ list.sort (KnownPluginList::sortByManufacturer);
+ }
+ else if (r == 5)
+ {
+ const SparseSet selected (listBox->getSelectedRows());
+
+ for (int i = list.getNumTypes(); --i >= 0;)
+ if (selected.contains (i))
+ list.removeType (i);
+ }
+ else if (r == 6)
+ {
+ const PluginDescription* const desc = list.getType (listBox->getSelectedRow());
+
+ if (desc != 0)
+ desc->file.getParentDirectory().startAsProcess();
+ }
+ else if (r == 7)
+ {
+ for (int i = list.getNumTypes(); --i >= 0;)
+ {
+ if (list.getType (i)->file != File::nonexistent
+ && ! list.getType (i)->file.exists())
+ {
+ list.removeType (i);
+ }
+ }
+ }
+ else if (r != 0)
+ {
+ typeToScan = r - 10;
+ startTimer (1);
+ }
+ }
+}
+
+void PluginListComponent::timerCallback()
+{
+ stopTimer();
+ scanFor (AudioPluginFormatManager::getInstance()->getFormat (typeToScan));
+}
+
+bool PluginListComponent::isInterestedInFileDrag (const StringArray& /*files*/)
+{
+ return true;
+}
+
+void PluginListComponent::filesDropped (const StringArray& files, int, int)
+{
+ OwnedArray typesFound;
+ list.scanAndAddDragAndDroppedFiles (files, typesFound);
+}
+
+void PluginListComponent::scanFor (AudioPluginFormat* format)
+{
+ if (format == 0)
+ return;
+
+ FileSearchPath path (format->getDefaultLocationsToSearch());
+
+ if (propertiesToUse != 0)
+ path = propertiesToUse->getValue ("lastPluginScanPath_" + format->getName(), path.toString());
+
+ {
+ AlertWindow aw (TRANS("Select folders to scan..."), String::empty, AlertWindow::NoIcon);
+ FileSearchPathListComponent pathList;
+ pathList.setSize (500, 300);
+ pathList.setPath (path);
+
+ aw.addCustomComponent (&pathList);
+ aw.addButton (TRANS("Scan"), 1, KeyPress::returnKey);
+ aw.addButton (TRANS("Cancel"), 0, KeyPress (KeyPress::escapeKey));
+
+ if (aw.runModalLoop() == 0)
+ return;
+
+ path = pathList.getPath();
+ }
+
+ if (propertiesToUse != 0)
+ {
+ propertiesToUse->setValue ("lastPluginScanPath_" + format->getName(), path.toString());
+ propertiesToUse->saveIfNeeded();
+ }
+
+ double progress = 0.0;
+
+ AlertWindow aw (TRANS("Scanning for plugins..."),
+ TRANS("Searching for all possible plugin files..."), AlertWindow::NoIcon);
+
+ aw.addButton (TRANS("Cancel"), 0, KeyPress (KeyPress::escapeKey));
+ aw.addProgressBarComponent (progress);
+
+ aw.enterModalState();
+
+ MessageManager::getInstance()->dispatchPendingMessages();
+
+ PluginDirectoryScanner scanner (list, *format, path, true, deadMansPedalFile);
+
+ for (;;)
+ {
+ aw.setMessage (TRANS("Testing:\n\n")
+ + scanner.getNextPluginFileThatWillBeScanned().getFileName());
+
+ MessageManager::getInstance()->dispatchPendingMessages (500);
+
+ if (! scanner.scanNextFile (true))
+ break;
+
+ if (! aw.isCurrentlyModal())
+ break;
+
+ progress = scanner.getProgress();
+ }
+
+ if (scanner.getFailedFiles().size() > 0)
+ {
+ StringArray shortNames;
+
+ for (int i = 0; i < scanner.getFailedFiles().size(); ++i)
+ shortNames.add (File (scanner.getFailedFiles()[i]).getFileName());
+
+ AlertWindow::showMessageBox (AlertWindow::InfoIcon,
+ TRANS("Scan complete"),
+ TRANS("Note that the following files appeared to be plugin files, but failed to load correctly:\n\n")
+ + shortNames.joinIntoString (", "));
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_PluginListComponent.cpp *********/
+
+/********* Start of inlined file: juce_AudioUnitPluginFormat.cpp *********/
+
+#if JUCE_PLUGINHOST_AU && (! (defined (LINUX) || defined (_WIN32)))
+
+#include
+#include
+#include
+
+BEGIN_JUCE_NAMESPACE
+
+#if JUCE_MAC
+
+extern void juce_callAnyTimersSynchronously();
+extern bool juce_isHIViewCreatedByJuce (HIViewRef view);
+extern bool juce_isWindowCreatedByJuce (WindowRef window);
+
+#if MACOS_10_3_OR_EARLIER
+ #define kAudioUnitType_Generator 'augn'
+#endif
+
+// Change this to disable logging of various activities
+#ifndef AU_LOGGING
+ #define AU_LOGGING 1
+#endif
+
+#if AU_LOGGING
+ #define log(a) Logger::writeToLog(a);
+#else
+ #define log(a)
+#endif
+
+static int insideCallback = 0;
+
+class AudioUnitPluginWindow;
+
+class AudioUnitPluginInstance : public AudioPluginInstance
+{
+public:
+
+ ~AudioUnitPluginInstance();
+
+ // AudioPluginInstance methods:
+
+ void fillInPluginDescription (PluginDescription& desc) const
+ {
+ desc.name = pluginName;
+ desc.file = file;
+ desc.uid = ((int) componentDesc.componentType)
+ ^ ((int) componentDesc.componentSubType)
+ ^ ((int) componentDesc.componentManufacturer);
+ desc.lastFileModTime = file.getLastModificationTime();
+ desc.pluginFormatName = "AudioUnit";
+ desc.category = getCategory();
+ desc.manufacturerName = manufacturer;
+ desc.version = version;
+ desc.numInputChannels = getNumInputChannels();
+ desc.numOutputChannels = getNumOutputChannels();
+ desc.isInstrument = (componentDesc.componentType == kAudioUnitType_MusicDevice);
+ }
+
+ const String getName() const { return pluginName; }
+ bool acceptsMidi() const { return wantsMidiMessages; }
+ bool producesMidi() const { return false; }
+
+ // AudioProcessor methods:
+
+ void prepareToPlay (double sampleRate, int estimatedSamplesPerBlock);
+ void releaseResources();
+ void processBlock (AudioSampleBuffer& buffer,
+ MidiBuffer& midiMessages);
+
+ AudioProcessorEditor* createEditor();
+
+ const String getInputChannelName (const int index) const;
+ bool isInputChannelStereoPair (int index) const;
+
+ const String getOutputChannelName (const int index) const;
+ bool isOutputChannelStereoPair (int index) const;
+
+ int getNumParameters();
+ float getParameter (int index);
+ void setParameter (int index, float newValue);
+ const String getParameterName (int index);
+ const String getParameterText (int index);
+ bool isParameterAutomatable (int index) const;
+
+ int getNumPrograms();
+ int getCurrentProgram();
+ void setCurrentProgram (int index);
+ const String getProgramName (int index);
+ void changeProgramName (int index, const String& newName);
+
+ void getStateInformation (MemoryBlock& destData);
+ void getCurrentProgramStateInformation (MemoryBlock& destData);
+ void setStateInformation (const void* data, int sizeInBytes);
+ void setCurrentProgramStateInformation (const void* data, int sizeInBytes);
+
+ juce_UseDebuggingNewOperator
+
+private:
+ friend class AudioUnitPluginWindow;
+ friend class AudioUnitPluginFormat;
+
+ ComponentDescription componentDesc;
+ String pluginName, manufacturer, version;
+ File file;
+ CriticalSection lock;
+ bool initialised, wantsMidiMessages, wasPlaying;
+
+ AudioBufferList* outputBufferList;
+ AudioTimeStamp timeStamp;
+ AudioSampleBuffer* currentBuffer;
+
+ AudioUnit audioUnit;
+ Array parameterIds;
+
+ bool getComponentDescFromFile (const File& file);
+ void initialise();
+
+ OSStatus renderGetInput (AudioUnitRenderActionFlags* ioActionFlags,
+ const AudioTimeStamp* inTimeStamp,
+ UInt32 inBusNumber,
+ UInt32 inNumberFrames,
+ AudioBufferList* ioData) const;
+
+ static OSStatus renderGetInputCallback (void* inRefCon,
+ AudioUnitRenderActionFlags* ioActionFlags,
+ const AudioTimeStamp* inTimeStamp,
+ UInt32 inBusNumber,
+ UInt32 inNumberFrames,
+ AudioBufferList* ioData)
+ {
+ return ((AudioUnitPluginInstance*) inRefCon)
+ ->renderGetInput (ioActionFlags, inTimeStamp, inBusNumber, inNumberFrames, ioData);
+ }
+
+ OSStatus getBeatAndTempo (Float64* outCurrentBeat, Float64* outCurrentTempo) const;
+ OSStatus getMusicalTimeLocation (UInt32* outDeltaSampleOffsetToNextBeat, Float32* outTimeSig_Numerator,
+ UInt32* outTimeSig_Denominator, Float64* outCurrentMeasureDownBeat) const;
+ OSStatus getTransportState (Boolean* outIsPlaying, Boolean* outTransportStateChanged,
+ Float64* outCurrentSampleInTimeLine, Boolean* outIsCycling,
+ Float64* outCycleStartBeat, Float64* outCycleEndBeat);
+
+ static OSStatus getBeatAndTempoCallback (void* inHostUserData, Float64* outCurrentBeat, Float64* outCurrentTempo)
+ {
+ return ((AudioUnitPluginInstance*) inHostUserData)->getBeatAndTempo (outCurrentBeat, outCurrentTempo);
+ }
+
+ static OSStatus getMusicalTimeLocationCallback (void* inHostUserData, UInt32* outDeltaSampleOffsetToNextBeat,
+ Float32* outTimeSig_Numerator, UInt32* outTimeSig_Denominator,
+ Float64* outCurrentMeasureDownBeat)
+ {
+ return ((AudioUnitPluginInstance*) inHostUserData)
+ ->getMusicalTimeLocation (outDeltaSampleOffsetToNextBeat, outTimeSig_Numerator,
+ outTimeSig_Denominator, outCurrentMeasureDownBeat);
+ }
+
+ static OSStatus getTransportStateCallback (void* inHostUserData, Boolean* outIsPlaying, Boolean* outTransportStateChanged,
+ Float64* outCurrentSampleInTimeLine, Boolean* outIsCycling,
+ Float64* outCycleStartBeat, Float64* outCycleEndBeat)
+ {
+ return ((AudioUnitPluginInstance*) inHostUserData)
+ ->getTransportState (outIsPlaying, outTransportStateChanged,
+ outCurrentSampleInTimeLine, outIsCycling,
+ outCycleStartBeat, outCycleEndBeat);
+ }
+
+ void getNumChannels (int& numIns, int& numOuts)
+ {
+ numIns = 0;
+ numOuts = 0;
+
+ AUChannelInfo supportedChannels [128];
+ UInt32 supportedChannelsSize = sizeof (supportedChannels);
+
+ if (AudioUnitGetProperty (audioUnit, kAudioUnitProperty_SupportedNumChannels, kAudioUnitScope_Global,
+ 0, supportedChannels, &supportedChannelsSize) == noErr
+ && supportedChannelsSize > 0)
+ {
+ for (int i = 0; i < supportedChannelsSize / sizeof (AUChannelInfo); ++i)
+ {
+ numIns = jmax (numIns, supportedChannels[i].inChannels);
+ numOuts = jmax (numOuts, supportedChannels[i].outChannels);
+ }
+ }
+ else
+ {
+ // (this really means the plugin will take any number of ins/outs as long
+ // as they are the same)
+ numIns = numOuts = 2;
+ }
+ }
+
+ const String getCategory() const;
+
+ AudioUnitPluginInstance (const File& file);
+};
+
+AudioUnitPluginInstance::AudioUnitPluginInstance (const File& file_)
+ : file (file_),
+ initialised (false),
+ wantsMidiMessages (false),
+ audioUnit (0),
+ outputBufferList (0),
+ currentBuffer (0)
+{
+ try
+ {
+ ++insideCallback;
+
+ log (T("Opening AU: ") + file.getFullPathName());
+
+ if (getComponentDescFromFile (file))
+ {
+ ComponentRecord* const comp = FindNextComponent (0, &componentDesc);
+
+ if (comp != 0)
+ {
+ audioUnit = (AudioUnit) OpenComponent (comp);
+
+ wantsMidiMessages = componentDesc.componentType == kAudioUnitType_MusicDevice
+ || componentDesc.componentType == kAudioUnitType_MusicEffect;
+ }
+ }
+
+ --insideCallback;
+ }
+ catch (...)
+ {
+ --insideCallback;
+ }
+}
+
+AudioUnitPluginInstance::~AudioUnitPluginInstance()
+{
+ {
+ const ScopedLock sl (lock);
+
+ jassert (insideCallback == 0);
+
+ if (audioUnit != 0)
+ {
+ AudioUnitUninitialize (audioUnit);
+ CloseComponent (audioUnit);
+ audioUnit = 0;
+ }
+ }
+
+ juce_free (outputBufferList);
+}
+
+bool AudioUnitPluginInstance::getComponentDescFromFile (const File& file)
+{
+ zerostruct (componentDesc);
+
+ if (! file.hasFileExtension (T(".component")))
+ return false;
+
+ const String filename (file.getFullPathName());
+ const char* const utf8 = filename.toUTF8();
+ CFURLRef url = CFURLCreateFromFileSystemRepresentation (0, (const UInt8*) utf8,
+ strlen (utf8), file.isDirectory());
+ if (url != 0)
+ {
+ CFBundleRef bundleRef = CFBundleCreate (kCFAllocatorDefault, url);
+ CFRelease (url);
+
+ if (bundleRef != 0)
+ {
+ CFTypeRef name = CFBundleGetValueForInfoDictionaryKey (bundleRef, CFSTR("CFBundleName"));
+
+ if (name != 0 && CFGetTypeID (name) == CFStringGetTypeID())
+ pluginName = PlatformUtilities::cfStringToJuceString ((CFStringRef) name);
+
+ if (pluginName.isEmpty())
+ pluginName = file.getFileNameWithoutExtension();
+
+ CFTypeRef versionString = CFBundleGetValueForInfoDictionaryKey (bundleRef, CFSTR("CFBundleVersion"));
+
+ if (versionString != 0 && CFGetTypeID (versionString) == CFStringGetTypeID())
+ version = PlatformUtilities::cfStringToJuceString ((CFStringRef) versionString);
+
+ CFTypeRef manuString = CFBundleGetValueForInfoDictionaryKey (bundleRef, CFSTR("CFBundleGetInfoString"));
+
+ if (manuString != 0 && CFGetTypeID (manuString) == CFStringGetTypeID())
+ manufacturer = PlatformUtilities::cfStringToJuceString ((CFStringRef) manuString);
+
+ short resFileId = CFBundleOpenBundleResourceMap (bundleRef);
+ UseResFile (resFileId);
+
+ for (int i = 1; i <= Count1Resources ('thng'); ++i)
+ {
+ Handle h = Get1IndResource ('thng', i);
+
+ if (h != 0)
+ {
+ HLock (h);
+ const uint32* const types = (const uint32*) *h;
+
+ if (types[0] == kAudioUnitType_MusicDevice
+ || types[0] == kAudioUnitType_MusicEffect
+ || types[0] == kAudioUnitType_Effect
+ || types[0] == kAudioUnitType_Generator
+ || types[0] == kAudioUnitType_Panner)
+ {
+ componentDesc.componentType = types[0];
+ componentDesc.componentSubType = types[1];
+ componentDesc.componentManufacturer = types[2];
+ break;
+ }
+
+ HUnlock (h);
+ ReleaseResource (h);
+ }
+ }
+
+ CFBundleCloseBundleResourceMap (bundleRef, resFileId);
+ CFRelease (bundleRef);
+ }
+ }
+
+ return componentDesc.componentType != 0 && componentDesc.componentSubType != 0;
+}
+
+void AudioUnitPluginInstance::initialise()
+{
+ if (initialised || audioUnit == 0)
+ return;
+
+ log (T("Initialising AU: ") + pluginName);
+
+ parameterIds.clear();
+
+ {
+ UInt32 paramListSize = 0;
+ AudioUnitGetProperty (audioUnit, kAudioUnitProperty_ParameterList, kAudioUnitScope_Global,
+ 0, 0, ¶mListSize);
+
+ if (paramListSize > 0)
+ {
+ parameterIds.insertMultiple (0, 0, paramListSize / sizeof (int));
+
+ AudioUnitGetProperty (audioUnit, kAudioUnitProperty_ParameterList, kAudioUnitScope_Global,
+ 0, ¶meterIds.getReference(0), ¶mListSize);
+ }
+ }
+
+ {
+ AURenderCallbackStruct info;
+ zerostruct (info);
+ info.inputProcRefCon = this;
+ info.inputProc = renderGetInputCallback;
+
+ AudioUnitSetProperty (audioUnit, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input,
+ 0, &info, sizeof (info));
+ }
+
+ {
+ HostCallbackInfo info;
+ zerostruct (info);
+ info.hostUserData = this;
+ info.beatAndTempoProc = getBeatAndTempoCallback;
+ info.musicalTimeLocationProc = getMusicalTimeLocationCallback;
+ info.transportStateProc = getTransportStateCallback;
+
+ AudioUnitSetProperty (audioUnit, kAudioUnitProperty_HostCallbacks, kAudioUnitScope_Global,
+ 0, &info, sizeof (info));
+ }
+
+ int numIns, numOuts;
+ getNumChannels (numIns, numOuts);
+ setPlayConfigDetails (numIns, numOuts, 0, 0);
+
+ initialised = AudioUnitInitialize (audioUnit) == noErr;
+
+ setLatencySamples (0);
+}
+
+void AudioUnitPluginInstance::prepareToPlay (double sampleRate_,
+ int samplesPerBlockExpected)
+{
+ initialise();
+
+ if (initialised)
+ {
+ int numIns, numOuts;
+ getNumChannels (numIns, numOuts);
+
+ setPlayConfigDetails (numIns, numOuts, sampleRate_, samplesPerBlockExpected);
+
+ Float64 latencySecs = 0.0;
+ UInt32 latencySize = sizeof (latencySecs);
+ AudioUnitGetProperty (audioUnit, kAudioUnitProperty_Latency, kAudioUnitScope_Global,
+ 0, &latencySecs, &latencySize);
+
+ setLatencySamples (roundDoubleToInt (latencySecs * sampleRate_));
+
+ AudioUnitReset (audioUnit, kAudioUnitScope_Input, 0);
+ AudioUnitReset (audioUnit, kAudioUnitScope_Output, 0);
+ AudioUnitReset (audioUnit, kAudioUnitScope_Global, 0);
+
+ AudioStreamBasicDescription stream;
+ zerostruct (stream);
+ stream.mSampleRate = sampleRate_;
+ stream.mFormatID = kAudioFormatLinearPCM;
+ stream.mFormatFlags = kAudioFormatFlagsNativeFloatPacked | kAudioFormatFlagIsNonInterleaved;
+ stream.mFramesPerPacket = 1;
+ stream.mBytesPerPacket = 4;
+ stream.mBytesPerFrame = 4;
+ stream.mBitsPerChannel = 32;
+ stream.mChannelsPerFrame = numIns;
+
+ OSStatus err = AudioUnitSetProperty (audioUnit,
+ kAudioUnitProperty_StreamFormat,
+ kAudioUnitScope_Input,
+ 0, &stream, sizeof (stream));
+
+ stream.mChannelsPerFrame = numOuts;
+
+ err = AudioUnitSetProperty (audioUnit,
+ kAudioUnitProperty_StreamFormat,
+ kAudioUnitScope_Output,
+ 0, &stream, sizeof (stream));
+
+ juce_free (outputBufferList);
+ outputBufferList = (AudioBufferList*) juce_calloc (sizeof (AudioBufferList) + sizeof (AudioBuffer) * (numOuts + 1));
+ outputBufferList->mNumberBuffers = numOuts;
+
+ for (int i = numOuts; --i >= 0;)
+ outputBufferList->mBuffers[i].mNumberChannels = 1;
+
+ zerostruct (timeStamp);
+ timeStamp.mSampleTime = 0;
+ timeStamp.mHostTime = AudioGetCurrentHostTime();
+ timeStamp.mFlags = kAudioTimeStampSampleTimeValid | kAudioTimeStampHostTimeValid;
+
+ currentBuffer = 0;
+ wasPlaying = false;
+ }
+}
+
+void AudioUnitPluginInstance::releaseResources()
+{
+ if (initialised)
+ {
+ AudioUnitReset (audioUnit, kAudioUnitScope_Input, 0);
+ AudioUnitReset (audioUnit, kAudioUnitScope_Output, 0);
+ AudioUnitReset (audioUnit, kAudioUnitScope_Global, 0);
+
+ juce_free (outputBufferList);
+ outputBufferList = 0;
+ currentBuffer = 0;
+ }
+}
+
+OSStatus AudioUnitPluginInstance::renderGetInput (AudioUnitRenderActionFlags* ioActionFlags,
+ const AudioTimeStamp* inTimeStamp,
+ UInt32 inBusNumber,
+ UInt32 inNumberFrames,
+ AudioBufferList* ioData) const
+{
+ if (inBusNumber == 0
+ && currentBuffer != 0)
+ {
+ jassert (inNumberFrames == currentBuffer->getNumSamples()); // if this ever happens, might need to add extra handling
+
+ for (int i = 0; i < ioData->mNumberBuffers; ++i)
+ {
+ if (i < currentBuffer->getNumChannels())
+ {
+ memcpy (ioData->mBuffers[i].mData,
+ currentBuffer->getSampleData (i, 0),
+ sizeof (float) * inNumberFrames);
+ }
+ else
+ {
+ zeromem (ioData->mBuffers[i].mData, sizeof (float) * inNumberFrames);
+ }
+ }
+ }
+
+ return noErr;
+}
+
+void AudioUnitPluginInstance::processBlock (AudioSampleBuffer& buffer,
+ MidiBuffer& midiMessages)
+{
+ const int numSamples = buffer.getNumSamples();
+
+ if (initialised)
+ {
+ AudioUnitRenderActionFlags flags = 0;
+
+ timeStamp.mHostTime = AudioGetCurrentHostTime();
+
+ for (int i = getNumOutputChannels(); --i >= 0;)
+ {
+ outputBufferList->mBuffers[i].mDataByteSize = sizeof (float) * numSamples;
+ outputBufferList->mBuffers[i].mData = buffer.getSampleData (i, 0);
+ }
+
+ currentBuffer = &buffer;
+
+ if (wantsMidiMessages)
+ {
+ const uint8* midiEventData;
+ int midiEventSize, midiEventPosition;
+ MidiBuffer::Iterator i (midiMessages);
+
+ while (i.getNextEvent (midiEventData, midiEventSize, midiEventPosition))
+ {
+ if (midiEventSize <= 3)
+ MusicDeviceMIDIEvent (audioUnit,
+ midiEventData[0], midiEventData[1], midiEventData[2],
+ midiEventPosition);
+ else
+ MusicDeviceSysEx (audioUnit, midiEventData, midiEventSize);
+ }
+
+ midiMessages.clear();
+ }
+
+ AudioUnitRender (audioUnit, &flags, &timeStamp,
+ 0, numSamples, outputBufferList);
+
+ timeStamp.mSampleTime += numSamples;
+ }
+ else
+ {
+ // Not initialised, so just bypass..
+ for (int i = getNumInputChannels(); i < getNumOutputChannels(); ++i)
+ buffer.clear (i, 0, buffer.getNumSamples());
+ }
+}
+
+OSStatus AudioUnitPluginInstance::getBeatAndTempo (Float64* outCurrentBeat, Float64* outCurrentTempo) const
+{
+ AudioPlayHead* const ph = getPlayHead();
+ AudioPlayHead::CurrentPositionInfo result;
+
+ if (ph != 0 && ph->getCurrentPosition (result))
+ {
+ *outCurrentBeat = result.ppqPosition;
+ *outCurrentTempo = result.bpm;
+ }
+ else
+ {
+ *outCurrentBeat = 0;
+ *outCurrentTempo = 120.0;
+ }
+
+ return noErr;
+}
+
+OSStatus AudioUnitPluginInstance::getMusicalTimeLocation (UInt32* outDeltaSampleOffsetToNextBeat,
+ Float32* outTimeSig_Numerator,
+ UInt32* outTimeSig_Denominator,
+ Float64* outCurrentMeasureDownBeat) const
+{
+ AudioPlayHead* const ph = getPlayHead();
+ AudioPlayHead::CurrentPositionInfo result;
+
+ if (ph != 0 && ph->getCurrentPosition (result))
+ {
+ *outTimeSig_Numerator = result.timeSigNumerator;
+ *outTimeSig_Denominator = result.timeSigDenominator;
+
+ *outDeltaSampleOffsetToNextBeat = 0; //xxx
+ *outCurrentMeasureDownBeat = result.ppqPositionOfLastBarStart; //xxx wrong
+ }
+ else
+ {
+ *outDeltaSampleOffsetToNextBeat = 0;
+ *outTimeSig_Numerator = 4;
+ *outTimeSig_Denominator = 4;
+ *outCurrentMeasureDownBeat = 0;
+ }
+
+ return noErr;
+}
+
+OSStatus AudioUnitPluginInstance::getTransportState (Boolean* outIsPlaying,
+ Boolean* outTransportStateChanged,
+ Float64* outCurrentSampleInTimeLine,
+ Boolean* outIsCycling,
+ Float64* outCycleStartBeat,
+ Float64* outCycleEndBeat)
+{
+ AudioPlayHead* const ph = getPlayHead();
+ AudioPlayHead::CurrentPositionInfo result;
+
+ if (ph != 0 && ph->getCurrentPosition (result))
+ {
+ *outIsPlaying = result.isPlaying;
+ *outTransportStateChanged = result.isPlaying != wasPlaying;
+ wasPlaying = result.isPlaying;
+ *outCurrentSampleInTimeLine = roundDoubleToInt (result.timeInSeconds * getSampleRate());
+ *outIsCycling = false;
+ *outCycleStartBeat = 0;
+ *outCycleEndBeat = 0;
+ }
+ else
+ {
+ *outIsPlaying = false;
+ *outTransportStateChanged = false;
+ *outCurrentSampleInTimeLine = 0;
+ *outIsCycling = false;
+ *outCycleStartBeat = 0;
+ *outCycleEndBeat = 0;
+ }
+
+ return noErr;
+}
+
+static VoidArray activeWindows;
+
+class AudioUnitPluginWindow : public AudioProcessorEditor,
+ public Timer
+{
+public:
+
+ AudioUnitPluginWindow (AudioUnitPluginInstance& plugin_)
+ : AudioProcessorEditor (&plugin_),
+ plugin (plugin_),
+ isOpen (false),
+ pluginWantsKeys (false),
+ wasShowing (false),
+ recursiveResize (false),
+ viewComponent (0),
+ pluginViewRef (0)
+ {
+ movementWatcher = new CompMovementWatcher (this);
+
+ activeWindows.add (this);
+
+ setOpaque (true);
+ setVisible (true);
+ setSize (1, 1);
+
+ ComponentDescription viewList [16];
+ UInt32 viewListSize = sizeof (viewList);
+ AudioUnitGetProperty (plugin.audioUnit, kAudioUnitProperty_GetUIComponentList, kAudioUnitScope_Global,
+ 0, &viewList, &viewListSize);
+
+ componentRecord = FindNextComponent (0, &viewList[0]);
+ }
+
+ ~AudioUnitPluginWindow()
+ {
+ deleteAndZero (movementWatcher);
+
+ closePluginWindow();
+
+ activeWindows.removeValue (this);
+ plugin.editorBeingDeleted (this);
+ }
+
+ bool isValid() const throw() { return componentRecord != 0; }
+
+ void componentMovedOrResized()
+ {
+ if (recursiveResize)
+ return;
+
+ Component* const topComp = getTopLevelComponent();
+
+ if (topComp->getPeer() != 0)
+ {
+ int x = 0, y = 0;
+ relativePositionToOtherComponent (topComp, x, y);
+
+ recursiveResize = true;
+
+ if (pluginViewRef != 0)
+ {
+ HIRect r;
+ r.origin.x = (float) x;
+ r.origin.y = (float) y;
+ r.size.width = (float) getWidth();
+ r.size.height = (float) getHeight();
+ HIViewSetFrame (pluginViewRef, &r);
+ }
+
+ recursiveResize = false;
+ }
+ }
+
+ void componentVisibilityChanged()
+ {
+ const bool isShowingNow = isShowing();
+
+ if (wasShowing != isShowingNow)
+ {
+ wasShowing = isShowingNow;
+
+ if (isShowingNow)
+ openPluginWindow();
+ else
+ closePluginWindow();
+ }
+
+ componentMovedOrResized();
+ }
+
+ void componentPeerChanged()
+ {
+ closePluginWindow();
+ openPluginWindow();
+ }
+
+ void timerCallback()
+ {
+ if (pluginViewRef != 0)
+ {
+ HIRect bounds;
+ HIViewGetBounds (pluginViewRef, &bounds);
+ const int w = jmax (32, (int) bounds.size.width);
+ const int h = jmax (32, (int) bounds.size.height);
+
+ if (w != getWidth() || h != getHeight())
+ {
+ setSize (w, h);
+ startTimer (50);
+ }
+ else
+ {
+ startTimer (jlimit (50, 500, getTimerInterval() + 20));
+ }
+ }
+ }
+
+ bool keyStateChanged()
+ {
+ return pluginWantsKeys;
+ }
+
+ bool keyPressed (const KeyPress&)
+ {
+ return pluginWantsKeys;
+ }
+
+ void paint (Graphics& g)
+ {
+ if (isOpen)
+ {
+ ComponentPeer* const peer = getPeer();
+
+ if (peer != 0)
+ {
+ peer->addMaskedRegion (getScreenX() - peer->getScreenX(),
+ getScreenY() - peer->getScreenY(),
+ getWidth(), getHeight());
+ }
+ }
+ else
+ {
+ g.fillAll (Colours::black);
+ }
+ }
+
+ void broughtToFront()
+ {
+ activeWindows.removeValue (this);
+ activeWindows.add (this);
+ }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ AudioUnitPluginInstance& plugin;
+ bool isOpen, wasShowing, recursiveResize;
+ bool pluginWantsKeys;
+
+ ComponentRecord* componentRecord;
+ AudioUnitCarbonView viewComponent;
+ HIViewRef pluginViewRef;
+
+ void openPluginWindow()
+ {
+ if (isOpen || getWindowHandle() == 0 || componentRecord == 0)
+ return;
+
+ log (T("Opening AU GUI: ") + plugin.getName());
+ isOpen = true;
+
+ pluginWantsKeys = true; //xxx any way to find this out? Does it matter?
+
+ viewComponent = (AudioUnitCarbonView) OpenComponent (componentRecord);
+
+ if (viewComponent != 0)
+ {
+ Float32Point pos = { getScreenX() - getTopLevelComponent()->getScreenX(),
+ getScreenY() - getTopLevelComponent()->getScreenY() };
+ Float32Point size = { 250, 200 };
+
+ AudioUnitCarbonViewCreate (viewComponent,
+ plugin.audioUnit,
+ (WindowRef) getWindowHandle(),
+ HIViewGetRoot ((WindowRef) getWindowHandle()),
+ &pos, &size,
+ (ControlRef*) &pluginViewRef);
+ }
+
+ timerCallback(); // to set our comp to the right size
+ repaint();
+ }
+
+ void closePluginWindow()
+ {
+ stopTimer();
+
+ if (isOpen)
+ {
+ log (T("Closing AU GUI: ") + plugin.getName());
+ isOpen = false;
+
+ if (viewComponent != 0)
+ CloseComponent (viewComponent);
+
+ pluginViewRef = 0;
+ }
+ }
+
+ class CompMovementWatcher : public ComponentMovementWatcher
+ {
+ public:
+ CompMovementWatcher (AudioUnitPluginWindow* const owner_)
+ : ComponentMovementWatcher (owner_),
+ owner (owner_)
+ {
+ }
+
+ void componentMovedOrResized (bool /*wasMoved*/, bool /*wasResized*/)
+ {
+ owner->componentMovedOrResized();
+ }
+
+ void componentPeerChanged()
+ {
+ owner->componentPeerChanged();
+ }
+
+ void componentVisibilityChanged (Component&)
+ {
+ owner->componentVisibilityChanged();
+ }
+
+ private:
+ AudioUnitPluginWindow* const owner;
+ };
+
+ CompMovementWatcher* movementWatcher;
+};
+
+AudioProcessorEditor* AudioUnitPluginInstance::createEditor()
+{
+ AudioUnitPluginWindow* w = new AudioUnitPluginWindow (*this);
+
+ if (! w->isValid())
+ deleteAndZero (w);
+
+ return w;
+}
+
+const String AudioUnitPluginInstance::getCategory() const
+{
+ const char* result = 0;
+
+ switch (componentDesc.componentType)
+ {
+ case kAudioUnitType_Effect:
+ case kAudioUnitType_MusicEffect:
+ result = "Effect";
+ break;
+ case kAudioUnitType_MusicDevice:
+ result = "Synth";
+ break;
+ case kAudioUnitType_Generator:
+ result = "Generator";
+ break;
+ case kAudioUnitType_Panner:
+ result = "Panner";
+ break;
+ default:
+ break;
+ }
+
+ return result;
+}
+
+int AudioUnitPluginInstance::getNumParameters()
+{
+ return parameterIds.size();
+}
+
+float AudioUnitPluginInstance::getParameter (int index)
+{
+ const ScopedLock sl (lock);
+
+ Float32 value = 0.0f;
+
+ if (audioUnit != 0 && ((unsigned int) index) < (unsigned int) parameterIds.size())
+ {
+ AudioUnitGetParameter (audioUnit,
+ (UInt32) parameterIds.getUnchecked (index),
+ kAudioUnitScope_Global, 0,
+ &value);
+ }
+
+ return value;
+}
+
+void AudioUnitPluginInstance::setParameter (int index, float newValue)
+{
+ const ScopedLock sl (lock);
+
+ if (audioUnit != 0 && ((unsigned int) index) < (unsigned int) parameterIds.size())
+ {
+ AudioUnitSetParameter (audioUnit,
+ (UInt32) parameterIds.getUnchecked (index),
+ kAudioUnitScope_Global, 0,
+ newValue, 0);
+ }
+}
+
+const String AudioUnitPluginInstance::getParameterName (int index)
+{
+ AudioUnitParameterInfo info;
+ zerostruct (info);
+ UInt32 sz = sizeof (info);
+
+ String name;
+
+ if (AudioUnitGetProperty (audioUnit,
+ kAudioUnitProperty_ParameterInfo,
+ kAudioUnitScope_Global,
+ parameterIds [index], &info, &sz) == noErr)
+ {
+ if ((info.flags & kAudioUnitParameterFlag_HasCFNameString) != 0)
+ name = PlatformUtilities::cfStringToJuceString (info.cfNameString);
+ else
+ name = String (info.name, sizeof (info.name));
+ }
+
+ return name;
+}
+
+const String AudioUnitPluginInstance::getParameterText (int index)
+{
+ return String (getParameter (index));
+}
+
+bool AudioUnitPluginInstance::isParameterAutomatable (int index) const
+{
+ AudioUnitParameterInfo info;
+ UInt32 sz = sizeof (info);
+
+ if (AudioUnitGetProperty (audioUnit,
+ kAudioUnitProperty_ParameterInfo,
+ kAudioUnitScope_Global,
+ parameterIds [index], &info, &sz) == noErr)
+ {
+ return (info.flags & kAudioUnitParameterFlag_NonRealTime) == 0;
+ }
+
+ return true;
+}
+
+int AudioUnitPluginInstance::getNumPrograms()
+{
+ CFArrayRef presets;
+ UInt32 sz = sizeof (CFArrayRef);
+ int num = 0;
+
+ if (AudioUnitGetProperty (audioUnit,
+ kAudioUnitProperty_FactoryPresets,
+ kAudioUnitScope_Global,
+ 0, &presets, &sz) == noErr)
+ {
+ num = (int) CFArrayGetCount (presets);
+ CFRelease (presets);
+ }
+
+ return num;
+}
+
+int AudioUnitPluginInstance::getCurrentProgram()
+{
+ AUPreset current;
+ current.presetNumber = 0;
+ UInt32 sz = sizeof (AUPreset);
+
+ AudioUnitGetProperty (audioUnit,
+ kAudioUnitProperty_FactoryPresets,
+ kAudioUnitScope_Global,
+ 0, ¤t, &sz);
+
+ return current.presetNumber;
+}
+
+void AudioUnitPluginInstance::setCurrentProgram (int newIndex)
+{
+ AUPreset current;
+ current.presetNumber = newIndex;
+ current.presetName = 0;
+
+ AudioUnitSetProperty (audioUnit,
+ kAudioUnitProperty_FactoryPresets,
+ kAudioUnitScope_Global,
+ 0, ¤t, sizeof (AUPreset));
+}
+
+const String AudioUnitPluginInstance::getProgramName (int index)
+{
+ String s;
+ CFArrayRef presets;
+ UInt32 sz = sizeof (CFArrayRef);
+
+ if (AudioUnitGetProperty (audioUnit,
+ kAudioUnitProperty_FactoryPresets,
+ kAudioUnitScope_Global,
+ 0, &presets, &sz) == noErr)
+ {
+ for (CFIndex i = 0; i < CFArrayGetCount (presets); ++i)
+ {
+ const AUPreset* p = (const AUPreset*) CFArrayGetValueAtIndex (presets, i);
+
+ if (p != 0 && p->presetNumber == index)
+ {
+ s = PlatformUtilities::cfStringToJuceString (p->presetName);
+ break;
+ }
+ }
+
+ CFRelease (presets);
+ }
+
+ return s;
+}
+
+void AudioUnitPluginInstance::changeProgramName (int index, const String& newName)
+{
+ jassertfalse // xxx not implemented!
+}
+
+const String AudioUnitPluginInstance::getInputChannelName (const int index) const
+{
+ if (((unsigned int) index) < (unsigned int) getNumInputChannels())
+ return T("Input ") + String (index + 1);
+
+ return String::empty;
+}
+
+bool AudioUnitPluginInstance::isInputChannelStereoPair (int index) const
+{
+ if (((unsigned int) index) >= (unsigned int) getNumInputChannels())
+ return false;
+
+ return true;
+}
+
+const String AudioUnitPluginInstance::getOutputChannelName (const int index) const
+{
+ if (((unsigned int) index) < (unsigned int) getNumOutputChannels())
+ return T("Output ") + String (index + 1);
+
+ return String::empty;
+}
+
+bool AudioUnitPluginInstance::isOutputChannelStereoPair (int index) const
+{
+ if (((unsigned int) index) >= (unsigned int) getNumOutputChannels())
+ return false;
+
+ return true;
+}
+
+void AudioUnitPluginInstance::getStateInformation (MemoryBlock& destData)
+{
+ getCurrentProgramStateInformation (destData);
+}
+
+void AudioUnitPluginInstance::getCurrentProgramStateInformation (MemoryBlock& destData)
+{
+ CFPropertyListRef propertyList = 0;
+ UInt32 sz = sizeof (CFPropertyListRef);
+
+ if (AudioUnitGetProperty (audioUnit,
+ kAudioUnitProperty_ClassInfo,
+ kAudioUnitScope_Global,
+ 0, &propertyList, &sz) == noErr)
+ {
+ CFWriteStreamRef stream = CFWriteStreamCreateWithAllocatedBuffers (kCFAllocatorDefault, kCFAllocatorDefault);
+ CFWriteStreamOpen (stream);
+
+ CFIndex bytesWritten = CFPropertyListWriteToStream (propertyList, stream, kCFPropertyListBinaryFormat_v1_0, 0);
+ CFWriteStreamClose (stream);
+
+ CFDataRef data = (CFDataRef) CFWriteStreamCopyProperty (stream, kCFStreamPropertyDataWritten);
+
+ destData.setSize (bytesWritten);
+ destData.copyFrom (CFDataGetBytePtr (data), 0, destData.getSize());
+ CFRelease (data);
+
+ CFRelease (stream);
+ CFRelease (propertyList);
+ }
+}
+
+void AudioUnitPluginInstance::setStateInformation (const void* data, int sizeInBytes)
+{
+ setCurrentProgramStateInformation (data, sizeInBytes);
+}
+
+void AudioUnitPluginInstance::setCurrentProgramStateInformation (const void* data, int sizeInBytes)
+{
+ CFReadStreamRef stream = CFReadStreamCreateWithBytesNoCopy (kCFAllocatorDefault,
+ (const UInt8*) data,
+ sizeInBytes,
+ kCFAllocatorNull);
+ CFReadStreamOpen (stream);
+
+ CFPropertyListFormat format = kCFPropertyListBinaryFormat_v1_0;
+ CFPropertyListRef propertyList = CFPropertyListCreateFromStream (kCFAllocatorDefault,
+ stream,
+ 0,
+ kCFPropertyListImmutable,
+ &format,
+ 0);
+ CFRelease (stream);
+
+ if (propertyList != 0)
+ AudioUnitSetProperty (audioUnit,
+ kAudioUnitProperty_ClassInfo,
+ kAudioUnitScope_Global,
+ 0, &propertyList, sizeof (propertyList));
+}
+
+AudioUnitPluginFormat::AudioUnitPluginFormat()
+{
+}
+
+AudioUnitPluginFormat::~AudioUnitPluginFormat()
+{
+}
+
+void AudioUnitPluginFormat::findAllTypesForFile (OwnedArray & results,
+ const File& file)
+{
+ if (! fileMightContainThisPluginType (file))
+ return;
+
+ PluginDescription desc;
+ desc.file = file;
+ desc.uid = 0;
+
+ AudioUnitPluginInstance* instance = dynamic_cast (createInstanceFromDescription (desc));
+
+ if (instance == 0)
+ return;
+
+ try
+ {
+ instance->fillInPluginDescription (desc);
+ results.add (new PluginDescription (desc));
+ }
+ catch (...)
+ {
+ // crashed while loading...
+ }
+
+ deleteAndZero (instance);
+}
+
+AudioPluginInstance* AudioUnitPluginFormat::createInstanceFromDescription (const PluginDescription& desc)
+{
+ AudioUnitPluginInstance* result = 0;
+
+ if (fileMightContainThisPluginType (desc.file))
+ {
+ result = new AudioUnitPluginInstance (desc.file);
+
+ if (result->audioUnit != 0)
+ {
+ result->initialise();
+ }
+ else
+ {
+ deleteAndZero (result);
+ }
+ }
+
+ return result;
+}
+
+bool AudioUnitPluginFormat::fileMightContainThisPluginType (const File& f)
+{
+ return f.hasFileExtension (T(".component"))
+ && f.isDirectory();
+}
+
+const FileSearchPath AudioUnitPluginFormat::getDefaultLocationsToSearch()
+{
+ return FileSearchPath ("~/Library/Audio/Plug-Ins/Components;/Library/Audio/Plug-Ins/Components");
+}
+
+#endif
+
+END_JUCE_NAMESPACE
+
+#undef log
+
+#endif
+/********* End of inlined file: juce_AudioUnitPluginFormat.cpp *********/
+
+/********* Start of inlined file: juce_VSTPluginFormat.cpp *********/
+
+#if JUCE_PLUGINHOST_VST
+
+#ifdef _WIN32
+ #undef #define _WIN32_WINNT
+ #define _WIN32_WINNT 0x500
+ #undef STRICT
+ #define STRICT
+ #include
+ #include
+ #pragma warning (disable : 4312)
+#elif defined (LINUX)
+ #include
+ #include
+ #include
+ #include
+ #include
+ #undef Font
+ #undef KeyPress
+ #undef Drawable
+ #undef Time
+#else
+ #include
+#endif
+
+BEGIN_JUCE_NAMESPACE
+
+#undef PRAGMA_ALIGN_SUPPORTED
+#define VST_FORCE_DEPRECATED 0
+
+#ifdef _MSC_VER
+ #pragma warning (push)
+ #pragma warning (disable: 4996)
+#endif
+
+/* Obviously you're going to need the Steinberg vstsdk2.4 folder in
+ your include path if you want to add VST support.
+
+ If you're not interested in VSTs, you can disable them by changing the
+ JUCE_PLUGINHOST_VST flag in juce_Config.h
+*/
+#include "pluginterfaces/vst2.x/aeffectx.h"
+
+#ifdef _MSC_VER
+ #pragma warning (pop)
+#endif
+
+#if JUCE_LINUX
+ #define Font JUCE_NAMESPACE::Font
+ #define KeyPress JUCE_NAMESPACE::KeyPress
+ #define Drawable JUCE_NAMESPACE::Drawable
+ #define Time JUCE_NAMESPACE::Time
+#endif
+
+#if ! JUCE_WIN32
+ #define _fpreset()
+ #define _clearfp()
+#endif
+
+extern void juce_callAnyTimersSynchronously();
+
+const int fxbVersionNum = 1;
+
+struct fxProgram
+{
+ long chunkMagic; // 'CcnK'
+ long byteSize; // of this chunk, excl. magic + byteSize
+ long fxMagic; // 'FxCk'
+ long version;
+ long fxID; // fx unique id
+ long fxVersion;
+ long numParams;
+ char prgName[28];
+ float params[1]; // variable no. of parameters
+};
+
+struct fxSet
+{
+ long chunkMagic; // 'CcnK'
+ long byteSize; // of this chunk, excl. magic + byteSize
+ long fxMagic; // 'FxBk'
+ long version;
+ long fxID; // fx unique id
+ long fxVersion;
+ long numPrograms;
+ char future[128];
+ fxProgram programs[1]; // variable no. of programs
+};
+
+struct fxChunkSet
+{
+ long chunkMagic; // 'CcnK'
+ long byteSize; // of this chunk, excl. magic + byteSize
+ long fxMagic; // 'FxCh', 'FPCh', or 'FBCh'
+ long version;
+ long fxID; // fx unique id
+ long fxVersion;
+ long numPrograms;
+ char future[128];
+ long chunkSize;
+ char chunk[8]; // variable
+};
+
+struct fxProgramSet
+{
+ long chunkMagic; // 'CcnK'
+ long byteSize; // of this chunk, excl. magic + byteSize
+ long fxMagic; // 'FxCh', 'FPCh', or 'FBCh'
+ long version;
+ long fxID; // fx unique id
+ long fxVersion;
+ long numPrograms;
+ char name[28];
+ long chunkSize;
+ char chunk[8]; // variable
+};
+
+#ifdef JUCE_LITTLE_ENDIAN
+ static long swap (const long x) throw() { return (long) swapByteOrder ((uint32) x); }
+
+ static float swapFloat (const float x) throw()
+ {
+ union { uint32 asInt; float asFloat; } n;
+ n.asFloat = x;
+ n.asInt = swapByteOrder (n.asInt);
+ return n.asFloat;
+ }
+#else
+ #define swap(x) (x)
+ #define swapFloat(x) (x)
+#endif
+
+typedef AEffect* (*MainCall) (audioMasterCallback);
+
+static VstIntPtr VSTCALLBACK audioMaster (AEffect* effect, VstInt32 opcode, VstInt32 index, VstIntPtr value, void* ptr, float opt);
+
+static int shellUIDToCreate = 0;
+static int insideVSTCallback = 0;
+
+class VSTPluginWindow;
+
+// Change this to disable logging of various VST activities
+#ifndef VST_LOGGING
+ #define VST_LOGGING 1
+#endif
+
+#if VST_LOGGING
+ #define log(a) Logger::writeToLog(a);
+#else
+ #define log(a)
+#endif
+
+#if JUCE_MAC
+extern bool juce_isHIViewCreatedByJuce (HIViewRef view);
+extern bool juce_isWindowCreatedByJuce (WindowRef window);
+
+#if JUCE_PPC
+static void* NewCFMFromMachO (void* const machofp) throw()
+{
+ void* result = juce_malloc (8);
+
+ ((void**) result)[0] = machofp;
+ ((void**) result)[1] = result;
+
+ return result;
+}
+#endif
+#endif
+
+#if JUCE_LINUX
+
+extern Display* display;
+extern XContext improbableNumber;
+
+typedef void (*EventProcPtr) (XEvent* ev);
+
+static bool xErrorTriggered;
+
+static int temporaryErrorHandler (Display*, XErrorEvent*)
+{
+ xErrorTriggered = true;
+ return 0;
+}
+
+static int getPropertyFromXWindow (Window handle, Atom atom)
+{
+ XErrorHandler oldErrorHandler = XSetErrorHandler (temporaryErrorHandler);
+ xErrorTriggered = false;
+
+ int userSize;
+ unsigned long bytes, userCount;
+ unsigned char* data;
+ Atom userType;
+
+ XGetWindowProperty (display, handle, atom, 0, 1, false, AnyPropertyType,
+ &userType, &userSize, &userCount, &bytes, &data);
+
+ XSetErrorHandler (oldErrorHandler);
+
+ return (userCount == 1 && ! xErrorTriggered) ? *(int*) data
+ : 0;
+}
+
+static Window getChildWindow (Window windowToCheck)
+{
+ Window rootWindow, parentWindow;
+ Window* childWindows;
+ unsigned int numChildren;
+
+ XQueryTree (display,
+ windowToCheck,
+ &rootWindow,
+ &parentWindow,
+ &childWindows,
+ &numChildren);
+
+ if (numChildren > 0)
+ return childWindows [0];
+
+ return 0;
+}
+
+static void translateJuceToXButtonModifiers (const MouseEvent& e, XEvent& ev) throw()
+{
+ if (e.mods.isLeftButtonDown())
+ {
+ ev.xbutton.button = Button1;
+ ev.xbutton.state |= Button1Mask;
+ }
+ else if (e.mods.isRightButtonDown())
+ {
+ ev.xbutton.button = Button3;
+ ev.xbutton.state |= Button3Mask;
+ }
+ else if (e.mods.isMiddleButtonDown())
+ {
+ ev.xbutton.button = Button2;
+ ev.xbutton.state |= Button2Mask;
+ }
+}
+
+static void translateJuceToXMotionModifiers (const MouseEvent& e, XEvent& ev) throw()
+{
+ if (e.mods.isLeftButtonDown())
+ ev.xmotion.state |= Button1Mask;
+ else if (e.mods.isRightButtonDown())
+ ev.xmotion.state |= Button3Mask;
+ else if (e.mods.isMiddleButtonDown())
+ ev.xmotion.state |= Button2Mask;
+}
+
+static void translateJuceToXCrossingModifiers (const MouseEvent& e, XEvent& ev) throw()
+{
+ if (e.mods.isLeftButtonDown())
+ ev.xcrossing.state |= Button1Mask;
+ else if (e.mods.isRightButtonDown())
+ ev.xcrossing.state |= Button3Mask;
+ else if (e.mods.isMiddleButtonDown())
+ ev.xcrossing.state |= Button2Mask;
+}
+
+static void translateJuceToXMouseWheelModifiers (const MouseEvent& e, const float increment, XEvent& ev) throw()
+{
+ if (increment < 0)
+ {
+ ev.xbutton.button = Button5;
+ ev.xbutton.state |= Button5Mask;
+ }
+ else if (increment > 0)
+ {
+ ev.xbutton.button = Button4;
+ ev.xbutton.state |= Button4Mask;
+ }
+}
+
+#endif
+
+static VoidArray activeModules;
+
+class ModuleHandle : public ReferenceCountedObject
+{
+public:
+
+ File file;
+ MainCall moduleMain;
+ String pluginName;
+
+ static ModuleHandle* findOrCreateModule (const File& file)
+ {
+ for (int i = activeModules.size(); --i >= 0;)
+ {
+ ModuleHandle* const module = (ModuleHandle*) activeModules.getUnchecked(i);
+
+ if (module->file == file)
+ return module;
+ }
+
+ _fpreset(); // (doesn't do any harm)
+ ++insideVSTCallback;
+ shellUIDToCreate = 0;
+
+ log ("Attempting to load VST: " + file.getFullPathName());
+
+ ModuleHandle* m = new ModuleHandle (file);
+
+ if (! m->open())
+ deleteAndZero (m);
+
+ --insideVSTCallback;
+ _fpreset(); // (doesn't do any harm)
+
+ return m;
+ }
+
+ ModuleHandle (const File& file_)
+ : file (file_),
+ moduleMain (0),
+#if JUCE_WIN32 || JUCE_LINUX
+ hModule (0)
+#elif JUCE_MAC
+ fragId (0),
+ resHandle (0),
+ bundleRef (0),
+ resFileId (0)
+#endif
+ {
+ activeModules.add (this);
+
+#if JUCE_WIN32 || JUCE_LINUX
+ fullParentDirectoryPathName = file_.getParentDirectory().getFullPathName();
+#elif JUCE_MAC
+ PlatformUtilities::makeFSSpecFromPath (&parentDirFSSpec, file_.getParentDirectory().getFullPathName());
+#endif
+ }
+
+ ~ModuleHandle()
+ {
+ activeModules.removeValue (this);
+
+ close();
+ }
+
+ juce_UseDebuggingNewOperator
+
+#if JUCE_WIN32 || JUCE_LINUX
+ void* hModule;
+ String fullParentDirectoryPathName;
+
+ bool open()
+ {
+#if JUCE_WIN32
+ static bool timePeriodSet = false;
+
+ if (! timePeriodSet)
+ {
+ timePeriodSet = true;
+ timeBeginPeriod (2);
+ }
+#endif
+
+ pluginName = file.getFileNameWithoutExtension();
+
+ hModule = Process::loadDynamicLibrary (file.getFullPathName());
+
+ moduleMain = (MainCall) Process::getProcedureEntryPoint (hModule, "VSTPluginMain");
+
+ if (moduleMain == 0)
+ moduleMain = (MainCall) Process::getProcedureEntryPoint (hModule, "main");
+
+ return moduleMain != 0;
+ }
+
+ void close()
+ {
+ _fpreset(); // (doesn't do any harm)
+
+ Process::freeDynamicLibrary (hModule);
+ }
+
+ void closeEffect (AEffect* eff)
+ {
+ eff->dispatcher (eff, effClose, 0, 0, 0, 0);
+ }
+
+#else
+ CFragConnectionID fragId;
+ Handle resHandle;
+ CFBundleRef bundleRef;
+ FSSpec parentDirFSSpec;
+ short resFileId;
+
+ bool open()
+ {
+ bool ok = false;
+ const String filename (file.getFullPathName());
+
+ if (file.hasFileExtension (T(".vst")))
+ {
+ const char* const utf8 = filename.toUTF8();
+ CFURLRef url = CFURLCreateFromFileSystemRepresentation (0, (const UInt8*) utf8,
+ strlen (utf8), file.isDirectory());
+
+ if (url != 0)
+ {
+ bundleRef = CFBundleCreate (kCFAllocatorDefault, url);
+ CFRelease (url);
+
+ if (bundleRef != 0)
+ {
+ if (CFBundleLoadExecutable (bundleRef))
+ {
+ moduleMain = (MainCall) CFBundleGetFunctionPointerForName (bundleRef, CFSTR("main_macho"));
+
+ if (moduleMain == 0)
+ moduleMain = (MainCall) CFBundleGetFunctionPointerForName (bundleRef, CFSTR("VSTPluginMain"));
+
+ if (moduleMain != 0)
+ {
+ CFTypeRef name = CFBundleGetValueForInfoDictionaryKey (bundleRef, CFSTR("CFBundleName"));
+
+ if (name != 0)
+ {
+ if (CFGetTypeID (name) == CFStringGetTypeID())
+ {
+ char buffer[1024];
+
+ if (CFStringGetCString ((CFStringRef) name, buffer, sizeof (buffer), CFStringGetSystemEncoding()))
+ pluginName = buffer;
+ }
+ }
+
+ if (pluginName.isEmpty())
+ pluginName = file.getFileNameWithoutExtension();
+
+ resFileId = CFBundleOpenBundleResourceMap (bundleRef);
+
+ ok = true;
+ }
+ }
+
+ if (! ok)
+ {
+ CFBundleUnloadExecutable (bundleRef);
+ CFRelease (bundleRef);
+ bundleRef = 0;
+ }
+ }
+ }
+ }
+#if JUCE_PPC
+ else
+ {
+ FSRef fn;
+
+ if (FSPathMakeRef ((UInt8*) (const char*) filename, &fn, 0) == noErr)
+ {
+ resFileId = FSOpenResFile (&fn, fsRdPerm);
+
+ if (resFileId != -1)
+ {
+ const int numEffs = Count1Resources ('aEff');
+
+ for (int i = 0; i < numEffs; ++i)
+ {
+ resHandle = Get1IndResource ('aEff', i + 1);
+
+ if (resHandle != 0)
+ {
+ OSType type;
+ Str255 name;
+ SInt16 id;
+ GetResInfo (resHandle, &id, &type, name);
+ pluginName = String ((const char*) name + 1, name[0]);
+ DetachResource (resHandle);
+ HLock (resHandle);
+
+ Ptr ptr;
+ Str255 errorText;
+
+ OSErr err = GetMemFragment (*resHandle, GetHandleSize (resHandle),
+ name, kPrivateCFragCopy,
+ &fragId, &ptr, errorText);
+
+ if (err == noErr)
+ {
+ moduleMain = (MainCall) newMachOFromCFM (ptr);
+ ok = true;
+ }
+ else
+ {
+ HUnlock (resHandle);
+ }
+
+ break;
+ }
+ }
+
+ if (! ok)
+ CloseResFile (resFileId);
+ }
+ }
+ }
+#endif
+
+ return ok;
+ }
+
+ void close()
+ {
+#if JUCE_PPC
+ if (fragId != 0)
+ {
+ if (moduleMain != 0)
+ disposeMachOFromCFM ((void*) moduleMain);
+
+ CloseConnection (&fragId);
+ HUnlock (resHandle);
+
+ if (resFileId != 0)
+ CloseResFile (resFileId);
+ }
+ else
+#endif
+ if (bundleRef != 0)
+ {
+ CFBundleCloseBundleResourceMap (bundleRef, resFileId);
+
+ if (CFGetRetainCount (bundleRef) == 1)
+ CFBundleUnloadExecutable (bundleRef);
+
+ if (CFGetRetainCount (bundleRef) > 0)
+ CFRelease (bundleRef);
+ }
+ }
+
+ void closeEffect (AEffect* eff)
+ {
+#if JUCE_PPC
+ if (fragId != 0)
+ {
+ VoidArray thingsToDelete;
+ thingsToDelete.add ((void*) eff->dispatcher);
+ thingsToDelete.add ((void*) eff->process);
+ thingsToDelete.add ((void*) eff->setParameter);
+ thingsToDelete.add ((void*) eff->getParameter);
+ thingsToDelete.add ((void*) eff->processReplacing);
+
+ eff->dispatcher (eff, effClose, 0, 0, 0, 0);
+
+ for (int i = thingsToDelete.size(); --i >= 0;)
+ disposeMachOFromCFM (thingsToDelete[i]);
+ }
+ else
+#endif
+ {
+ eff->dispatcher (eff, effClose, 0, 0, 0, 0);
+ }
+ }
+
+#if JUCE_PPC
+ static void* newMachOFromCFM (void* cfmfp)
+ {
+ if (cfmfp == 0)
+ return 0;
+
+ UInt32* const mfp = (UInt32*) juce_malloc (sizeof (UInt32) * 6);
+
+ mfp[0] = 0x3d800000 | ((UInt32) cfmfp >> 16);
+ mfp[1] = 0x618c0000 | ((UInt32) cfmfp & 0xffff);
+ mfp[2] = 0x800c0000;
+ mfp[3] = 0x804c0004;
+ mfp[4] = 0x7c0903a6;
+ mfp[5] = 0x4e800420;
+
+ MakeDataExecutable (mfp, sizeof (UInt32) * 6);
+ return mfp;
+ }
+
+ static void disposeMachOFromCFM (void* ptr)
+ {
+ juce_free (ptr);
+ }
+
+ void coerceAEffectFunctionCalls (AEffect* eff)
+ {
+ if (fragId != 0)
+ {
+ eff->dispatcher = (AEffectDispatcherProc) newMachOFromCFM ((void*) eff->dispatcher);
+ eff->process = (AEffectProcessProc) newMachOFromCFM ((void*) eff->process);
+ eff->setParameter = (AEffectSetParameterProc) newMachOFromCFM ((void*) eff->setParameter);
+ eff->getParameter = (AEffectGetParameterProc) newMachOFromCFM ((void*) eff->getParameter);
+ eff->processReplacing = (AEffectProcessProc) newMachOFromCFM ((void*) eff->processReplacing);
+ }
+ }
+#endif
+
+#endif
+};
+
+/**
+ An instance of a plugin, created by a VSTPluginFormat.
+
+*/
+class VSTPluginInstance : public AudioPluginInstance,
+ private Timer,
+ private AsyncUpdater
+{
+public:
+
+ ~VSTPluginInstance();
+
+ // AudioPluginInstance methods:
+
+ void fillInPluginDescription (PluginDescription& desc) const
+ {
+ desc.name = name;
+ desc.file = module->file;
+ desc.uid = getUID();
+ desc.lastFileModTime = desc.file.getLastModificationTime();
+ desc.pluginFormatName = "VST";
+ desc.category = getCategory();
+
+ {
+ char buffer [kVstMaxVendorStrLen + 8];
+ zerostruct (buffer);
+ dispatch (effGetVendorString, 0, 0, buffer, 0);
+ desc.manufacturerName = buffer;
+ }
+
+ desc.version = getVersion();
+ desc.numInputChannels = getNumInputChannels();
+ desc.numOutputChannels = getNumOutputChannels();
+ desc.isInstrument = (effect != 0 && (effect->flags & effFlagsIsSynth) != 0);
+ }
+
+ const String getName() const { return name; }
+ int getUID() const throw();
+ bool acceptsMidi() const { return wantsMidiMessages; }
+ bool producesMidi() const { return dispatch (effCanDo, 0, 0, (void*) "sendVstMidiEvent", 0) > 0; }
+
+ // AudioProcessor methods:
+
+ void prepareToPlay (double sampleRate, int estimatedSamplesPerBlock);
+ void releaseResources();
+ void processBlock (AudioSampleBuffer& buffer,
+ MidiBuffer& midiMessages);
+
+ AudioProcessorEditor* createEditor();
+
+ const String getInputChannelName (const int index) const;
+ bool isInputChannelStereoPair (int index) const;
+
+ const String getOutputChannelName (const int index) const;
+ bool isOutputChannelStereoPair (int index) const;
+
+ int getNumParameters() { return effect != 0 ? effect->numParams : 0; }
+ float getParameter (int index);
+ void setParameter (int index, float newValue);
+ const String getParameterName (int index);
+ const String getParameterText (int index);
+ bool isParameterAutomatable (int index) const;
+
+ int getNumPrograms() { return effect != 0 ? effect->numPrograms : 0; }
+ int getCurrentProgram() { return dispatch (effGetProgram, 0, 0, 0, 0); }
+ void setCurrentProgram (int index);
+ const String getProgramName (int index);
+ void changeProgramName (int index, const String& newName);
+
+ void getStateInformation (MemoryBlock& destData);
+ void getCurrentProgramStateInformation (MemoryBlock& destData);
+ void setStateInformation (const void* data, int sizeInBytes);
+ void setCurrentProgramStateInformation (const void* data, int sizeInBytes);
+
+ void timerCallback();
+ void handleAsyncUpdate();
+ VstIntPtr handleCallback (VstInt32 opcode, VstInt32 index, VstInt32 value, void *ptr, float opt);
+
+ juce_UseDebuggingNewOperator
+
+private:
+ friend class VSTPluginWindow;
+ friend class VSTPluginFormat;
+
+ AEffect* effect;
+ String name;
+ CriticalSection lock;
+ bool wantsMidiMessages, initialised, isPowerOn;
+ mutable StringArray programNames;
+ AudioSampleBuffer tempBuffer;
+ CriticalSection midiInLock;
+ MidiBuffer incomingMidi;
+ void* midiEventsToSend;
+ int numAllocatedMidiEvents;
+ VstTimeInfo vstHostTime;
+ float** channels;
+
+ ReferenceCountedObjectPtr module;
+
+ int dispatch (const int opcode, const int index, const int value, void* const ptr, float opt) const;
+ bool restoreProgramSettings (const fxProgram* const prog);
+ const String getCurrentProgramName();
+ void setParamsInProgramBlock (fxProgram* const prog) throw();
+ void updateStoredProgramNames();
+ void initialise();
+ void ensureMidiEventSize (int numEventsNeeded);
+ void freeMidiEvents();
+ void handleMidiFromPlugin (const VstEvents* const events);
+ void createTempParameterStore (MemoryBlock& dest);
+ void restoreFromTempParameterStore (const MemoryBlock& mb);
+ const String getParameterLabel (int index) const;
+
+ bool usesChunks() const throw() { return effect != 0 && (effect->flags & effFlagsProgramChunks) != 0; }
+ void getChunkData (MemoryBlock& mb, bool isPreset, int maxSizeMB) const;
+ void setChunkData (const char* data, int size, bool isPreset);
+ bool loadFromFXBFile (const void* data, int numBytes);
+ bool saveToFXBFile (MemoryBlock& dest, bool isFXB, int maxSizeMB);
+
+ int getVersionNumber() const throw() { return effect != 0 ? effect->version : 0; }
+ const String getVersion() const throw();
+ const String getCategory() const throw();
+
+ bool hasEditor() const throw() { return effect != 0 && (effect->flags & effFlagsHasEditor) != 0; }
+ void setPower (const bool on);
+
+ VSTPluginInstance (const ReferenceCountedObjectPtr & module);
+};
+
+VSTPluginInstance::VSTPluginInstance (const ReferenceCountedObjectPtr & module_)
+ : effect (0),
+ wantsMidiMessages (false),
+ initialised (false),
+ isPowerOn (false),
+ numAllocatedMidiEvents (0),
+ midiEventsToSend (0),
+ tempBuffer (1, 1),
+ channels (0),
+ module (module_)
+{
+ try
+ {
+ _fpreset();
+
+ ++insideVSTCallback;
+
+ name = module->pluginName;
+ log (T("Creating VST instance: ") + name);
+
+#if JUCE_MAC
+ if (module->resFileId != 0)
+ UseResFile (module->resFileId);
+
+#if JUCE_PPC
+ if (module->fragId != 0)
+ {
+ static void* audioMasterCoerced = 0;
+ if (audioMasterCoerced == 0)
+ audioMasterCoerced = NewCFMFromMachO ((void*) &audioMaster);
+
+ effect = module->moduleMain ((audioMasterCallback) audioMasterCoerced);
+ }
+ else
+#endif
+#endif
+ {
+ effect = module->moduleMain (&audioMaster);
+ }
+
+ --insideVSTCallback;
+
+ if (effect != 0 && effect->magic == kEffectMagic)
+ {
+#if JUCE_PPC
+ module->coerceAEffectFunctionCalls (effect);
+#endif
+
+ jassert (effect->resvd2 == 0);
+ jassert (effect->object != 0);
+
+ _fpreset(); // some dodgy plugs fuck around with this
+ }
+ else
+ {
+ effect = 0;
+ }
+ }
+ catch (...)
+ {
+ --insideVSTCallback;
+ }
+}
+
+VSTPluginInstance::~VSTPluginInstance()
+{
+ {
+ const ScopedLock sl (lock);
+
+ jassert (insideVSTCallback == 0);
+
+ if (effect != 0 && effect->magic == kEffectMagic)
+ {
+ try
+ {
+#if JUCE_MAC
+ if (module->resFileId != 0)
+ UseResFile (module->resFileId);
+#endif
+
+ // Must delete any editors before deleting the plugin instance!
+ jassert (getActiveEditor() == 0);
+
+ _fpreset(); // some dodgy plugs fuck around with this
+
+ module->closeEffect (effect);
+ }
+ catch (...)
+ {}
+ }
+
+ module = 0;
+ effect = 0;
+ }
+
+ freeMidiEvents();
+
+ juce_free (channels);
+ channels = 0;
+}
+
+void VSTPluginInstance::initialise()
+{
+ if (initialised || effect == 0)
+ return;
+
+ log (T("Initialising VST: ") + module->pluginName);
+ initialised = true;
+
+ dispatch (effIdentify, 0, 0, 0, 0);
+
+ // this code would ask the plugin for its name, but so few plugins
+ // actually bother implementing this correctly, that it's better to
+ // just ignore it and use the file name instead.
+/* {
+ char buffer [256];
+ zerostruct (buffer);
+ dispatch (effGetEffectName, 0, 0, buffer, 0);
+
+ name = String (buffer).trim();
+ if (name.isEmpty())
+ name = module->pluginName;
+ }
+*/
+
+ if (getSampleRate() > 0)
+ dispatch (effSetSampleRate, 0, 0, 0, (float) getSampleRate());
+
+ if (getBlockSize() > 0)
+ dispatch (effSetBlockSize, 0, jmax (32, getBlockSize()), 0, 0);
+
+ dispatch (effOpen, 0, 0, 0, 0);
+
+ setPlayConfigDetails (effect->numInputs, effect->numOutputs,
+ getSampleRate(), getBlockSize());
+
+ if (getNumPrograms() > 1)
+ setCurrentProgram (0);
+ else
+ dispatch (effSetProgram, 0, 0, 0, 0);
+
+ int i;
+ for (i = effect->numInputs; --i >= 0;)
+ dispatch (effConnectInput, i, 1, 0, 0);
+
+ for (i = effect->numOutputs; --i >= 0;)
+ dispatch (effConnectOutput, i, 1, 0, 0);
+
+ updateStoredProgramNames();
+
+ wantsMidiMessages = dispatch (effCanDo, 0, 0, (void*) "receiveVstMidiEvent", 0) > 0;
+
+ setLatencySamples (effect->initialDelay);
+}
+
+void VSTPluginInstance::prepareToPlay (double sampleRate_,
+ int samplesPerBlockExpected)
+{
+ setPlayConfigDetails (effect->numInputs, effect->numOutputs,
+ sampleRate_, samplesPerBlockExpected);
+
+ setLatencySamples (effect->initialDelay);
+
+ juce_free (channels);
+ channels = (float**) juce_calloc (sizeof (float*) * jmax (16, getNumOutputChannels() + 2, getNumInputChannels() + 2));
+
+ vstHostTime.tempo = 120.0;
+ vstHostTime.timeSigNumerator = 4;
+ vstHostTime.timeSigDenominator = 4;
+ vstHostTime.sampleRate = sampleRate_;
+ vstHostTime.samplePos = 0;
+ vstHostTime.flags = kVstNanosValid; /*| kVstTransportPlaying | kVstTempoValid | kVstTimeSigValid*/;
+
+ initialise();
+
+ if (initialised)
+ {
+ wantsMidiMessages = wantsMidiMessages
+ || (dispatch (effCanDo, 0, 0, (void*) "receiveVstMidiEvent", 0) > 0);
+
+ if (wantsMidiMessages)
+ ensureMidiEventSize (256);
+ else
+ freeMidiEvents();
+
+ incomingMidi.clear();
+
+ dispatch (effSetSampleRate, 0, 0, 0, (float) sampleRate_);
+ dispatch (effSetBlockSize, 0, jmax (16, samplesPerBlockExpected), 0, 0);
+
+ tempBuffer.setSize (jmax (1, effect->numOutputs), samplesPerBlockExpected);
+
+ if (! isPowerOn)
+ setPower (true);
+
+ // dodgy hack to force some plugins to initialise the sample rate..
+ if ((! hasEditor()) && getNumParameters() > 0)
+ {
+ const float old = getParameter (0);
+ setParameter (0, (old < 0.5f) ? 1.0f : 0.0f);
+ setParameter (0, old);
+ }
+
+ dispatch (effStartProcess, 0, 0, 0, 0);
+ }
+}
+
+void VSTPluginInstance::releaseResources()
+{
+ if (initialised)
+ {
+ dispatch (effStopProcess, 0, 0, 0, 0);
+ setPower (false);
+ }
+
+ tempBuffer.setSize (1, 1);
+ incomingMidi.clear();
+
+ freeMidiEvents();
+ juce_free (channels);
+ channels = 0;
+}
+
+void VSTPluginInstance::processBlock (AudioSampleBuffer& buffer,
+ MidiBuffer& midiMessages)
+{
+ const int numSamples = buffer.getNumSamples();
+
+ if (initialised)
+ {
+#if JUCE_WIN32
+ vstHostTime.nanoSeconds = timeGetTime() * 1000000.0;
+#elif JUCE_LINUX
+ timeval micro;
+ gettimeofday (µ, 0);
+ vstHostTime.nanoSeconds = micro.tv_usec * 1000.0;
+#elif JUCE_MAC
+ UnsignedWide micro;
+ Microseconds (µ);
+ vstHostTime.nanoSeconds = micro.lo * 1000.0;
+#endif
+
+ if (wantsMidiMessages)
+ {
+ MidiBuffer::Iterator iter (midiMessages);
+
+ int eventIndex = 0;
+ const uint8* midiData;
+ int numBytesOfMidiData, samplePosition;
+
+ while (iter.getNextEvent (midiData, numBytesOfMidiData, samplePosition))
+ {
+ if (numBytesOfMidiData < 4)
+ {
+ ensureMidiEventSize (eventIndex);
+ VstMidiEvent* const e
+ = (VstMidiEvent*) ((VstEvents*) midiEventsToSend)->events [eventIndex++];
+
+ // check that some plugin hasn't messed up our objects
+ jassert (e->type == kVstMidiType);
+ jassert (e->byteSize == 24);
+
+ e->deltaFrames = jlimit (0, numSamples - 1, samplePosition);
+ e->noteLength = 0;
+ e->noteOffset = 0;
+ e->midiData[0] = midiData[0];
+ e->midiData[1] = midiData[1];
+ e->midiData[2] = midiData[2];
+ e->detune = 0;
+ e->noteOffVelocity = 0;
+ }
+ }
+
+ if (midiEventsToSend == 0)
+ ensureMidiEventSize (1);
+
+ ((VstEvents*) midiEventsToSend)->numEvents = eventIndex;
+
+ try
+ {
+ effect->dispatcher (effect, effProcessEvents, 0, 0, midiEventsToSend, 0);
+ }
+ catch (...)
+ {}
+ }
+
+ int i;
+ const int maxChans = jmax (effect->numInputs, effect->numOutputs);
+
+ for (i = 0; i < maxChans; ++i)
+ channels[i] = buffer.getSampleData (i);
+
+ channels [maxChans] = 0;
+
+ _clearfp();
+
+ if ((effect->flags & effFlagsCanReplacing) != 0)
+ {
+ try
+ {
+ effect->processReplacing (effect, channels, channels, numSamples);
+ }
+ catch (...)
+ {}
+ }
+ else
+ {
+ tempBuffer.setSize (effect->numOutputs, numSamples);
+ tempBuffer.clear();
+
+ float* outs [64];
+
+ for (i = effect->numOutputs; --i >= 0;)
+ outs[i] = tempBuffer.getSampleData (i);
+
+ outs [effect->numOutputs] = 0;
+
+ try
+ {
+ effect->process (effect, channels, outs, numSamples);
+ }
+ catch (...)
+ {}
+
+ for (i = effect->numOutputs; --i >= 0;)
+ buffer.copyFrom (i, 0, outs[i], numSamples);
+ }
+ }
+ else
+ {
+ // Not initialised, so just bypass..
+ for (int i = getNumInputChannels(); i < getNumOutputChannels(); ++i)
+ buffer.clear (i, 0, buffer.getNumSamples());
+ }
+
+ {
+ // copy any incoming midi..
+ const ScopedLock sl (midiInLock);
+
+ midiMessages = incomingMidi;
+ incomingMidi.clear();
+ }
+}
+
+void VSTPluginInstance::ensureMidiEventSize (int numEventsNeeded)
+{
+ if (numEventsNeeded > numAllocatedMidiEvents)
+ {
+ numEventsNeeded = (numEventsNeeded + 32) & ~31;
+
+ const int size = 20 + sizeof (VstEvent*) * numEventsNeeded;
+
+ if (midiEventsToSend == 0)
+ midiEventsToSend = juce_calloc (size);
+ else
+ midiEventsToSend = juce_realloc (midiEventsToSend, size);
+
+ for (int i = numAllocatedMidiEvents; i < numEventsNeeded; ++i)
+ {
+ VstMidiEvent* const e = (VstMidiEvent*) juce_calloc (sizeof (VstMidiEvent));
+ e->type = kVstMidiType;
+ e->byteSize = 24;
+
+ ((VstEvents*) midiEventsToSend)->events[i] = (VstEvent*) e;
+ }
+
+ numAllocatedMidiEvents = numEventsNeeded;
+ }
+}
+
+void VSTPluginInstance::freeMidiEvents()
+{
+ if (midiEventsToSend != 0)
+ {
+ for (int i = numAllocatedMidiEvents; --i >= 0;)
+ juce_free (((VstEvents*) midiEventsToSend)->events[i]);
+
+ juce_free (midiEventsToSend);
+ midiEventsToSend = 0;
+ numAllocatedMidiEvents = 0;
+ }
+}
+
+void VSTPluginInstance::handleMidiFromPlugin (const VstEvents* const events)
+{
+ if (events != 0)
+ {
+ const ScopedLock sl (midiInLock);
+
+ for (int i = 0; i < events->numEvents; ++i)
+ {
+ const VstEvent* const e = events->events[i];
+
+ if (e->type == kVstMidiType)
+ {
+ incomingMidi.addEvent ((const uint8*) ((const VstMidiEvent*) e)->midiData,
+ 3, e->deltaFrames);
+ }
+ }
+ }
+}
+
+static Array activeWindows;
+
+class VSTPluginWindow : public AudioProcessorEditor,
+ public Timer
+{
+public:
+
+ VSTPluginWindow (VSTPluginInstance& plugin_)
+ : AudioProcessorEditor (&plugin_),
+ plugin (plugin_),
+ isOpen (false),
+ wasShowing (false),
+ pluginRefusesToResize (false),
+ pluginWantsKeys (false),
+ alreadyInside (false),
+ recursiveResize (false)
+ {
+#if JUCE_WIN32
+ sizeCheckCount = 0;
+ pluginHWND = 0;
+#elif JUCE_LINUX
+ pluginWindow = None;
+ pluginProc = None;
+#else
+ pluginViewRef = 0;
+#endif
+
+ movementWatcher = new CompMovementWatcher (this);
+
+ activeWindows.add (this);
+
+ setSize (1, 1);
+ setOpaque (true);
+ setVisible (true);
+ }
+
+ ~VSTPluginWindow()
+ {
+ deleteAndZero (movementWatcher);
+
+ closePluginWindow();
+
+ activeWindows.removeValue (this);
+ plugin.editorBeingDeleted (this);
+ }
+
+ void componentMovedOrResized()
+ {
+ if (recursiveResize)
+ return;
+
+ Component* const topComp = getTopLevelComponent();
+
+ if (topComp->getPeer() != 0)
+ {
+ int x = 0, y = 0;
+ relativePositionToOtherComponent (topComp, x, y);
+
+ recursiveResize = true;
+
+#if JUCE_MAC
+ if (pluginViewRef != 0)
+ {
+ HIRect r;
+ r.origin.x = (float) x;
+ r.origin.y = (float) y;
+ r.size.width = (float) getWidth();
+ r.size.height = (float) getHeight();
+ HIViewSetFrame (pluginViewRef, &r);
+ }
+ else if (pluginWindowRef != 0)
+ {
+ Rect r;
+ r.left = getScreenX();
+ r.top = getScreenY();
+ r.right = r.left + getWidth();
+ r.bottom = r.top + getHeight();
+
+ WindowGroupRef group = GetWindowGroup (pluginWindowRef);
+ WindowGroupAttributes atts;
+ GetWindowGroupAttributes (group, &atts);
+ ChangeWindowGroupAttributes (group, 0, kWindowGroupAttrMoveTogether);
+
+ SetWindowBounds (pluginWindowRef, kWindowContentRgn, &r);
+
+ if ((atts & kWindowGroupAttrMoveTogether) != 0)
+ ChangeWindowGroupAttributes (group, kWindowGroupAttrMoveTogether, 0);
+ }
+ else
+ {
+ repaint();
+ }
+#elif JUCE_WIN32
+ if (pluginHWND != 0)
+ MoveWindow (pluginHWND, x, y, getWidth(), getHeight(), TRUE);
+#elif JUCE_LINUX
+ if (pluginWindow != 0)
+ {
+ XResizeWindow (display, pluginWindow, getWidth(), getHeight());
+ XMoveWindow (display, pluginWindow, x, y);
+ XMapRaised (display, pluginWindow);
+ }
+#endif
+
+ recursiveResize = false;
+ }
+ }
+
+ void componentVisibilityChanged()
+ {
+ const bool isShowingNow = isShowing();
+
+ if (wasShowing != isShowingNow)
+ {
+ wasShowing = isShowingNow;
+
+ if (isShowingNow)
+ openPluginWindow();
+ else
+ closePluginWindow();
+ }
+
+ componentMovedOrResized();
+ }
+
+ void componentPeerChanged()
+ {
+ closePluginWindow();
+ openPluginWindow();
+ }
+
+ bool keyStateChanged()
+ {
+ return pluginWantsKeys;
+ }
+
+ bool keyPressed (const KeyPress&)
+ {
+ return pluginWantsKeys;
+ }
+
+ void paint (Graphics& g)
+ {
+ if (isOpen)
+ {
+ ComponentPeer* const peer = getPeer();
+
+ if (peer != 0)
+ {
+ peer->addMaskedRegion (getScreenX() - peer->getScreenX(),
+ getScreenY() - peer->getScreenY(),
+ getWidth(), getHeight());
+
+#if JUCE_MAC
+ if (pluginViewRef == 0)
+ {
+ ERect r;
+ r.left = getScreenX() - peer->getScreenX();
+ r.right = r.left + getWidth();
+ r.top = getScreenY() - peer->getScreenY();
+ r.bottom = r.top + getHeight();
+
+ dispatch (effEditDraw, 0, 0, &r, 0);
+ }
+#elif JUCE_LINUX
+ if (pluginWindow != 0)
+ {
+ const Rectangle clip (g.getClipBounds());
+
+ XEvent ev;
+ zerostruct (ev);
+ ev.xexpose.type = Expose;
+ ev.xexpose.display = display;
+ ev.xexpose.window = pluginWindow;
+ ev.xexpose.x = clip.getX();
+ ev.xexpose.y = clip.getY();
+ ev.xexpose.width = clip.getWidth();
+ ev.xexpose.height = clip.getHeight();
+
+ sendEventToChild (&ev);
+ }
+#endif
+ }
+ }
+ else
+ {
+ g.fillAll (Colours::black);
+ }
+ }
+
+ void timerCallback()
+ {
+#if JUCE_WIN32
+ if (--sizeCheckCount <= 0)
+ {
+ sizeCheckCount = 10;
+
+ checkPluginWindowSize();
+ }
+#endif
+
+ try
+ {
+ static bool reentrant = false;
+
+ if (! reentrant)
+ {
+ reentrant = true;
+ plugin.dispatch (effEditIdle, 0, 0, 0, 0);
+ reentrant = false;
+ }
+ }
+ catch (...)
+ {}
+ }
+
+ void mouseDown (const MouseEvent& e)
+ {
+#if JUCE_MAC
+ if (! alreadyInside)
+ {
+ alreadyInside = true;
+ toFront (true);
+ dispatch (effEditMouse, e.x, e.y, 0, 0);
+ alreadyInside = false;
+ }
+ else
+ {
+ PostEvent (::mouseDown, 0);
+ }
+#elif JUCE_LINUX
+
+ if (pluginWindow == 0)
+ return;
+
+ toFront (true);
+
+ XEvent ev;
+ zerostruct (ev);
+ ev.xbutton.display = display;
+ ev.xbutton.type = ButtonPress;
+ ev.xbutton.window = pluginWindow;
+ ev.xbutton.root = RootWindow (display, DefaultScreen (display));
+ ev.xbutton.time = CurrentTime;
+ ev.xbutton.x = e.x;
+ ev.xbutton.y = e.y;
+ ev.xbutton.x_root = e.getScreenX();
+ ev.xbutton.y_root = e.getScreenY();
+
+ translateJuceToXButtonModifiers (e, ev);
+
+ sendEventToChild (&ev);
+
+#else
+ (void) e;
+
+ toFront (true);
+#endif
+ }
+
+ void broughtToFront()
+ {
+ activeWindows.removeValue (this);
+ activeWindows.add (this);
+
+#if JUCE_MAC
+ dispatch (effEditTop, 0, 0, 0, 0);
+#endif
+ }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ VSTPluginInstance& plugin;
+ bool isOpen, wasShowing, recursiveResize;
+ bool pluginWantsKeys, pluginRefusesToResize, alreadyInside;
+
+#if JUCE_WIN32
+ HWND pluginHWND;
+ void* originalWndProc;
+ int sizeCheckCount;
+#elif JUCE_MAC
+ HIViewRef pluginViewRef;
+ WindowRef pluginWindowRef;
+#elif JUCE_LINUX
+ Window pluginWindow;
+ EventProcPtr pluginProc;
+#endif
+
+ void openPluginWindow()
+ {
+ if (isOpen || getWindowHandle() == 0)
+ return;
+
+ log (T("Opening VST UI: ") + plugin.name);
+ isOpen = true;
+
+ ERect* rect = 0;
+ dispatch (effEditGetRect, 0, 0, &rect, 0);
+ dispatch (effEditOpen, 0, 0, getWindowHandle(), 0);
+
+ // do this before and after like in the steinberg example
+ dispatch (effEditGetRect, 0, 0, &rect, 0);
+ dispatch (effGetProgram, 0, 0, 0, 0); // also in steinberg code
+
+ // Install keyboard hooks
+ pluginWantsKeys = (dispatch (effKeysRequired, 0, 0, 0, 0) == 0);
+
+#if JUCE_WIN32
+ originalWndProc = 0;
+ pluginHWND = GetWindow ((HWND) getWindowHandle(), GW_CHILD);
+
+ if (pluginHWND == 0)
+ {
+ isOpen = false;
+ setSize (300, 150);
+ return;
+ }
+
+ #pragma warning (push)
+ #pragma warning (disable: 4244)
+
+ originalWndProc = (void*) GetWindowLongPtr (pluginHWND, GWL_WNDPROC);
+
+ if (! pluginWantsKeys)
+ SetWindowLongPtr (pluginHWND, GWL_WNDPROC, (LONG_PTR) vstHookWndProc);
+
+ #pragma warning (pop)
+
+ int w, h;
+ RECT r;
+ GetWindowRect (pluginHWND, &r);
+ w = r.right - r.left;
+ h = r.bottom - r.top;
+
+ if (rect != 0)
+ {
+ const int rw = rect->right - rect->left;
+ const int rh = rect->bottom - rect->top;
+
+ if ((rw > 50 && rh > 50 && rw < 2000 && rh < 2000 && rw != w && rh != h)
+ || ((w == 0 && rw > 0) || (h == 0 && rh > 0)))
+ {
+ // very dodgy logic to decide which size is right.
+ if (abs (rw - w) > 350 || abs (rh - h) > 350)
+ {
+ SetWindowPos (pluginHWND, 0,
+ 0, 0, rw, rh,
+ SWP_NOMOVE | SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOZORDER);
+
+ GetWindowRect (pluginHWND, &r);
+
+ w = r.right - r.left;
+ h = r.bottom - r.top;
+
+ pluginRefusesToResize = (w != rw) || (h != rh);
+
+ w = rw;
+ h = rh;
+ }
+ }
+ }
+#elif JUCE_MAC
+ HIViewRef root = HIViewGetRoot ((WindowRef) getWindowHandle());
+ HIViewFindByID (root, kHIViewWindowContentID, &root);
+ pluginViewRef = HIViewGetFirstSubview (root);
+
+ while (pluginViewRef != 0 && juce_isHIViewCreatedByJuce (pluginViewRef))
+ pluginViewRef = HIViewGetNextView (pluginViewRef);
+
+ pluginWindowRef = 0;
+
+ if (pluginViewRef == 0)
+ {
+ WindowGroupRef ourGroup = GetWindowGroup ((WindowRef) getWindowHandle());
+ //DebugPrintWindowGroup (ourGroup);
+ //DebugPrintAllWindowGroups();
+
+ GetIndexedWindow (ourGroup, 1,
+ kWindowGroupContentsVisible,
+ &pluginWindowRef);
+
+ if (pluginWindowRef == (WindowRef) getWindowHandle()
+ || juce_isWindowCreatedByJuce (pluginWindowRef))
+ pluginWindowRef = 0;
+ }
+
+ int w = 250, h = 150;
+
+ if (rect != 0)
+ {
+ w = rect->right - rect->left;
+ h = rect->bottom - rect->top;
+
+ if (w == 0 || h == 0)
+ {
+ w = 250;
+ h = 150;
+ }
+ }
+
+#elif JUCE_LINUX
+ pluginWindow = getChildWindow ((Window) getWindowHandle());
+
+ if (pluginWindow != 0)
+ pluginProc = (EventProcPtr) getPropertyFromXWindow (pluginWindow,
+ XInternAtom (display, "_XEventProc", False));
+
+ int w = 250, h = 150;
+
+ if (rect != 0)
+ {
+ w = rect->right - rect->left;
+ h = rect->bottom - rect->top;
+
+ if (w == 0 || h == 0)
+ {
+ w = 250;
+ h = 150;
+ }
+ }
+
+ if (pluginWindow != 0)
+ XMapRaised (display, pluginWindow);
+#endif
+
+ // double-check it's not too tiny
+ w = jmax (w, 32);
+ h = jmax (h, 32);
+
+ setSize (w, h);
+
+#if JUCE_WIN32
+ checkPluginWindowSize();
+#endif
+
+ startTimer (18 + JUCE_NAMESPACE::Random::getSystemRandom().nextInt (5));
+ repaint();
+ }
+
+ void closePluginWindow()
+ {
+ if (isOpen)
+ {
+ log (T("Closing VST UI: ") + plugin.getName());
+ isOpen = false;
+
+ dispatch (effEditClose, 0, 0, 0, 0);
+
+#if JUCE_WIN32
+ #pragma warning (push)
+ #pragma warning (disable: 4244)
+
+ if (pluginHWND != 0 && IsWindow (pluginHWND))
+ SetWindowLongPtr (pluginHWND, GWL_WNDPROC, (LONG_PTR) originalWndProc);
+
+ #pragma warning (pop)
+
+ stopTimer();
+
+ if (pluginHWND != 0 && IsWindow (pluginHWND))
+ DestroyWindow (pluginHWND);
+
+ pluginHWND = 0;
+#elif JUCE_MAC
+ dispatch (effEditSleep, 0, 0, 0, 0);
+ pluginViewRef = 0;
+ stopTimer();
+#elif JUCE_LINUX
+ stopTimer();
+ pluginWindow = 0;
+ pluginProc = 0;
+#endif
+ }
+ }
+
+#if JUCE_WIN32
+ void checkPluginWindowSize() throw()
+ {
+ RECT r;
+ GetWindowRect (pluginHWND, &r);
+ const int w = r.right - r.left;
+ const int h = r.bottom - r.top;
+
+ if (isShowing() && w > 0 && h > 0
+ && (w != getWidth() || h != getHeight())
+ && ! pluginRefusesToResize)
+ {
+ setSize (w, h);
+ sizeCheckCount = 0;
+ }
+ }
+#endif
+
+ class CompMovementWatcher : public ComponentMovementWatcher
+ {
+ public:
+ CompMovementWatcher (VSTPluginWindow* const owner_)
+ : ComponentMovementWatcher (owner_),
+ owner (owner_)
+ {
+ }
+
+ void componentMovedOrResized (bool /*wasMoved*/, bool /*wasResized*/)
+ {
+ owner->componentMovedOrResized();
+ }
+
+ void componentPeerChanged()
+ {
+ owner->componentPeerChanged();
+ }
+
+ void componentVisibilityChanged (Component&)
+ {
+ owner->componentVisibilityChanged();
+ }
+
+ private:
+ VSTPluginWindow* const owner;
+ };
+
+ CompMovementWatcher* movementWatcher;
+
+ int dispatch (const int opcode, const int index, const int value, void* const ptr, float opt)
+ {
+ return plugin.dispatch (opcode, index, value, ptr, opt);
+ }
+
+ // hooks to get keyboard events from VST windows..
+#if JUCE_WIN32
+ static LRESULT CALLBACK vstHookWndProc (HWND hW, UINT message, WPARAM wParam, LPARAM lParam)
+ {
+ for (int i = activeWindows.size(); --i >= 0;)
+ {
+ const VSTPluginWindow* const w = (const VSTPluginWindow*) activeWindows.getUnchecked (i);
+
+ if (w->pluginHWND == hW)
+ {
+ if (message == WM_CHAR
+ || message == WM_KEYDOWN
+ || message == WM_SYSKEYDOWN
+ || message == WM_KEYUP
+ || message == WM_SYSKEYUP
+ || message == WM_APPCOMMAND)
+ {
+ SendMessage ((HWND) w->getTopLevelComponent()->getWindowHandle(),
+ message, wParam, lParam);
+ }
+
+ return CallWindowProc ((WNDPROC) (w->originalWndProc),
+ (HWND) w->pluginHWND,
+ message,
+ wParam,
+ lParam);
+ }
+ }
+
+ return DefWindowProc (hW, message, wParam, lParam);
+ }
+#endif
+
+#if JUCE_LINUX
+
+ // overload mouse/keyboard events to forward them to the plugin's inner window..
+ void sendEventToChild (XEvent* event)
+ {
+ if (pluginProc != 0)
+ {
+ // if the plugin publishes an event procedure, pass the event directly..
+ pluginProc (event);
+ }
+ else if (pluginWindow != 0)
+ {
+ // if the plugin has a window, then send the event to the window so that
+ // its message thread will pick it up..
+ XSendEvent (display, pluginWindow, False, 0L, event);
+ XFlush (display);
+ }
+ }
+
+ void mouseEnter (const MouseEvent& e)
+ {
+ if (pluginWindow != 0)
+ {
+ XEvent ev;
+ zerostruct (ev);
+ ev.xcrossing.display = display;
+ ev.xcrossing.type = EnterNotify;
+ ev.xcrossing.window = pluginWindow;
+ ev.xcrossing.root = RootWindow (display, DefaultScreen (display));
+ ev.xcrossing.time = CurrentTime;
+ ev.xcrossing.x = e.x;
+ ev.xcrossing.y = e.y;
+ ev.xcrossing.x_root = e.getScreenX();
+ ev.xcrossing.y_root = e.getScreenY();
+ ev.xcrossing.mode = NotifyNormal; // NotifyGrab, NotifyUngrab
+ ev.xcrossing.detail = NotifyAncestor; // NotifyVirtual, NotifyInferior, NotifyNonlinear,NotifyNonlinearVirtual
+
+ translateJuceToXCrossingModifiers (e, ev);
+
+ sendEventToChild (&ev);
+ }
+ }
+
+ void mouseExit (const MouseEvent& e)
+ {
+ if (pluginWindow != 0)
+ {
+ XEvent ev;
+ zerostruct (ev);
+ ev.xcrossing.display = display;
+ ev.xcrossing.type = LeaveNotify;
+ ev.xcrossing.window = pluginWindow;
+ ev.xcrossing.root = RootWindow (display, DefaultScreen (display));
+ ev.xcrossing.time = CurrentTime;
+ ev.xcrossing.x = e.x;
+ ev.xcrossing.y = e.y;
+ ev.xcrossing.x_root = e.getScreenX();
+ ev.xcrossing.y_root = e.getScreenY();
+ ev.xcrossing.mode = NotifyNormal; // NotifyGrab, NotifyUngrab
+ ev.xcrossing.detail = NotifyAncestor; // NotifyVirtual, NotifyInferior, NotifyNonlinear,NotifyNonlinearVirtual
+ ev.xcrossing.focus = hasKeyboardFocus (true); // TODO - yes ?
+
+ translateJuceToXCrossingModifiers (e, ev);
+
+ sendEventToChild (&ev);
+ }
+ }
+
+ void mouseMove (const MouseEvent& e)
+ {
+ if (pluginWindow != 0)
+ {
+ XEvent ev;
+ zerostruct (ev);
+ ev.xmotion.display = display;
+ ev.xmotion.type = MotionNotify;
+ ev.xmotion.window = pluginWindow;
+ ev.xmotion.root = RootWindow (display, DefaultScreen (display));
+ ev.xmotion.time = CurrentTime;
+ ev.xmotion.is_hint = NotifyNormal;
+ ev.xmotion.x = e.x;
+ ev.xmotion.y = e.y;
+ ev.xmotion.x_root = e.getScreenX();
+ ev.xmotion.y_root = e.getScreenY();
+
+ sendEventToChild (&ev);
+ }
+ }
+
+ void mouseDrag (const MouseEvent& e)
+ {
+ if (pluginWindow != 0)
+ {
+ XEvent ev;
+ zerostruct (ev);
+ ev.xmotion.display = display;
+ ev.xmotion.type = MotionNotify;
+ ev.xmotion.window = pluginWindow;
+ ev.xmotion.root = RootWindow (display, DefaultScreen (display));
+ ev.xmotion.time = CurrentTime;
+ ev.xmotion.x = e.x ;
+ ev.xmotion.y = e.y;
+ ev.xmotion.x_root = e.getScreenX();
+ ev.xmotion.y_root = e.getScreenY();
+ ev.xmotion.is_hint = NotifyNormal;
+
+ translateJuceToXMotionModifiers (e, ev);
+ sendEventToChild (&ev);
+ }
+ }
+
+ void mouseUp (const MouseEvent& e)
+ {
+ if (pluginWindow != 0)
+ {
+ XEvent ev;
+ zerostruct (ev);
+ ev.xbutton.display = display;
+ ev.xbutton.type = ButtonRelease;
+ ev.xbutton.window = pluginWindow;
+ ev.xbutton.root = RootWindow (display, DefaultScreen (display));
+ ev.xbutton.time = CurrentTime;
+ ev.xbutton.x = e.x;
+ ev.xbutton.y = e.y;
+ ev.xbutton.x_root = e.getScreenX();
+ ev.xbutton.y_root = e.getScreenY();
+
+ translateJuceToXButtonModifiers (e, ev);
+ sendEventToChild (&ev);
+ }
+ }
+
+ void mouseWheelMove (const MouseEvent& e,
+ float incrementX,
+ float incrementY)
+ {
+ if (pluginWindow != 0)
+ {
+ XEvent ev;
+ zerostruct (ev);
+ ev.xbutton.display = display;
+ ev.xbutton.type = ButtonPress;
+ ev.xbutton.window = pluginWindow;
+ ev.xbutton.root = RootWindow (display, DefaultScreen (display));
+ ev.xbutton.time = CurrentTime;
+ ev.xbutton.x = e.x;
+ ev.xbutton.y = e.y;
+ ev.xbutton.x_root = e.getScreenX();
+ ev.xbutton.y_root = e.getScreenY();
+
+ translateJuceToXMouseWheelModifiers (e, incrementY, ev);
+ sendEventToChild (&ev);
+
+ // TODO - put a usleep here ?
+
+ ev.xbutton.type = ButtonRelease;
+ sendEventToChild (&ev);
+ }
+ }
+#endif
+
+};
+
+AudioProcessorEditor* VSTPluginInstance::createEditor()
+{
+ if (hasEditor())
+ return new VSTPluginWindow (*this);
+
+ return 0;
+}
+
+void VSTPluginInstance::handleAsyncUpdate()
+{
+ // indicates that something about the plugin has changed..
+ updateHostDisplay();
+}
+
+bool VSTPluginInstance::restoreProgramSettings (const fxProgram* const prog)
+{
+ if (swap (prog->chunkMagic) == 'CcnK' && swap (prog->fxMagic) == 'FxCk')
+ {
+ changeProgramName (getCurrentProgram(), prog->prgName);
+
+ for (int i = 0; i < swap (prog->numParams); ++i)
+ setParameter (i, swapFloat (prog->params[i]));
+
+ return true;
+ }
+
+ return false;
+}
+
+bool VSTPluginInstance::loadFromFXBFile (const void* const data,
+ const int dataSize)
+{
+ if (dataSize < 28)
+ return false;
+
+ const fxSet* const set = (const fxSet*) data;
+
+ if ((swap (set->chunkMagic) != 'CcnK' && swap (set->chunkMagic) != 'KncC')
+ || swap (set->version) > fxbVersionNum)
+ return false;
+
+ if (swap (set->fxMagic) == 'FxBk')
+ {
+ // bank of programs
+ if (swap (set->numPrograms) >= 0)
+ {
+ const int oldProg = getCurrentProgram();
+ const int numParams = swap (((const fxProgram*) (set->programs))->numParams);
+ const int progLen = sizeof (fxProgram) + (numParams - 1) * sizeof (float);
+
+ for (int i = 0; i < swap (set->numPrograms); ++i)
+ {
+ if (i != oldProg)
+ {
+ const fxProgram* const prog = (const fxProgram*) (((const char*) (set->programs)) + i * progLen);
+ if (((const char*) prog) - ((const char*) set) >= dataSize)
+ return false;
+
+ if (swap (set->numPrograms) > 0)
+ setCurrentProgram (i);
+
+ if (! restoreProgramSettings (prog))
+ return false;
+ }
+ }
+
+ if (swap (set->numPrograms) > 0)
+ setCurrentProgram (oldProg);
+
+ const fxProgram* const prog = (const fxProgram*) (((const char*) (set->programs)) + oldProg * progLen);
+ if (((const char*) prog) - ((const char*) set) >= dataSize)
+ return false;
+
+ if (! restoreProgramSettings (prog))
+ return false;
+ }
+ }
+ else if (swap (set->fxMagic) == 'FxCk')
+ {
+ // single program
+ const fxProgram* const prog = (const fxProgram*) data;
+
+ if (swap (prog->chunkMagic) != 'CcnK')
+ return false;
+
+ changeProgramName (getCurrentProgram(), prog->prgName);
+
+ for (int i = 0; i < swap (prog->numParams); ++i)
+ setParameter (i, swapFloat (prog->params[i]));
+ }
+ else if (swap (set->fxMagic) == 'FBCh' || swap (set->fxMagic) == 'hCBF')
+ {
+ // non-preset chunk
+ const fxChunkSet* const cset = (const fxChunkSet*) data;
+
+ if (swap (cset->chunkSize) + sizeof (fxChunkSet) - 8 > (unsigned int) dataSize)
+ return false;
+
+ setChunkData (cset->chunk, swap (cset->chunkSize), false);
+ }
+ else if (swap (set->fxMagic) == 'FPCh' || swap (set->fxMagic) == 'hCPF')
+ {
+ // preset chunk
+ const fxProgramSet* const cset = (const fxProgramSet*) data;
+
+ if (swap (cset->chunkSize) + sizeof (fxProgramSet) - 8 > (unsigned int) dataSize)
+ return false;
+
+ setChunkData (cset->chunk, swap (cset->chunkSize), true);
+
+ changeProgramName (getCurrentProgram(), cset->name);
+ }
+ else
+ {
+ return false;
+ }
+
+ return true;
+}
+
+void VSTPluginInstance::setParamsInProgramBlock (fxProgram* const prog) throw()
+{
+ const int numParams = getNumParameters();
+
+ prog->chunkMagic = swap ('CcnK');
+ prog->byteSize = 0;
+ prog->fxMagic = swap ('FxCk');
+ prog->version = swap (fxbVersionNum);
+ prog->fxID = swap (getUID());
+ prog->fxVersion = swap (getVersionNumber());
+ prog->numParams = swap (numParams);
+
+ getCurrentProgramName().copyToBuffer (prog->prgName, sizeof (prog->prgName) - 1);
+
+ for (int i = 0; i < numParams; ++i)
+ prog->params[i] = swapFloat (getParameter (i));
+}
+
+bool VSTPluginInstance::saveToFXBFile (MemoryBlock& dest, bool isFXB, int maxSizeMB)
+{
+ const int numPrograms = getNumPrograms();
+ const int numParams = getNumParameters();
+
+ if (usesChunks())
+ {
+ if (isFXB)
+ {
+ MemoryBlock chunk;
+ getChunkData (chunk, false, maxSizeMB);
+
+ const int totalLen = sizeof (fxChunkSet) + chunk.getSize() - 8;
+ dest.setSize (totalLen, true);
+
+ fxChunkSet* const set = (fxChunkSet*) dest.getData();
+ set->chunkMagic = swap ('CcnK');
+ set->byteSize = 0;
+ set->fxMagic = swap ('FBCh');
+ set->version = swap (fxbVersionNum);
+ set->fxID = swap (getUID());
+ set->fxVersion = swap (getVersionNumber());
+ set->numPrograms = swap (numPrograms);
+ set->chunkSize = swap (chunk.getSize());
+
+ chunk.copyTo (set->chunk, 0, chunk.getSize());
+ }
+ else
+ {
+ MemoryBlock chunk;
+ getChunkData (chunk, true, maxSizeMB);
+
+ const int totalLen = sizeof (fxProgramSet) + chunk.getSize() - 8;
+ dest.setSize (totalLen, true);
+
+ fxProgramSet* const set = (fxProgramSet*) dest.getData();
+ set->chunkMagic = swap ('CcnK');
+ set->byteSize = 0;
+ set->fxMagic = swap ('FPCh');
+ set->version = swap (fxbVersionNum);
+ set->fxID = swap (getUID());
+ set->fxVersion = swap (getVersionNumber());
+ set->numPrograms = swap (numPrograms);
+ set->chunkSize = swap (chunk.getSize());
+
+ getCurrentProgramName().copyToBuffer (set->name, sizeof (set->name) - 1);
+ chunk.copyTo (set->chunk, 0, chunk.getSize());
+ }
+ }
+ else
+ {
+ if (isFXB)
+ {
+ const int progLen = sizeof (fxProgram) + (numParams - 1) * sizeof (float);
+ const int len = (sizeof (fxSet) - sizeof (fxProgram)) + progLen * jmax (1, numPrograms);
+ dest.setSize (len, true);
+
+ fxSet* const set = (fxSet*) dest.getData();
+ set->chunkMagic = swap ('CcnK');
+ set->byteSize = 0;
+ set->fxMagic = swap ('FxBk');
+ set->version = swap (fxbVersionNum);
+ set->fxID = swap (getUID());
+ set->fxVersion = swap (getVersionNumber());
+ set->numPrograms = swap (numPrograms);
+
+ const int oldProgram = getCurrentProgram();
+ MemoryBlock oldSettings;
+ createTempParameterStore (oldSettings);
+
+ setParamsInProgramBlock ((fxProgram*) (((char*) (set->programs)) + oldProgram * progLen));
+
+ for (int i = 0; i < numPrograms; ++i)
+ {
+ if (i != oldProgram)
+ {
+ setCurrentProgram (i);
+ setParamsInProgramBlock ((fxProgram*) (((char*) (set->programs)) + i * progLen));
+ }
+ }
+
+ setCurrentProgram (oldProgram);
+ restoreFromTempParameterStore (oldSettings);
+ }
+ else
+ {
+ const int totalLen = sizeof (fxProgram) + (numParams - 1) * sizeof (float);
+ dest.setSize (totalLen, true);
+
+ setParamsInProgramBlock ((fxProgram*) dest.getData());
+ }
+ }
+
+ return true;
+}
+
+void VSTPluginInstance::getChunkData (MemoryBlock& mb, bool isPreset, int maxSizeMB) const
+{
+ if (usesChunks())
+ {
+ void* data = 0;
+ const int bytes = dispatch (effGetChunk, isPreset ? 1 : 0, 0, &data, 0.0f);
+
+ if (data != 0 && bytes <= maxSizeMB * 1024 * 1024)
+ {
+ mb.setSize (bytes);
+ mb.copyFrom (data, 0, bytes);
+ }
+ }
+}
+
+void VSTPluginInstance::setChunkData (const char* data, int size, bool isPreset)
+{
+ if (size > 0 && usesChunks())
+ {
+ dispatch (effSetChunk, isPreset ? 1 : 0, size, (void*) data, 0.0f);
+
+ if (! isPreset)
+ updateStoredProgramNames();
+ }
+}
+
+void VSTPluginInstance::timerCallback()
+{
+ if (dispatch (effIdle, 0, 0, 0, 0) == 0)
+ stopTimer();
+}
+
+int VSTPluginInstance::dispatch (const int opcode, const int index, const int value, void* const ptr, float opt) const
+{
+ const ScopedLock sl (lock);
+
+ ++insideVSTCallback;
+ int result = 0;
+
+ try
+ {
+ if (effect != 0)
+ {
+#if JUCE_MAC
+ if (module->resFileId != 0)
+ UseResFile (module->resFileId);
+
+ CGrafPtr oldPort;
+
+ if (getActiveEditor() != 0)
+ {
+ int x = 0, y = 0;
+ getActiveEditor()->relativePositionToOtherComponent (getActiveEditor()->getTopLevelComponent(), x, y);
+
+ GetPort (&oldPort);
+ SetPortWindowPort ((WindowRef) getActiveEditor()->getWindowHandle());
+ SetOrigin (-x, -y);
+ }
+#endif
+
+ result = effect->dispatcher (effect, opcode, index, value, ptr, opt);
+
+#if JUCE_MAC
+ if (getActiveEditor() != 0)
+ SetPort (oldPort);
+
+ module->resFileId = CurResFile();
+#endif
+
+ --insideVSTCallback;
+ return result;
+ }
+ }
+ catch (...)
+ {
+ //char s[512];
+ //sprintf (s, "dispatcher (%d, %d, %d, %x, %f)", opcode, index, value, (int)ptr, opt);
+ }
+
+ --insideVSTCallback;
+ return result;
+}
+
+// handles non plugin-specific callbacks..
+static VstIntPtr handleGeneralCallback (VstInt32 opcode, VstInt32 index, VstInt32 value, void *ptr, float opt)
+{
+ (void) index;
+ (void) value;
+ (void) opt;
+
+ switch (opcode)
+ {
+ case audioMasterCanDo:
+ {
+ static const char* canDos[] = { "supplyIdle",
+ "sendVstEvents",
+ "sendVstMidiEvent",
+ "sendVstTimeInfo",
+ "receiveVstEvents",
+ "receiveVstMidiEvent",
+ "supportShell",
+ "shellCategory" };
+
+ for (int i = 0; i < numElementsInArray (canDos); ++i)
+ if (strcmp (canDos[i], (const char*) ptr) == 0)
+ return 1;
+
+ return 0;
+ }
+
+ case audioMasterVersion:
+ return 0x2400;
+ case audioMasterCurrentId:
+ return shellUIDToCreate;
+ case audioMasterGetNumAutomatableParameters:
+ return 0;
+ case audioMasterGetAutomationState:
+ return 1;
+
+ case audioMasterGetVendorVersion:
+ return 0x0101;
+ case audioMasterGetVendorString:
+ case audioMasterGetProductString:
+ JUCEApplication::getInstance()
+ ->getApplicationName().copyToBuffer ((char*) ptr, jmin (kVstMaxVendorStrLen, kVstMaxProductStrLen) - 1);
+ break;
+
+ case audioMasterGetSampleRate:
+ return 44100;
+
+ case audioMasterGetBlockSize:
+ return 512;
+
+ case audioMasterSetOutputSampleRate:
+ return 0;
+
+ default:
+ DBG ("*** Unhandled VST Callback: " + String ((int) opcode));
+ break;
+ }
+
+ return 0;
+}
+
+// handles callbacks for a specific plugin
+VstIntPtr VSTPluginInstance::handleCallback (VstInt32 opcode, VstInt32 index, VstInt32 value, void *ptr, float opt)
+{
+ switch (opcode)
+ {
+ case audioMasterAutomate:
+ sendParamChangeMessageToListeners (index, opt);
+ break;
+
+ case audioMasterProcessEvents:
+ handleMidiFromPlugin ((const VstEvents*) ptr);
+ break;
+
+ case audioMasterGetTime:
+ #ifdef _MSC_VER
+ #pragma warning (push)
+ #pragma warning (disable: 4311)
+ #endif
+
+ return (VstIntPtr) &vstHostTime;
+
+ #ifdef _MSC_VER
+ #pragma warning (pop)
+ #endif
+ break;
+
+ case audioMasterIdle:
+ if (insideVSTCallback == 0 && MessageManager::getInstance()->isThisTheMessageThread())
+ {
+ ++insideVSTCallback;
+#if JUCE_MAC
+ if (getActiveEditor() != 0)
+ dispatch (effEditIdle, 0, 0, 0, 0);
+#endif
+ const MessageManagerLock mml;
+
+ juce_callAnyTimersSynchronously();
+
+ handleUpdateNowIfNeeded();
+
+ for (int i = ComponentPeer::getNumPeers(); --i >= 0;)
+ ComponentPeer::getPeer (i)->performAnyPendingRepaintsNow();
+
+ --insideVSTCallback;
+ }
+ break;
+
+ case audioMasterUpdateDisplay:
+ triggerAsyncUpdate();
+ break;
+
+ case audioMasterTempoAt:
+ // returns (10000 * bpm)
+ break;
+
+ case audioMasterNeedIdle:
+ startTimer (50);
+ break;
+
+ case audioMasterSizeWindow:
+ if (getActiveEditor() != 0)
+ getActiveEditor()->setSize (index, value);
+
+ return 1;
+
+ case audioMasterGetSampleRate:
+ return (VstIntPtr) getSampleRate();
+
+ case audioMasterGetBlockSize:
+ return (VstIntPtr) getBlockSize();
+
+ case audioMasterWantMidi:
+ wantsMidiMessages = true;
+ break;
+
+ case audioMasterGetDirectory:
+ #if JUCE_MAC
+ return (VstIntPtr) (void*) &module->parentDirFSSpec;
+ #else
+ return (VstIntPtr) (pointer_sized_uint) (const char*) module->fullParentDirectoryPathName;
+ #endif
+
+ case audioMasterGetAutomationState:
+ // returns 0: not supported, 1: off, 2:read, 3:write, 4:read/write
+ break;
+
+ // none of these are handled (yet)..
+ case audioMasterBeginEdit:
+ case audioMasterEndEdit:
+ case audioMasterSetTime:
+ case audioMasterPinConnected:
+ case audioMasterGetParameterQuantization:
+ case audioMasterIOChanged:
+ case audioMasterGetInputLatency:
+ case audioMasterGetOutputLatency:
+ case audioMasterGetPreviousPlug:
+ case audioMasterGetNextPlug:
+ case audioMasterWillReplaceOrAccumulate:
+ case audioMasterGetCurrentProcessLevel:
+ case audioMasterOfflineStart:
+ case audioMasterOfflineRead:
+ case audioMasterOfflineWrite:
+ case audioMasterOfflineGetCurrentPass:
+ case audioMasterOfflineGetCurrentMetaPass:
+ case audioMasterVendorSpecific:
+ case audioMasterSetIcon:
+ case audioMasterGetLanguage:
+ case audioMasterOpenWindow:
+ case audioMasterCloseWindow:
+ break;
+
+ default:
+ return handleGeneralCallback (opcode, index, value, ptr, opt);
+ }
+
+ return 0;
+}
+
+// entry point for all callbacks from the plugin
+static VstIntPtr VSTCALLBACK audioMaster (AEffect* effect, VstInt32 opcode, VstInt32 index, VstIntPtr value, void* ptr, float opt)
+{
+ try
+ {
+ if (effect != 0 && effect->resvd2 != 0)
+ {
+ return ((VSTPluginInstance*)(effect->resvd2))
+ ->handleCallback (opcode, index, value, ptr, opt);
+ }
+
+ return handleGeneralCallback (opcode, index, value, ptr, opt);
+ }
+ catch (...)
+ {
+ return 0;
+ }
+}
+
+const String VSTPluginInstance::getVersion() const throw()
+{
+ int v = dispatch (effGetVendorVersion, 0, 0, 0, 0);
+
+ String s;
+
+ if (v != 0)
+ {
+ int versionBits[4];
+ int n = 0;
+
+ while (v != 0)
+ {
+ versionBits [n++] = (v & 0xff);
+ v >>= 8;
+ }
+
+ s << 'V';
+
+ while (n > 0)
+ {
+ s << versionBits [--n];
+
+ if (n > 0)
+ s << '.';
+ }
+ }
+
+ return s;
+}
+
+int VSTPluginInstance::getUID() const throw()
+{
+ int uid = effect != 0 ? effect->uniqueID : 0;
+
+ if (uid == 0)
+ uid = module->file.hashCode();
+
+ return uid;
+}
+
+const String VSTPluginInstance::getCategory() const throw()
+{
+ const char* result = 0;
+
+ switch (dispatch (effGetPlugCategory, 0, 0, 0, 0))
+ {
+ case kPlugCategEffect:
+ result = "Effect";
+ break;
+
+ case kPlugCategSynth:
+ result = "Synth";
+ break;
+
+ case kPlugCategAnalysis:
+ result = "Anaylsis";
+ break;
+
+ case kPlugCategMastering:
+ result = "Mastering";
+ break;
+
+ case kPlugCategSpacializer:
+ result = "Spacial";
+ break;
+
+ case kPlugCategRoomFx:
+ result = "Reverb";
+ break;
+
+ case kPlugSurroundFx:
+ result = "Surround";
+ break;
+
+ case kPlugCategRestoration:
+ result = "Restoration";
+ break;
+
+ case kPlugCategGenerator:
+ result = "Tone generation";
+ break;
+
+ default:
+ break;
+ }
+
+ return result;
+}
+
+float VSTPluginInstance::getParameter (int index)
+{
+ if (effect != 0 && ((unsigned int) index) < (unsigned int) effect->numParams)
+ {
+ try
+ {
+ const ScopedLock sl (lock);
+ return effect->getParameter (effect, index);
+ }
+ catch (...)
+ {
+ }
+ }
+
+ return 0.0f;
+}
+
+void VSTPluginInstance::setParameter (int index, float newValue)
+{
+ if (effect != 0 && ((unsigned int) index) < (unsigned int) effect->numParams)
+ {
+ try
+ {
+ const ScopedLock sl (lock);
+
+ if (effect->getParameter (effect, index) != newValue)
+ effect->setParameter (effect, index, newValue);
+ }
+ catch (...)
+ {
+ }
+ }
+}
+
+const String VSTPluginInstance::getParameterName (int index)
+{
+ if (effect != 0)
+ {
+ jassert (index >= 0 && index < effect->numParams);
+
+ char nm [256];
+ zerostruct (nm);
+ dispatch (effGetParamName, index, 0, nm, 0);
+ return String (nm).trim();
+ }
+
+ return String::empty;
+}
+
+const String VSTPluginInstance::getParameterLabel (int index) const
+{
+ if (effect != 0)
+ {
+ jassert (index >= 0 && index < effect->numParams);
+
+ char nm [256];
+ zerostruct (nm);
+ dispatch (effGetParamLabel, index, 0, nm, 0);
+ return String (nm).trim();
+ }
+
+ return String::empty;
+}
+
+const String VSTPluginInstance::getParameterText (int index)
+{
+ if (effect != 0)
+ {
+ jassert (index >= 0 && index < effect->numParams);
+
+ char nm [256];
+ zerostruct (nm);
+ dispatch (effGetParamDisplay, index, 0, nm, 0);
+ return String (nm).trim();
+ }
+
+ return String::empty;
+}
+
+bool VSTPluginInstance::isParameterAutomatable (int index) const
+{
+ if (effect != 0)
+ {
+ jassert (index >= 0 && index < effect->numParams);
+ return dispatch (effCanBeAutomated, index, 0, 0, 0) != 0;
+ }
+
+ return false;
+}
+
+void VSTPluginInstance::createTempParameterStore (MemoryBlock& dest)
+{
+ dest.setSize (64 + 4 * getNumParameters());
+ dest.fillWith (0);
+
+ getCurrentProgramName().copyToBuffer ((char*) dest.getData(), 63);
+
+ float* const p = (float*) (((char*) dest.getData()) + 64);
+ for (int i = 0; i < getNumParameters(); ++i)
+ p[i] = getParameter(i);
+}
+
+void VSTPluginInstance::restoreFromTempParameterStore (const MemoryBlock& m)
+{
+ changeProgramName (getCurrentProgram(), (const char*) m.getData());
+
+ float* p = (float*) (((char*) m.getData()) + 64);
+ for (int i = 0; i < getNumParameters(); ++i)
+ setParameter (i, p[i]);
+}
+
+void VSTPluginInstance::setCurrentProgram (int newIndex)
+{
+ if (getNumPrograms() > 0 && newIndex != getCurrentProgram())
+ dispatch (effSetProgram, 0, jlimit (0, getNumPrograms() - 1, newIndex), 0, 0);
+}
+
+const String VSTPluginInstance::getProgramName (int index)
+{
+ if (index == getCurrentProgram())
+ {
+ return getCurrentProgramName();
+ }
+ else if (effect != 0)
+ {
+ char nm [256];
+ zerostruct (nm);
+
+ if (dispatch (effGetProgramNameIndexed,
+ jlimit (0, getNumPrograms(), index),
+ -1, nm, 0) != 0)
+ {
+ return String (nm).trim();
+ }
+ }
+
+ return programNames [index];
+}
+
+void VSTPluginInstance::changeProgramName (int index, const String& newName)
+{
+ if (index == getCurrentProgram())
+ {
+ if (getNumPrograms() > 0 && newName != getCurrentProgramName())
+ dispatch (effSetProgramName, 0, 0, (void*) (const char*) newName.substring (0, 24), 0.0f);
+ }
+ else
+ {
+ jassertfalse // xxx not implemented!
+ }
+}
+
+void VSTPluginInstance::updateStoredProgramNames()
+{
+ if (effect != 0 && getNumPrograms() > 0)
+ {
+ char nm [256];
+ zerostruct (nm);
+
+ // only do this if the plugin can't use indexed names..
+ if (dispatch (effGetProgramNameIndexed, 0, -1, nm, 0) == 0)
+ {
+ const int oldProgram = getCurrentProgram();
+ MemoryBlock oldSettings;
+ createTempParameterStore (oldSettings);
+
+ for (int i = 0; i < getNumPrograms(); ++i)
+ {
+ setCurrentProgram (i);
+ getCurrentProgramName(); // (this updates the list)
+ }
+
+ setCurrentProgram (oldProgram);
+ restoreFromTempParameterStore (oldSettings);
+ }
+ }
+}
+
+const String VSTPluginInstance::getCurrentProgramName()
+{
+ if (effect != 0)
+ {
+ char nm [256];
+ zerostruct (nm);
+ dispatch (effGetProgramName, 0, 0, nm, 0);
+
+ const int index = getCurrentProgram();
+ if (programNames[index].isEmpty())
+ {
+ while (programNames.size() < index)
+ programNames.add (String::empty);
+
+ programNames.set (index, String (nm).trim());
+ }
+
+ return String (nm).trim();
+ }
+
+ return String::empty;
+}
+
+const String VSTPluginInstance::getInputChannelName (const int index) const
+{
+ if (index >= 0 && index < getNumInputChannels())
+ {
+ VstPinProperties pinProps;
+ if (dispatch (effGetInputProperties, index, 0, &pinProps, 0.0f) != 0)
+ return String (pinProps.label, sizeof (pinProps.label));
+ }
+
+ return String::empty;
+}
+
+bool VSTPluginInstance::isInputChannelStereoPair (int index) const
+{
+ if (index < 0 || index >= getNumInputChannels())
+ return false;
+
+ VstPinProperties pinProps;
+ if (dispatch (effGetInputProperties, index, 0, &pinProps, 0.0f) != 0)
+ return (pinProps.flags & kVstPinIsStereo) != 0;
+
+ return true;
+}
+
+const String VSTPluginInstance::getOutputChannelName (const int index) const
+{
+ if (index >= 0 && index < getNumOutputChannels())
+ {
+ VstPinProperties pinProps;
+ if (dispatch (effGetOutputProperties, index, 0, &pinProps, 0.0f) != 0)
+ return String (pinProps.label, sizeof (pinProps.label));
+ }
+
+ return String::empty;
+}
+
+bool VSTPluginInstance::isOutputChannelStereoPair (int index) const
+{
+ if (index < 0 || index >= getNumOutputChannels())
+ return false;
+
+ VstPinProperties pinProps;
+ if (dispatch (effGetOutputProperties, index, 0, &pinProps, 0.0f) != 0)
+ return (pinProps.flags & kVstPinIsStereo) != 0;
+
+ return true;
+}
+
+void VSTPluginInstance::setPower (const bool on)
+{
+ dispatch (effMainsChanged, 0, on ? 1 : 0, 0, 0);
+ isPowerOn = on;
+}
+
+const int defaultMaxSizeMB = 64;
+
+void VSTPluginInstance::getStateInformation (MemoryBlock& destData)
+{
+ saveToFXBFile (destData, true, defaultMaxSizeMB);
+}
+
+void VSTPluginInstance::getCurrentProgramStateInformation (MemoryBlock& destData)
+{
+ saveToFXBFile (destData, false, defaultMaxSizeMB);
+}
+
+void VSTPluginInstance::setStateInformation (const void* data, int sizeInBytes)
+{
+ loadFromFXBFile (data, sizeInBytes);
+}
+
+void VSTPluginInstance::setCurrentProgramStateInformation (const void* data, int sizeInBytes)
+{
+ loadFromFXBFile (data, sizeInBytes);
+}
+
+VSTPluginFormat::VSTPluginFormat()
+{
+}
+
+VSTPluginFormat::~VSTPluginFormat()
+{
+}
+
+void VSTPluginFormat::findAllTypesForFile (OwnedArray & results,
+ const File& file)
+{
+ if (! fileMightContainThisPluginType (file))
+ return;
+
+ PluginDescription desc;
+ desc.file = file;
+ desc.uid = 0;
+
+ VSTPluginInstance* instance = dynamic_cast (createInstanceFromDescription (desc));
+
+ if (instance == 0)
+ return;
+
+ try
+ {
+#if JUCE_MAC
+ if (instance->module->resFileId != 0)
+ UseResFile (instance->module->resFileId);
+#endif
+
+ instance->fillInPluginDescription (desc);
+
+ VstPlugCategory category = (VstPlugCategory) instance->dispatch (effGetPlugCategory, 0, 0, 0, 0);
+
+ if (category != kPlugCategShell)
+ {
+ // Normal plugin...
+ results.add (new PluginDescription (desc));
+
+ ++insideVSTCallback;
+ instance->dispatch (effOpen, 0, 0, 0, 0);
+ --insideVSTCallback;
+ }
+ else
+ {
+ // It's a shell plugin, so iterate all the subtypes...
+ char shellEffectName [64];
+
+ for (;;)
+ {
+ zerostruct (shellEffectName);
+ const int uid = instance->dispatch (effShellGetNextPlugin, 0, 0, shellEffectName, 0);
+
+ if (uid == 0)
+ {
+ break;
+ }
+ else
+ {
+ desc.uid = uid;
+ desc.name = shellEffectName;
+
+ bool alreadyThere = false;
+
+ for (int i = results.size(); --i >= 0;)
+ {
+ PluginDescription* const d = results.getUnchecked(i);
+
+ if (d->isDuplicateOf (desc))
+ {
+ alreadyThere = true;
+ break;
+ }
+ }
+
+ if (! alreadyThere)
+ results.add (new PluginDescription (desc));
+ }
+ }
+ }
+ }
+ catch (...)
+ {
+ // crashed while loading...
+ }
+
+ deleteAndZero (instance);
+}
+
+AudioPluginInstance* VSTPluginFormat::createInstanceFromDescription (const PluginDescription& desc)
+{
+ VSTPluginInstance* result = 0;
+
+ if (fileMightContainThisPluginType (desc.file))
+ {
+ const File previousWorkingDirectory (File::getCurrentWorkingDirectory());
+ desc.file.getParentDirectory().setAsCurrentWorkingDirectory();
+
+ const ReferenceCountedObjectPtr module (ModuleHandle::findOrCreateModule (desc.file));
+
+ if (module != 0)
+ {
+ shellUIDToCreate = desc.uid;
+
+ result = new VSTPluginInstance (module);
+
+ if (result->effect != 0)
+ {
+ result->effect->resvd2 = (VstIntPtr) (pointer_sized_int) result;
+ result->initialise();
+ }
+ else
+ {
+ deleteAndZero (result);
+ }
+ }
+
+ previousWorkingDirectory.setAsCurrentWorkingDirectory();
+ }
+
+ return result;
+}
+
+bool VSTPluginFormat::fileMightContainThisPluginType (const File& f)
+{
+#if JUCE_MAC
+ if (f.isDirectory() && f.hasFileExtension (T(".vst")))
+ return true;
+
+#if JUCE_PPC
+ FSRef fileRef;
+ if (PlatformUtilities::makeFSRefFromPath (&fileRef, f.getFullPathName()))
+ {
+ const short resFileId = FSOpenResFile (&fileRef, fsRdPerm);
+
+ if (resFileId != -1)
+ {
+ const int numEffects = Count1Resources ('aEff');
+ CloseResFile (resFileId);
+
+ if (numEffects > 0)
+ return true;
+ }
+ }
+#endif
+
+ return false;
+#elif JUCE_WIN32
+ return f.existsAsFile()
+ && f.hasFileExtension (T(".dll"));
+#elif JUCE_LINUX
+ return f.existsAsFile()
+ && f.hasFileExtension (T(".so"));
+#endif
+}
+
+const FileSearchPath VSTPluginFormat::getDefaultLocationsToSearch()
+{
+#if JUCE_MAC
+ return FileSearchPath ("~/Library/Audio/Plug-Ins/VST;/Library/Audio/Plug-Ins/VST");
+#elif JUCE_WIN32
+ const String programFiles (File::getSpecialLocation (File::globalApplicationsDirectory).getFullPathName());
+
+ return FileSearchPath (programFiles + "\\Steinberg\\VstPlugins");
+#elif JUCE_LINUX
+ return FileSearchPath ("/usr/lib/vst");
+#endif
+}
+
+END_JUCE_NAMESPACE
+
+#undef log
+
+#endif
+/********* End of inlined file: juce_VSTPluginFormat.cpp *********/
+
+/********* Start of inlined file: juce_AudioProcessor.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+AudioProcessor::AudioProcessor()
+ : playHead (0),
+ activeEditor (0),
+ sampleRate (0),
+ blockSize (0),
+ numInputChannels (0),
+ numOutputChannels (0),
+ latencySamples (0),
+ suspended (false),
+ nonRealtime (false)
+{
+}
+
+AudioProcessor::~AudioProcessor()
+{
+ // ooh, nasty - the editor should have been deleted before the filter
+ // that it refers to is deleted..
+ jassert (activeEditor == 0);
+
+#ifdef JUCE_DEBUG
+ // This will fail if you've called beginParameterChangeGesture() for one
+ // or more parameters without having made a corresponding call to endParameterChangeGesture...
+ jassert (changingParams.countNumberOfSetBits() == 0);
+#endif
+}
+
+void AudioProcessor::setPlayHead (AudioPlayHead* const newPlayHead) throw()
+{
+ playHead = newPlayHead;
+}
+
+void AudioProcessor::addListener (AudioProcessorListener* const newListener) throw()
+{
+ const ScopedLock sl (listenerLock);
+ listeners.addIfNotAlreadyThere (newListener);
+}
+
+void AudioProcessor::removeListener (AudioProcessorListener* const listenerToRemove) throw()
+{
+ const ScopedLock sl (listenerLock);
+ listeners.removeValue (listenerToRemove);
+}
+
+void AudioProcessor::setPlayConfigDetails (const int numIns,
+ const int numOuts,
+ const double sampleRate_,
+ const int blockSize_) throw()
+{
+ numInputChannels = numIns;
+ numOutputChannels = numOuts;
+ sampleRate = sampleRate_;
+ blockSize = blockSize_;
+}
+
+void AudioProcessor::setNonRealtime (const bool nonRealtime_) throw()
+{
+ nonRealtime = nonRealtime_;
+}
+
+void AudioProcessor::setLatencySamples (const int newLatency)
+{
+ if (latencySamples != newLatency)
+ {
+ latencySamples = newLatency;
+ updateHostDisplay();
+ }
+}
+
+void AudioProcessor::setParameterNotifyingHost (const int parameterIndex,
+ const float newValue)
+{
+ setParameter (parameterIndex, newValue);
+ sendParamChangeMessageToListeners (parameterIndex, newValue);
+}
+
+void AudioProcessor::sendParamChangeMessageToListeners (const int parameterIndex, const float newValue)
+{
+ jassert (((unsigned int) parameterIndex) < (unsigned int) getNumParameters());
+
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ listenerLock.enter();
+ AudioProcessorListener* const l = (AudioProcessorListener*) listeners [i];
+ listenerLock.exit();
+
+ if (l != 0)
+ l->audioProcessorParameterChanged (this, parameterIndex, newValue);
+ }
+}
+
+void AudioProcessor::beginParameterChangeGesture (int parameterIndex)
+{
+ jassert (((unsigned int) parameterIndex) < (unsigned int) getNumParameters());
+
+#ifdef JUCE_DEBUG
+ // This means you've called beginParameterChangeGesture twice in succession without a matching
+ // call to endParameterChangeGesture. That might be fine in most hosts, but better to avoid doing it.
+ jassert (! changingParams [parameterIndex]);
+ changingParams.setBit (parameterIndex);
+#endif
+
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ listenerLock.enter();
+ AudioProcessorListener* const l = (AudioProcessorListener*) listeners [i];
+ listenerLock.exit();
+
+ if (l != 0)
+ l->audioProcessorParameterChangeGestureBegin (this, parameterIndex);
+ }
+}
+
+void AudioProcessor::endParameterChangeGesture (int parameterIndex)
+{
+ jassert (((unsigned int) parameterIndex) < (unsigned int) getNumParameters());
+
+#ifdef JUCE_DEBUG
+ // This means you've called endParameterChangeGesture without having previously called
+ // endParameterChangeGesture. That might be fine in most hosts, but better to keep the
+ // calls matched correctly.
+ jassert (changingParams [parameterIndex]);
+ changingParams.clearBit (parameterIndex);
+#endif
+
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ listenerLock.enter();
+ AudioProcessorListener* const l = (AudioProcessorListener*) listeners [i];
+ listenerLock.exit();
+
+ if (l != 0)
+ l->audioProcessorParameterChangeGestureEnd (this, parameterIndex);
+ }
+}
+
+void AudioProcessor::updateHostDisplay()
+{
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ listenerLock.enter();
+ AudioProcessorListener* const l = (AudioProcessorListener*) listeners [i];
+ listenerLock.exit();
+
+ if (l != 0)
+ l->audioProcessorChanged (this);
+ }
+}
+
+bool AudioProcessor::isParameterAutomatable (int /*index*/) const
+{
+ return true;
+}
+
+void AudioProcessor::suspendProcessing (const bool shouldBeSuspended)
+{
+ const ScopedLock sl (callbackLock);
+ suspended = shouldBeSuspended;
+}
+
+void AudioProcessor::editorBeingDeleted (AudioProcessorEditor* const editor) throw()
+{
+ const ScopedLock sl (callbackLock);
+
+ jassert (activeEditor == editor);
+
+ if (activeEditor == editor)
+ activeEditor = 0;
+}
+
+AudioProcessorEditor* AudioProcessor::createEditorIfNeeded()
+{
+ if (activeEditor != 0)
+ return activeEditor;
+
+ AudioProcessorEditor* const ed = createEditor();
+
+ if (ed != 0)
+ {
+ // you must give your editor comp a size before returning it..
+ jassert (ed->getWidth() > 0 && ed->getHeight() > 0);
+
+ const ScopedLock sl (callbackLock);
+ activeEditor = ed;
+ }
+
+ return ed;
+}
+
+void AudioProcessor::getCurrentProgramStateInformation (JUCE_NAMESPACE::MemoryBlock& destData)
+{
+ getStateInformation (destData);
+}
+
+void AudioProcessor::setCurrentProgramStateInformation (const void* data, int sizeInBytes)
+{
+ setStateInformation (data, sizeInBytes);
+}
+
+// magic number to identify memory blocks that we've stored as XML
+const uint32 magicXmlNumber = 0x21324356;
+
+void AudioProcessor::copyXmlToBinary (const XmlElement& xml,
+ JUCE_NAMESPACE::MemoryBlock& destData)
+{
+ const String xmlString (xml.createDocument (String::empty, true, false));
+ const int stringLength = xmlString.length();
+
+ destData.setSize (stringLength + 10);
+
+ char* const d = (char*) destData.getData();
+ *(uint32*) d = swapIfBigEndian ((const uint32) magicXmlNumber);
+ *(uint32*) (d + 4) = swapIfBigEndian ((const uint32) stringLength);
+
+ xmlString.copyToBuffer (d + 8, stringLength);
+}
+
+XmlElement* AudioProcessor::getXmlFromBinary (const void* data,
+ const int sizeInBytes)
+{
+ if (sizeInBytes > 8
+ && littleEndianInt ((const char*) data) == magicXmlNumber)
+ {
+ const uint32 stringLength = littleEndianInt (((const char*) data) + 4);
+
+ if (stringLength > 0)
+ {
+ XmlDocument doc (String (((const char*) data) + 8,
+ jmin ((sizeInBytes - 8), stringLength)));
+
+ return doc.getDocumentElement();
+ }
+ }
+
+ return 0;
+}
+
+void AudioProcessorListener::audioProcessorParameterChangeGestureBegin (AudioProcessor*, int)
+{
+}
+
+void AudioProcessorListener::audioProcessorParameterChangeGestureEnd (AudioProcessor*, int)
+{
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_AudioProcessor.cpp *********/
+
+/********* Start of inlined file: juce_AudioProcessorEditor.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+AudioProcessorEditor::AudioProcessorEditor (AudioProcessor* const owner_)
+ : owner (owner_)
+{
+ // the filter must be valid..
+ jassert (owner != 0);
+}
+
+AudioProcessorEditor::~AudioProcessorEditor()
+{
+ // if this fails, then the wrapper hasn't called editorBeingDeleted() on the
+ // filter for some reason..
+ jassert (owner->getActiveEditor() != this);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_AudioProcessorEditor.cpp *********/
+
+/********* Start of inlined file: juce_AudioProcessorGraph.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+const int AudioProcessorGraph::midiChannelIndex = 0x1000;
+
+AudioProcessorGraph::Node::Node (const uint32 id_,
+ AudioProcessor* const processor_) throw()
+ : id (id_),
+ processor (processor_),
+ isPrepared (false)
+{
+ jassert (processor_ != 0);
+}
+
+AudioProcessorGraph::Node::~Node()
+{
+ delete processor;
+}
+
+void AudioProcessorGraph::Node::prepare (const double sampleRate, const int blockSize,
+ AudioProcessorGraph* const graph)
+{
+ if (! isPrepared)
+ {
+ isPrepared = true;
+
+ AudioProcessorGraph::AudioGraphIOProcessor* const ioProc
+ = dynamic_cast (processor);
+
+ if (ioProc != 0)
+ ioProc->setParentGraph (graph);
+
+ processor->setPlayConfigDetails (processor->getNumInputChannels(),
+ processor->getNumOutputChannels(),
+ sampleRate, blockSize);
+
+ processor->prepareToPlay (sampleRate, blockSize);
+ }
+}
+
+void AudioProcessorGraph::Node::unprepare()
+{
+ if (isPrepared)
+ {
+ isPrepared = false;
+ processor->releaseResources();
+ }
+}
+
+AudioProcessorGraph::AudioProcessorGraph()
+ : lastNodeId (0),
+ renderingBuffers (1, 1)
+{
+}
+
+AudioProcessorGraph::~AudioProcessorGraph()
+{
+ clearRenderingSequence();
+ clear();
+}
+
+const String AudioProcessorGraph::getName() const
+{
+ return "Audio Graph";
+}
+
+void AudioProcessorGraph::clear()
+{
+ nodes.clear();
+ connections.clear();
+ triggerAsyncUpdate();
+}
+
+AudioProcessorGraph::Node* AudioProcessorGraph::getNodeForId (const uint32 nodeId) const throw()
+{
+ for (int i = nodes.size(); --i >= 0;)
+ if (nodes.getUnchecked(i)->id == nodeId)
+ return nodes.getUnchecked(i);
+
+ return 0;
+}
+
+AudioProcessorGraph::Node* AudioProcessorGraph::addNode (AudioProcessor* const newProcessor,
+ uint32 nodeId)
+{
+ if (newProcessor == 0)
+ {
+ jassertfalse
+ return 0;
+ }
+
+ if (nodeId == 0)
+ {
+ nodeId = ++lastNodeId;
+ }
+ else
+ {
+ // you can't add a node with an id that already exists in the graph..
+ jassert (getNodeForId (nodeId) == 0);
+ removeNode (nodeId);
+ }
+
+ lastNodeId = nodeId;
+
+ Node* const n = new Node (nodeId, newProcessor);
+ nodes.add (n);
+ triggerAsyncUpdate();
+
+ AudioProcessorGraph::AudioGraphIOProcessor* const ioProc
+ = dynamic_cast (n->processor);
+
+ if (ioProc != 0)
+ ioProc->setParentGraph (this);
+
+ return n;
+}
+
+bool AudioProcessorGraph::removeNode (const uint32 nodeId)
+{
+ disconnectNode (nodeId);
+
+ for (int i = nodes.size(); --i >= 0;)
+ {
+ if (nodes.getUnchecked(i)->id == nodeId)
+ {
+ AudioProcessorGraph::AudioGraphIOProcessor* const ioProc
+ = dynamic_cast (nodes.getUnchecked(i)->processor);
+
+ if (ioProc != 0)
+ ioProc->setParentGraph (0);
+
+ nodes.remove (i);
+ triggerAsyncUpdate();
+
+ return true;
+ }
+ }
+
+ return false;
+}
+
+const AudioProcessorGraph::Connection* AudioProcessorGraph::getConnectionBetween (const uint32 sourceNodeId,
+ const int sourceChannelIndex,
+ const uint32 destNodeId,
+ const int destChannelIndex) const throw()
+{
+ for (int i = connections.size(); --i >= 0;)
+ {
+ const Connection* const c = connections.getUnchecked(i);
+
+ if (c->sourceNodeId == sourceNodeId
+ && c->destNodeId == destNodeId
+ && c->sourceChannelIndex == sourceChannelIndex
+ && c->destChannelIndex == destChannelIndex)
+ {
+ return c;
+ }
+ }
+
+ return 0;
+}
+
+bool AudioProcessorGraph::isConnected (const uint32 possibleSourceNodeId,
+ const uint32 possibleDestNodeId) const throw()
+{
+ for (int i = connections.size(); --i >= 0;)
+ {
+ const Connection* const c = connections.getUnchecked(i);
+
+ if (c->sourceNodeId == possibleSourceNodeId
+ && c->destNodeId == possibleDestNodeId)
+ {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+bool AudioProcessorGraph::canConnect (const uint32 sourceNodeId,
+ const int sourceChannelIndex,
+ const uint32 destNodeId,
+ const int destChannelIndex) const throw()
+{
+ if (sourceChannelIndex < 0
+ || destChannelIndex < 0
+ || sourceNodeId == destNodeId
+ || (destChannelIndex == midiChannelIndex) != (sourceChannelIndex == midiChannelIndex))
+ return false;
+
+ const Node* const source = getNodeForId (sourceNodeId);
+
+ if (source == 0
+ || (sourceChannelIndex != midiChannelIndex && sourceChannelIndex >= source->processor->getNumOutputChannels())
+ || (sourceChannelIndex == midiChannelIndex && ! source->processor->producesMidi()))
+ return false;
+
+ const Node* const dest = getNodeForId (destNodeId);
+
+ if (dest == 0
+ || (destChannelIndex != midiChannelIndex && destChannelIndex >= dest->processor->getNumInputChannels())
+ || (destChannelIndex == midiChannelIndex && ! dest->processor->acceptsMidi()))
+ return false;
+
+ return getConnectionBetween (sourceNodeId, sourceChannelIndex,
+ destNodeId, destChannelIndex) == 0;
+}
+
+bool AudioProcessorGraph::addConnection (const uint32 sourceNodeId,
+ const int sourceChannelIndex,
+ const uint32 destNodeId,
+ const int destChannelIndex)
+{
+ if (! canConnect (sourceNodeId, sourceChannelIndex, destNodeId, destChannelIndex))
+ return false;
+
+ Connection* const c = new Connection();
+ c->sourceNodeId = sourceNodeId;
+ c->sourceChannelIndex = sourceChannelIndex;
+ c->destNodeId = destNodeId;
+ c->destChannelIndex = destChannelIndex;
+
+ connections.add (c);
+ triggerAsyncUpdate();
+
+ return true;
+}
+
+void AudioProcessorGraph::removeConnection (const int index)
+{
+ connections.remove (index);
+ triggerAsyncUpdate();
+}
+
+bool AudioProcessorGraph::removeConnection (const uint32 sourceNodeId, const int sourceChannelIndex,
+ const uint32 destNodeId, const int destChannelIndex)
+{
+ bool doneAnything = false;
+
+ for (int i = connections.size(); --i >= 0;)
+ {
+ const Connection* const c = connections.getUnchecked(i);
+
+ if (c->sourceNodeId == sourceNodeId
+ && c->destNodeId == destNodeId
+ && c->sourceChannelIndex == sourceChannelIndex
+ && c->destChannelIndex == destChannelIndex)
+ {
+ removeConnection (i);
+ doneAnything = true;
+ triggerAsyncUpdate();
+ }
+ }
+
+ return doneAnything;
+}
+
+bool AudioProcessorGraph::disconnectNode (const uint32 nodeId)
+{
+ bool doneAnything = false;
+
+ for (int i = connections.size(); --i >= 0;)
+ {
+ const Connection* const c = connections.getUnchecked(i);
+
+ if (c->sourceNodeId == nodeId || c->destNodeId == nodeId)
+ {
+ removeConnection (i);
+ doneAnything = true;
+ triggerAsyncUpdate();
+ }
+ }
+
+ return doneAnything;
+}
+
+bool AudioProcessorGraph::removeIllegalConnections()
+{
+ bool doneAnything = false;
+
+ for (int i = connections.size(); --i >= 0;)
+ {
+ const Connection* const c = connections.getUnchecked(i);
+
+ const Node* const source = getNodeForId (c->sourceNodeId);
+ const Node* const dest = getNodeForId (c->destNodeId);
+
+ if (source == 0 || dest == 0
+ || (c->sourceChannelIndex != midiChannelIndex
+ && (((unsigned int) c->sourceChannelIndex) >= (unsigned int) source->processor->getNumOutputChannels()))
+ || (c->sourceChannelIndex == midiChannelIndex
+ && ! source->processor->producesMidi())
+ || (c->destChannelIndex != midiChannelIndex
+ && (((unsigned int) c->destChannelIndex) >= (unsigned int) dest->processor->getNumInputChannels()))
+ || (c->destChannelIndex == midiChannelIndex
+ && ! dest->processor->acceptsMidi()))
+ {
+ removeConnection (i);
+ doneAnything = true;
+ triggerAsyncUpdate();
+ }
+ }
+
+ return doneAnything;
+}
+
+namespace GraphRenderingOps
+{
+
+class AudioGraphRenderingOp
+{
+public:
+ AudioGraphRenderingOp() throw() {}
+ virtual ~AudioGraphRenderingOp() throw() {}
+
+ virtual void perform (AudioSampleBuffer& sharedBufferChans,
+ const OwnedArray & sharedMidiBuffers,
+ const int numSamples) throw() = 0;
+
+ juce_UseDebuggingNewOperator
+};
+
+class ClearChannelOp : public AudioGraphRenderingOp
+{
+public:
+ ClearChannelOp (const int channelNum_) throw()
+ : channelNum (channelNum_)
+ {}
+
+ ~ClearChannelOp() throw() {}
+
+ void perform (AudioSampleBuffer& sharedBufferChans, const OwnedArray &, const int numSamples) throw()
+ {
+ sharedBufferChans.clear (channelNum, 0, numSamples);
+ }
+
+private:
+ const int channelNum;
+
+ ClearChannelOp (const ClearChannelOp&);
+ const ClearChannelOp& operator= (const ClearChannelOp&);
+};
+
+class CopyChannelOp : public AudioGraphRenderingOp
+{
+public:
+ CopyChannelOp (const int srcChannelNum_, const int dstChannelNum_) throw()
+ : srcChannelNum (srcChannelNum_),
+ dstChannelNum (dstChannelNum_)
+ {}
+
+ ~CopyChannelOp() throw() {}
+
+ void perform (AudioSampleBuffer& sharedBufferChans, const OwnedArray &, const int numSamples) throw()
+ {
+ sharedBufferChans.copyFrom (dstChannelNum, 0, sharedBufferChans, srcChannelNum, 0, numSamples);
+ }
+
+private:
+ const int srcChannelNum, dstChannelNum;
+
+ CopyChannelOp (const CopyChannelOp&);
+ const CopyChannelOp& operator= (const CopyChannelOp&);
+};
+
+class AddChannelOp : public AudioGraphRenderingOp
+{
+public:
+ AddChannelOp (const int srcChannelNum_, const int dstChannelNum_) throw()
+ : srcChannelNum (srcChannelNum_),
+ dstChannelNum (dstChannelNum_)
+ {}
+
+ ~AddChannelOp() throw() {}
+
+ void perform (AudioSampleBuffer& sharedBufferChans,
+ const OwnedArray & sharedMidiBuffers,
+ const int numSamples) throw()
+ {
+ if (dstChannelNum != AudioProcessorGraph::midiChannelIndex)
+ sharedBufferChans.addFrom (dstChannelNum, 0, sharedBufferChans, srcChannelNum, 0, numSamples);
+ else
+ sharedMidiBuffers.getUnchecked (dstChannelNum)
+ ->addEvents (*sharedMidiBuffers.getUnchecked (srcChannelNum),
+ 0, numSamples, 0);
+ }
+
+private:
+ const int srcChannelNum, dstChannelNum;
+
+ AddChannelOp (const AddChannelOp&);
+ const AddChannelOp& operator= (const AddChannelOp&);
+};
+
+class ClearMidiBufferOp : public AudioGraphRenderingOp
+{
+public:
+ ClearMidiBufferOp (const int bufferNum_) throw()
+ : bufferNum (bufferNum_)
+ {}
+
+ ~ClearMidiBufferOp() throw() {}
+
+ void perform (AudioSampleBuffer&, const OwnedArray & sharedMidiBuffers, const int) throw()
+ {
+ sharedMidiBuffers.getUnchecked (bufferNum)->clear();
+ }
+
+private:
+ const int bufferNum;
+
+ ClearMidiBufferOp (const ClearMidiBufferOp&);
+ const ClearMidiBufferOp& operator= (const ClearMidiBufferOp&);
+};
+
+class CopyMidiBufferOp : public AudioGraphRenderingOp
+{
+public:
+ CopyMidiBufferOp (const int srcBufferNum_, const int dstBufferNum_) throw()
+ : srcBufferNum (srcBufferNum_),
+ dstBufferNum (dstBufferNum_)
+ {}
+
+ ~CopyMidiBufferOp() throw() {}
+
+ void perform (AudioSampleBuffer&, const OwnedArray & sharedMidiBuffers, const int) throw()
+ {
+ *sharedMidiBuffers.getUnchecked (dstBufferNum) = *sharedMidiBuffers.getUnchecked (srcBufferNum);
+ }
+
+private:
+ const int srcBufferNum, dstBufferNum;
+
+ CopyMidiBufferOp (const CopyMidiBufferOp&);
+ const CopyMidiBufferOp& operator= (const CopyMidiBufferOp&);
+};
+
+class AddMidiBufferOp : public AudioGraphRenderingOp
+{
+public:
+ AddMidiBufferOp (const int srcBufferNum_, const int dstBufferNum_) throw()
+ : srcBufferNum (srcBufferNum_),
+ dstBufferNum (dstBufferNum_)
+ {}
+
+ ~AddMidiBufferOp() throw() {}
+
+ void perform (AudioSampleBuffer&, const OwnedArray & sharedMidiBuffers, const int numSamples) throw()
+ {
+ sharedMidiBuffers.getUnchecked (dstBufferNum)
+ ->addEvents (*sharedMidiBuffers.getUnchecked (srcBufferNum), 0, numSamples, 0);
+ }
+
+private:
+ const int srcBufferNum, dstBufferNum;
+
+ AddMidiBufferOp (const AddMidiBufferOp&);
+ const AddMidiBufferOp& operator= (const AddMidiBufferOp&);
+};
+
+class ProcessBufferOp : public AudioGraphRenderingOp
+{
+public:
+ ProcessBufferOp (const AudioProcessorGraph::Node::Ptr& node_,
+ const Array & audioChannelsToUse_,
+ const int totalChans_,
+ const int midiBufferToUse_) throw()
+ : node (node_),
+ processor (node_->processor),
+ audioChannelsToUse (audioChannelsToUse_),
+ totalChans (totalChans_),
+ midiBufferToUse (midiBufferToUse_)
+ {
+ channels = (float**) juce_calloc (sizeof (float*) * totalChans_);
+ }
+
+ ~ProcessBufferOp() throw()
+ {
+ juce_free (channels);
+ }
+
+ void perform (AudioSampleBuffer& sharedBufferChans, const OwnedArray & sharedMidiBuffers, const int numSamples) throw()
+ {
+ for (int i = totalChans; --i >= 0;)
+ channels[i] = sharedBufferChans.getSampleData (audioChannelsToUse.getUnchecked (i), 0);
+
+ AudioSampleBuffer buffer (channels, totalChans, numSamples);
+
+ processor->processBlock (buffer, *sharedMidiBuffers.getUnchecked (midiBufferToUse));
+ }
+
+ const AudioProcessorGraph::Node::Ptr node;
+ AudioProcessor* const processor;
+
+private:
+ Array audioChannelsToUse;
+ float** channels;
+ int totalChans;
+ int midiBufferToUse;
+
+ ProcessBufferOp (const ProcessBufferOp&);
+ const ProcessBufferOp& operator= (const ProcessBufferOp&);
+};
+
+/** Used to calculate the correct sequence of rendering ops needed, based on
+ the best re-use of shared buffers at each stage.
+*/
+class RenderingOpSequenceCalculator
+{
+public:
+
+ RenderingOpSequenceCalculator (AudioProcessorGraph& graph_,
+ const VoidArray& orderedNodes_,
+ VoidArray& renderingOps)
+ : graph (graph_),
+ orderedNodes (orderedNodes_)
+ {
+ nodeIds.add (-2); // first buffer is read-only zeros
+ channels.add (0);
+
+ midiNodeIds.add (-2);
+
+ for (int i = 0; i < orderedNodes.size(); ++i)
+ {
+ createRenderingOpsForNode ((AudioProcessorGraph::Node*) orderedNodes.getUnchecked(i),
+ renderingOps, i);
+
+ markAnyUnusedBuffersAsFree (i);
+ }
+ }
+
+ int getNumBuffersNeeded() const throw() { return nodeIds.size(); }
+
+ int getNumMidiBuffersNeeded() const throw() { return midiNodeIds.size(); }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ AudioProcessorGraph& graph;
+ const VoidArray& orderedNodes;
+ Array nodeIds, channels, midiNodeIds;
+
+ void createRenderingOpsForNode (AudioProcessorGraph::Node* const node,
+ VoidArray& renderingOps,
+ const int ourRenderingIndex)
+ {
+ const int numIns = node->processor->getNumInputChannels();
+ const int numOuts = node->processor->getNumOutputChannels();
+ const int totalChans = jmax (numIns, numOuts);
+
+ Array audioChannelsToUse;
+ int midiBufferToUse = -1;
+
+ for (int inputChan = 0; inputChan < numIns; ++inputChan)
+ {
+ // get a list of all the inputs to this node
+ Array sourceNodes, sourceOutputChans;
+
+ for (int i = graph.getNumConnections(); --i >= 0;)
+ {
+ const AudioProcessorGraph::Connection* const c = graph.getConnection (i);
+
+ if (c->destNodeId == node->id && c->destChannelIndex == inputChan)
+ {
+ sourceNodes.add (c->sourceNodeId);
+ sourceOutputChans.add (c->sourceChannelIndex);
+ }
+ }
+
+ int bufIndex = -1;
+
+ if (sourceNodes.size() == 0)
+ {
+ // unconnected input channel
+
+ if (inputChan >= numOuts)
+ {
+ bufIndex = getReadOnlyEmptyBuffer();
+ jassert (bufIndex >= 0);
+ }
+ else
+ {
+ bufIndex = getFreeBuffer (false);
+ renderingOps.add (new ClearChannelOp (bufIndex));
+ }
+ }
+ else if (sourceNodes.size() == 1)
+ {
+ // channel with a straightforward single input..
+ const int srcNode = sourceNodes.getUnchecked(0);
+ const int srcChan = sourceOutputChans.getUnchecked(0);
+
+ bufIndex = getBufferContaining (srcNode, srcChan);
+ jassert (bufIndex >= 0);
+
+ if (inputChan < numOuts
+ && isBufferNeededLater (ourRenderingIndex,
+ inputChan,
+ srcNode, srcChan))
+ {
+ // can't mess up this channel because it's needed later by another node, so we
+ // need to use a copy of it..
+ const int newFreeBuffer = getFreeBuffer (false);
+
+ renderingOps.add (new CopyChannelOp (bufIndex, newFreeBuffer));
+
+ bufIndex = newFreeBuffer;
+ }
+ }
+ else
+ {
+ // channel with a mix of several inputs..
+
+ // try to find a re-usable channel from our inputs..
+ int reusableInputIndex = -1;
+
+ for (int i = 0; i < sourceNodes.size(); ++i)
+ {
+ const int sourceBufIndex = getBufferContaining (sourceNodes.getUnchecked(i),
+ sourceOutputChans.getUnchecked(i));
+
+ jassert (sourceBufIndex >= 0);
+
+ if (! isBufferNeededLater (ourRenderingIndex,
+ inputChan,
+ sourceNodes.getUnchecked(i),
+ sourceOutputChans.getUnchecked(i)))
+ {
+ // we've found one of our input chans that can be re-used..
+ reusableInputIndex = i;
+ bufIndex = sourceBufIndex;
+ break;
+ }
+ }
+
+ if (reusableInputIndex < 0)
+ {
+ // can't re-use any of our input chans, so get a new one and copy everything into it..
+ bufIndex = getFreeBuffer (false);
+ jassert (bufIndex != 0);
+
+ const int srcIndex = getBufferContaining (sourceNodes.getUnchecked (0),
+ sourceOutputChans.getUnchecked (0));
+ jassert (srcIndex >= 0);
+
+ renderingOps.add (new CopyChannelOp (srcIndex, bufIndex));
+
+ reusableInputIndex = 0;
+ }
+
+ for (int j = 0; j < sourceNodes.size(); ++j)
+ {
+ if (j != reusableInputIndex)
+ {
+ const int srcIndex = getBufferContaining (sourceNodes.getUnchecked(j),
+ sourceOutputChans.getUnchecked(j));
+ jassert (srcIndex >= 0);
+
+ renderingOps.add (new AddChannelOp (srcIndex, bufIndex));
+ }
+ }
+ }
+
+ jassert (bufIndex >= 0);
+ audioChannelsToUse.add (bufIndex);
+
+ if (inputChan < numOuts)
+ markBufferAsContaining (bufIndex, node->id, inputChan);
+ }
+
+ for (int outputChan = numIns; outputChan < numOuts; ++outputChan)
+ {
+ const int bufIndex = getFreeBuffer (false);
+ jassert (bufIndex != 0);
+ audioChannelsToUse.add (bufIndex);
+
+ markBufferAsContaining (bufIndex, node->id, outputChan);
+ }
+
+ // Now the same thing for midi..
+ Array midiSourceNodes;
+
+ for (int i = graph.getNumConnections(); --i >= 0;)
+ {
+ const AudioProcessorGraph::Connection* const c = graph.getConnection (i);
+
+ if (c->destNodeId == node->id && c->destChannelIndex == AudioProcessorGraph::midiChannelIndex)
+ midiSourceNodes.add (c->sourceNodeId);
+ }
+
+ if (midiSourceNodes.size() == 0)
+ {
+ // No midi inputs..
+ midiBufferToUse = getFreeBuffer (true); // need to pick a buffer even if the processor doesn't use midi
+
+ if (node->processor->acceptsMidi() || node->processor->producesMidi())
+ renderingOps.add (new ClearMidiBufferOp (midiBufferToUse));
+ }
+ else if (midiSourceNodes.size() == 1)
+ {
+ // One midi input..
+ midiBufferToUse = getBufferContaining (midiSourceNodes.getUnchecked(0),
+ AudioProcessorGraph::midiChannelIndex);
+
+ jassert (midiBufferToUse >= 0);
+
+ if (midiBufferToUse >= 0)
+ {
+ if (isBufferNeededLater (ourRenderingIndex,
+ AudioProcessorGraph::midiChannelIndex,
+ midiSourceNodes.getUnchecked(0),
+ AudioProcessorGraph::midiChannelIndex))
+ {
+ // can't mess up this channel because it's needed later by another node, so we
+ // need to use a copy of it..
+ const int newFreeBuffer = getFreeBuffer (true);
+ renderingOps.add (new CopyMidiBufferOp (midiBufferToUse, newFreeBuffer));
+ midiBufferToUse = newFreeBuffer;
+ }
+ }
+ }
+ else
+ {
+ // More than one midi input being mixed..
+ int reusableInputIndex = -1;
+
+ for (int i = 0; i < midiSourceNodes.size(); ++i)
+ {
+ const int sourceBufIndex = getBufferContaining (midiSourceNodes.getUnchecked(i),
+ AudioProcessorGraph::midiChannelIndex);
+
+ jassert (sourceBufIndex >= 0);
+
+ if (! isBufferNeededLater (ourRenderingIndex,
+ AudioProcessorGraph::midiChannelIndex,
+ midiSourceNodes.getUnchecked(i),
+ AudioProcessorGraph::midiChannelIndex))
+ {
+ // we've found one of our input buffers that can be re-used..
+ reusableInputIndex = i;
+ midiBufferToUse = sourceBufIndex;
+ break;
+ }
+ }
+
+ if (reusableInputIndex < 0)
+ {
+ // can't re-use any of our input buffers, so get a new one and copy everything into it..
+ midiBufferToUse = getFreeBuffer (true);
+ jassert (midiBufferToUse >= 0);
+
+ const int srcIndex = getBufferContaining (midiSourceNodes.getUnchecked(0),
+ AudioProcessorGraph::midiChannelIndex);
+ jassert (srcIndex >= 0);
+
+ renderingOps.add (new CopyMidiBufferOp (srcIndex, midiBufferToUse));
+
+ reusableInputIndex = 0;
+ }
+
+ for (int j = 0; j < midiSourceNodes.size(); ++j)
+ {
+ if (j != reusableInputIndex)
+ {
+ const int srcIndex = getBufferContaining (midiSourceNodes.getUnchecked(j),
+ AudioProcessorGraph::midiChannelIndex);
+ jassert (srcIndex >= 0);
+
+ renderingOps.add (new AddMidiBufferOp (srcIndex, midiBufferToUse));
+ }
+ }
+ }
+
+ if (node->processor->producesMidi())
+ markBufferAsContaining (midiBufferToUse, node->id,
+ AudioProcessorGraph::midiChannelIndex);
+
+ renderingOps.add (new ProcessBufferOp (node, audioChannelsToUse,
+ totalChans, midiBufferToUse));
+ }
+
+ int getFreeBuffer (const bool forMidi)
+ {
+ if (forMidi)
+ {
+ for (int i = 1; i < midiNodeIds.size(); ++i)
+ if (midiNodeIds.getUnchecked(i) < 0)
+ return i;
+
+ midiNodeIds.add (-1);
+ return midiNodeIds.size() - 1;
+ }
+ else
+ {
+ for (int i = 1; i < nodeIds.size(); ++i)
+ if (nodeIds.getUnchecked(i) < 0)
+ return i;
+
+ nodeIds.add (-1);
+ channels.add (0);
+ return nodeIds.size() - 1;
+ }
+ }
+
+ int getReadOnlyEmptyBuffer() const throw()
+ {
+ return 0;
+ }
+
+ int getBufferContaining (const int nodeId, const int outputChannel) const throw()
+ {
+ if (outputChannel == AudioProcessorGraph::midiChannelIndex)
+ {
+ for (int i = midiNodeIds.size(); --i >= 0;)
+ if (midiNodeIds.getUnchecked(i) == nodeId)
+ return i;
+ }
+ else
+ {
+ for (int i = nodeIds.size(); --i >= 0;)
+ if (nodeIds.getUnchecked(i) == nodeId
+ && channels.getUnchecked(i) == outputChannel)
+ return i;
+ }
+
+ return -1;
+ }
+
+ void markAnyUnusedBuffersAsFree (const int stepIndex)
+ {
+ int i;
+ for (i = 0; i < nodeIds.size(); ++i)
+ {
+ if (nodeIds.getUnchecked(i) >= 0
+ && ! isBufferNeededLater (stepIndex, -1,
+ nodeIds.getUnchecked(i),
+ channels.getUnchecked(i)))
+ {
+ nodeIds.set (i, -1);
+ }
+ }
+
+ for (i = 0; i < midiNodeIds.size(); ++i)
+ {
+ if (midiNodeIds.getUnchecked(i) >= 0
+ && ! isBufferNeededLater (stepIndex, -1,
+ midiNodeIds.getUnchecked(i),
+ AudioProcessorGraph::midiChannelIndex))
+ {
+ midiNodeIds.set (i, -1);
+ }
+ }
+ }
+
+ bool isBufferNeededLater (int stepIndexToSearchFrom,
+ int inputChannelOfIndexToIgnore,
+ const int nodeId,
+ const int outputChanIndex) const throw()
+ {
+ while (stepIndexToSearchFrom < orderedNodes.size())
+ {
+ const AudioProcessorGraph::Node* const node = (const AudioProcessorGraph::Node*) orderedNodes.getUnchecked (stepIndexToSearchFrom);
+
+ if (outputChanIndex == AudioProcessorGraph::midiChannelIndex)
+ {
+ if (inputChannelOfIndexToIgnore != AudioProcessorGraph::midiChannelIndex
+ && graph.getConnectionBetween (nodeId, AudioProcessorGraph::midiChannelIndex,
+ node->id, AudioProcessorGraph::midiChannelIndex) != 0)
+ return true;
+ }
+ else
+ {
+ for (int i = 0; i < node->processor->getNumInputChannels(); ++i)
+ if (i != inputChannelOfIndexToIgnore
+ && graph.getConnectionBetween (nodeId, outputChanIndex,
+ node->id, i) != 0)
+ return true;
+ }
+
+ inputChannelOfIndexToIgnore = -1;
+ ++stepIndexToSearchFrom;
+ }
+
+ return false;
+ }
+
+ void markBufferAsContaining (int bufferNum, int nodeId, int outputIndex)
+ {
+ if (outputIndex == AudioProcessorGraph::midiChannelIndex)
+ {
+ jassert (bufferNum > 0 && bufferNum < midiNodeIds.size());
+
+ midiNodeIds.set (bufferNum, nodeId);
+ }
+ else
+ {
+ jassert (bufferNum > 0 && bufferNum < nodeIds.size());
+
+ nodeIds.set (bufferNum, nodeId);
+ channels.set (bufferNum, outputIndex);
+ }
+ }
+
+ RenderingOpSequenceCalculator (const RenderingOpSequenceCalculator&);
+ const RenderingOpSequenceCalculator& operator= (const RenderingOpSequenceCalculator&);
+};
+
+}
+
+void AudioProcessorGraph::clearRenderingSequence()
+{
+ const ScopedLock sl (renderLock);
+
+ for (int i = renderingOps.size(); --i >= 0;)
+ {
+ GraphRenderingOps::AudioGraphRenderingOp* const r
+ = (GraphRenderingOps::AudioGraphRenderingOp*) renderingOps.getUnchecked(i);
+
+ renderingOps.remove (i);
+ delete r;
+ }
+}
+
+bool AudioProcessorGraph::isAnInputTo (const uint32 possibleInputId,
+ const uint32 possibleDestinationId,
+ const int recursionCheck) const throw()
+{
+ if (recursionCheck > 0)
+ {
+ for (int i = connections.size(); --i >= 0;)
+ {
+ const AudioProcessorGraph::Connection* const c = connections.getUnchecked (i);
+
+ if (c->destNodeId == possibleDestinationId
+ && (c->sourceNodeId == possibleInputId
+ || isAnInputTo (possibleInputId, c->sourceNodeId, recursionCheck - 1)))
+ return true;
+ }
+ }
+
+ return false;
+}
+
+void AudioProcessorGraph::buildRenderingSequence()
+{
+ VoidArray newRenderingOps;
+ int numRenderingBuffersNeeded = 2;
+ int numMidiBuffersNeeded = 1;
+
+ {
+ MessageManagerLock mml;
+
+ VoidArray orderedNodes;
+
+ int i;
+ for (i = 0; i < nodes.size(); ++i)
+ {
+ Node* const node = nodes.getUnchecked(i);
+
+ node->prepare (getSampleRate(), getBlockSize(), this);
+
+ int j = 0;
+ for (; j < orderedNodes.size(); ++j)
+ if (isAnInputTo (node->id,
+ ((Node*) orderedNodes.getUnchecked (j))->id,
+ nodes.size() + 1))
+ break;
+
+ orderedNodes.insert (j, node);
+ }
+
+ GraphRenderingOps::RenderingOpSequenceCalculator calculator (*this, orderedNodes, newRenderingOps);
+
+ numRenderingBuffersNeeded = calculator.getNumBuffersNeeded();
+ numMidiBuffersNeeded = calculator.getNumMidiBuffersNeeded();
+ }
+
+ VoidArray oldRenderingOps (renderingOps);
+
+ {
+ // swap over to the new set of rendering sequence..
+ const ScopedLock sl (renderLock);
+
+ renderingBuffers.setSize (numRenderingBuffersNeeded, getBlockSize());
+ renderingBuffers.clear();
+
+ for (int i = midiBuffers.size(); --i >= 0;)
+ midiBuffers.getUnchecked(i)->clear();
+
+ while (midiBuffers.size() < numMidiBuffersNeeded)
+ midiBuffers.add (new MidiBuffer());
+
+ renderingOps = newRenderingOps;
+ }
+
+ for (int i = oldRenderingOps.size(); --i >= 0;)
+ delete (GraphRenderingOps::AudioGraphRenderingOp*) oldRenderingOps.getUnchecked(i);
+}
+
+void AudioProcessorGraph::handleAsyncUpdate()
+{
+ buildRenderingSequence();
+}
+
+void AudioProcessorGraph::prepareToPlay (double /*sampleRate*/, int /*estimatedSamplesPerBlock*/)
+{
+ currentAudioIOBuffer = 0;
+ currentMidiIOBuffer = 0;
+
+ clearRenderingSequence();
+ buildRenderingSequence();
+}
+
+void AudioProcessorGraph::releaseResources()
+{
+ for (int i = 0; i < nodes.size(); ++i)
+ nodes.getUnchecked(i)->unprepare();
+
+ renderingBuffers.setSize (1, 1);
+ midiBuffers.clear();
+
+ currentAudioIOBuffer = 0;
+ currentMidiIOBuffer = 0;
+}
+
+void AudioProcessorGraph::processBlock (AudioSampleBuffer& buffer, MidiBuffer& midiMessages)
+{
+ const ScopedLock sl (renderLock);
+
+ currentAudioIOBuffer = &buffer;
+ currentMidiIOBuffer = &midiMessages;
+
+ const int numSamples = buffer.getNumSamples();
+
+ for (int i = 0; i < renderingOps.size(); ++i)
+ {
+ GraphRenderingOps::AudioGraphRenderingOp* const op
+ = (GraphRenderingOps::AudioGraphRenderingOp*) renderingOps.getUnchecked(i);
+
+ op->perform (renderingBuffers, midiBuffers, numSamples);
+ }
+}
+
+const String AudioProcessorGraph::getInputChannelName (const int channelIndex) const
+{
+ return "Input " + String (channelIndex + 1);
+}
+
+const String AudioProcessorGraph::getOutputChannelName (const int channelIndex) const
+{
+ return "Output " + String (channelIndex + 1);
+}
+
+bool AudioProcessorGraph::isInputChannelStereoPair (int /*index*/) const
+{
+ return true;
+}
+
+bool AudioProcessorGraph::isOutputChannelStereoPair (int /*index*/) const
+{
+ return true;
+}
+
+bool AudioProcessorGraph::acceptsMidi() const
+{
+ return true;
+}
+
+bool AudioProcessorGraph::producesMidi() const
+{
+ return true;
+}
+
+void AudioProcessorGraph::getStateInformation (JUCE_NAMESPACE::MemoryBlock& /*destData*/)
+{
+}
+
+void AudioProcessorGraph::setStateInformation (const void* /*data*/, int /*sizeInBytes*/)
+{
+}
+
+AudioProcessorGraph::AudioGraphIOProcessor::AudioGraphIOProcessor (const IODeviceType type_)
+ : type (type_),
+ graph (0)
+{
+}
+
+AudioProcessorGraph::AudioGraphIOProcessor::~AudioGraphIOProcessor()
+{
+}
+
+const String AudioProcessorGraph::AudioGraphIOProcessor::getName() const
+{
+ switch (type)
+ {
+ case audioOutputNode:
+ return "Audio Output";
+ case audioInputNode:
+ return "Audio Input";
+ case midiOutputNode:
+ return "Midi Output";
+ case midiInputNode:
+ return "Midi Input";
+ default:
+ break;
+ }
+
+ return String::empty;
+}
+
+void AudioProcessorGraph::AudioGraphIOProcessor::fillInPluginDescription (PluginDescription& d) const
+{
+ d.name = getName();
+ d.uid = d.name.hashCode();
+ d.category = "I/O devices";
+ d.pluginFormatName = "Internal";
+ d.manufacturerName = "Raw Material Software";
+ d.version = "1.0";
+ d.isInstrument = false;
+
+ d.numInputChannels = getNumInputChannels();
+ if (type == audioOutputNode && graph != 0)
+ d.numInputChannels = graph->getNumInputChannels();
+
+ d.numOutputChannels = getNumOutputChannels();
+ if (type == audioInputNode && graph != 0)
+ d.numOutputChannels = graph->getNumOutputChannels();
+}
+
+void AudioProcessorGraph::AudioGraphIOProcessor::prepareToPlay (double, int)
+{
+ jassert (graph != 0);
+}
+
+void AudioProcessorGraph::AudioGraphIOProcessor::releaseResources()
+{
+}
+
+void AudioProcessorGraph::AudioGraphIOProcessor::processBlock (AudioSampleBuffer& buffer,
+ MidiBuffer& midiMessages)
+{
+ jassert (graph != 0);
+
+ switch (type)
+ {
+ case audioOutputNode:
+ {
+ for (int i = jmin (graph->currentAudioIOBuffer->getNumChannels(),
+ buffer.getNumChannels()); --i >= 0;)
+ {
+ graph->currentAudioIOBuffer->addFrom (i, 0, buffer, i, 0, buffer.getNumSamples());
+ }
+
+ break;
+ }
+
+ case audioInputNode:
+ {
+ for (int i = jmin (graph->currentAudioIOBuffer->getNumChannels(),
+ buffer.getNumChannels()); --i >= 0;)
+ {
+ buffer.addFrom (i, 0, *graph->currentAudioIOBuffer, i, 0, buffer.getNumSamples());
+ }
+
+ break;
+ }
+
+ case midiOutputNode:
+ graph->currentMidiIOBuffer->addEvents (midiMessages, 0, buffer.getNumSamples(), 0);
+ break;
+
+ case midiInputNode:
+ midiMessages.addEvents (*graph->currentMidiIOBuffer, 0, buffer.getNumSamples(), 0);
+ break;
+
+ default:
+ break;
+ }
+}
+
+bool AudioProcessorGraph::AudioGraphIOProcessor::acceptsMidi() const
+{
+ return type == midiOutputNode;
+}
+
+bool AudioProcessorGraph::AudioGraphIOProcessor::producesMidi() const
+{
+ return type == midiInputNode;
+}
+
+const String AudioProcessorGraph::AudioGraphIOProcessor::getInputChannelName (const int channelIndex) const
+{
+ switch (type)
+ {
+ case audioOutputNode:
+ return "Output " + String (channelIndex + 1);
+ case midiOutputNode:
+ return "Midi Output";
+ default:
+ break;
+ }
+
+ return String::empty;
+}
+
+const String AudioProcessorGraph::AudioGraphIOProcessor::getOutputChannelName (const int channelIndex) const
+{
+ switch (type)
+ {
+ case audioInputNode:
+ return "Input " + String (channelIndex + 1);
+ case midiInputNode:
+ return "Midi Input";
+ default:
+ break;
+ }
+
+ return String::empty;
+}
+
+bool AudioProcessorGraph::AudioGraphIOProcessor::isInputChannelStereoPair (int /*index*/) const
+{
+ return type == audioInputNode || type == audioOutputNode;
+}
+
+bool AudioProcessorGraph::AudioGraphIOProcessor::isOutputChannelStereoPair (int index) const
+{
+ return isInputChannelStereoPair (index);
+}
+
+bool AudioProcessorGraph::AudioGraphIOProcessor::isInput() const throw()
+{
+ return type == audioInputNode || type == midiInputNode;
+}
+
+bool AudioProcessorGraph::AudioGraphIOProcessor::isOutput() const throw()
+{
+ return type == audioOutputNode || type == midiOutputNode;
+}
+
+AudioProcessorEditor* AudioProcessorGraph::AudioGraphIOProcessor::createEditor()
+{
+ return 0;
+}
+
+int AudioProcessorGraph::AudioGraphIOProcessor::getNumParameters() { return 0; }
+const String AudioProcessorGraph::AudioGraphIOProcessor::getParameterName (int) { return String::empty; }
+
+float AudioProcessorGraph::AudioGraphIOProcessor::getParameter (int) { return 0.0f; }
+const String AudioProcessorGraph::AudioGraphIOProcessor::getParameterText (int) { return String::empty; }
+void AudioProcessorGraph::AudioGraphIOProcessor::setParameter (int, float) { }
+
+int AudioProcessorGraph::AudioGraphIOProcessor::getNumPrograms() { return 0; }
+int AudioProcessorGraph::AudioGraphIOProcessor::getCurrentProgram() { return 0; }
+void AudioProcessorGraph::AudioGraphIOProcessor::setCurrentProgram (int) { }
+
+const String AudioProcessorGraph::AudioGraphIOProcessor::getProgramName (int) { return String::empty; }
+void AudioProcessorGraph::AudioGraphIOProcessor::changeProgramName (int, const String&) { }
+
+void AudioProcessorGraph::AudioGraphIOProcessor::getStateInformation (JUCE_NAMESPACE::MemoryBlock&)
+{
+}
+
+void AudioProcessorGraph::AudioGraphIOProcessor::setStateInformation (const void*, int)
+{
+}
+
+void AudioProcessorGraph::AudioGraphIOProcessor::setParentGraph (AudioProcessorGraph* const newGraph) throw()
+{
+ graph = newGraph;
+
+ if (graph != 0)
+ {
+ setPlayConfigDetails (type == audioOutputNode ? graph->getNumInputChannels() : 0,
+ type == audioInputNode ? graph->getNumOutputChannels() : 0,
+ getSampleRate(),
+ getBlockSize());
+
+ updateHostDisplay();
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_AudioProcessorGraph.cpp *********/
+
+/********* Start of inlined file: juce_AudioProcessorPlayer.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+AudioProcessorPlayer::AudioProcessorPlayer()
+ : processor (0),
+ sampleRate (0),
+ blockSize (0),
+ isPrepared (false),
+ numInputChans (0),
+ numOutputChans (0),
+ tempBuffer (1, 1)
+{
+}
+
+AudioProcessorPlayer::~AudioProcessorPlayer()
+{
+ setProcessor (0);
+}
+
+void AudioProcessorPlayer::setProcessor (AudioProcessor* const processorToPlay)
+{
+ if (processor != processorToPlay)
+ {
+ if (processorToPlay != 0 && sampleRate > 0 && blockSize > 0)
+ {
+ processorToPlay->setPlayConfigDetails (numInputChans, numOutputChans,
+ sampleRate, blockSize);
+
+ processorToPlay->prepareToPlay (sampleRate, blockSize);
+ }
+
+ lock.enter();
+ AudioProcessor* const oldOne = isPrepared ? processor : 0;
+ processor = processorToPlay;
+ isPrepared = true;
+ lock.exit();
+
+ if (oldOne != 0)
+ oldOne->releaseResources();
+ }
+}
+
+void AudioProcessorPlayer::audioDeviceIOCallback (const float** inputChannelData,
+ int totalNumInputChannels,
+ float** outputChannelData,
+ int totalNumOutputChannels,
+ int numSamples)
+{
+ // these should have been prepared by audioDeviceAboutToStart()...
+ jassert (sampleRate > 0 && blockSize > 0);
+
+ incomingMidi.clear();
+ messageCollector.removeNextBlockOfMessages (incomingMidi, numSamples);
+
+ int i, numActiveChans = 0, numInputs = 0, numOutputs = 0;
+
+ // messy stuff needed to compact the channels down into an array
+ // of non-zero pointers..
+ for (i = 0; i < totalNumInputChannels; ++i)
+ {
+ if (inputChannelData[i] != 0)
+ {
+ inputChans [numInputs++] = inputChannelData[i];
+ if (numInputs >= numElementsInArray (inputChans))
+ break;
+ }
+ }
+
+ for (i = 0; i < totalNumOutputChannels; ++i)
+ {
+ if (outputChannelData[i] != 0)
+ {
+ outputChans [numOutputs++] = outputChannelData[i];
+ if (numOutputs >= numElementsInArray (outputChans))
+ break;
+ }
+ }
+
+ if (numInputs > numOutputs)
+ {
+ // if there aren't enough output channels for the number of
+ // inputs, we need to create some temporary extra ones (can't
+ // use the input data in case it gets written to)
+ tempBuffer.setSize (numInputs - numOutputs, numSamples,
+ false, false, true);
+
+ for (i = 0; i < numOutputs; ++i)
+ {
+ channels[numActiveChans] = outputChans[i];
+ memcpy (channels[numActiveChans], inputChans[i], sizeof (float) * numSamples);
+ ++numActiveChans;
+ }
+
+ for (i = numOutputs; i < numInputs; ++i)
+ {
+ channels[numActiveChans] = tempBuffer.getSampleData (i - numOutputs, 0);
+ memcpy (channels[numActiveChans], inputChans[i], sizeof (float) * numSamples);
+ ++numActiveChans;
+ }
+ }
+ else
+ {
+ for (i = 0; i < numInputs; ++i)
+ {
+ channels[numActiveChans] = outputChans[i];
+ memcpy (channels[numActiveChans], inputChans[i], sizeof (float) * numSamples);
+ ++numActiveChans;
+ }
+
+ for (i = numInputs; i < numOutputs; ++i)
+ {
+ channels[numActiveChans] = outputChans[i];
+ zeromem (channels[numActiveChans], sizeof (float) * numSamples);
+ ++numActiveChans;
+ }
+ }
+
+ AudioSampleBuffer buffer (channels, numActiveChans, numSamples);
+
+ const ScopedLock sl (lock);
+
+ if (processor != 0)
+ processor->processBlock (buffer, incomingMidi);
+}
+
+void AudioProcessorPlayer::audioDeviceAboutToStart (AudioIODevice* device)
+{
+ const ScopedLock sl (lock);
+
+ sampleRate = device->getCurrentSampleRate();
+ blockSize = device->getCurrentBufferSizeSamples();
+ numInputChans = device->getActiveInputChannels().countNumberOfSetBits();
+ numOutputChans = device->getActiveOutputChannels().countNumberOfSetBits();
+
+ messageCollector.reset (sampleRate);
+ zeromem (channels, sizeof (channels));
+
+ if (processor != 0)
+ {
+ if (isPrepared)
+ processor->releaseResources();
+
+ AudioProcessor* const oldProcessor = processor;
+ setProcessor (0);
+ setProcessor (oldProcessor);
+ }
+}
+
+void AudioProcessorPlayer::audioDeviceStopped()
+{
+ const ScopedLock sl (lock);
+
+ if (processor != 0 && isPrepared)
+ processor->releaseResources();
+
+ sampleRate = 0.0;
+ blockSize = 0;
+ isPrepared = false;
+ tempBuffer.setSize (1, 1);
+}
+
+void AudioProcessorPlayer::handleIncomingMidiMessage (MidiInput*, const MidiMessage& message)
+{
+ messageCollector.addMessageToQueue (message);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_AudioProcessorPlayer.cpp *********/
+
+/********* Start of inlined file: juce_GenericAudioProcessorEditor.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+class ProcessorParameterPropertyComp : public PropertyComponent,
+ public AudioProcessorListener,
+ public AsyncUpdater
+{
+public:
+ ProcessorParameterPropertyComp (const String& name,
+ AudioProcessor* const owner_,
+ const int index_)
+ : PropertyComponent (name),
+ owner (owner_),
+ index (index_)
+ {
+ addAndMakeVisible (slider = new ParamSlider (owner_, index_));
+ owner_->addListener (this);
+ }
+
+ ~ProcessorParameterPropertyComp()
+ {
+ owner->removeListener (this);
+ deleteAllChildren();
+ }
+
+ void refresh()
+ {
+ slider->setValue (owner->getParameter (index), false);
+ }
+
+ void audioProcessorChanged (AudioProcessor*) {}
+
+ void audioProcessorParameterChanged (AudioProcessor*, int parameterIndex, float)
+ {
+ if (parameterIndex == index)
+ triggerAsyncUpdate();
+ }
+
+ void handleAsyncUpdate()
+ {
+ refresh();
+ }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ AudioProcessor* const owner;
+ const int index;
+ Slider* slider;
+
+ class ParamSlider : public Slider
+ {
+ public:
+ ParamSlider (AudioProcessor* const owner_, const int index_)
+ : Slider (String::empty),
+ owner (owner_),
+ index (index_)
+ {
+ setRange (0.0, 1.0, 0.0);
+ setSliderStyle (Slider::LinearBar);
+ setTextBoxIsEditable (false);
+ setScrollWheelEnabled (false);
+ }
+
+ ~ParamSlider()
+ {
+ }
+
+ void valueChanged()
+ {
+ const float newVal = (float) getValue();
+
+ if (owner->getParameter (index) != newVal)
+ owner->setParameter (index, newVal);
+ }
+
+ const String getTextFromValue (double /*value*/)
+ {
+ return owner->getParameterText (index);
+ }
+
+ juce_UseDebuggingNewOperator
+
+ private:
+ AudioProcessor* const owner;
+ const int index;
+ };
+};
+
+GenericAudioProcessorEditor::GenericAudioProcessorEditor (AudioProcessor* const owner)
+ : AudioProcessorEditor (owner)
+{
+ setOpaque (true);
+
+ addAndMakeVisible (panel = new PropertyPanel());
+
+ Array params;
+
+ const int numParams = owner->getNumParameters();
+ int totalHeight = 0;
+
+ for (int i = 0; i < numParams; ++i)
+ {
+ String name (owner->getParameterName (i));
+ if (name.trim().isEmpty())
+ name = "Unnamed";
+
+ ProcessorParameterPropertyComp* const pc = new ProcessorParameterPropertyComp (name, owner, i);
+ params.add (pc);
+ totalHeight += pc->getPreferredHeight();
+ }
+
+ panel->addProperties (params);
+
+ setSize (400, jlimit (25, 400, totalHeight));
+}
+
+GenericAudioProcessorEditor::~GenericAudioProcessorEditor()
+{
+ deleteAllChildren();
+}
+
+void GenericAudioProcessorEditor::paint (Graphics& g)
+{
+ g.fillAll (Colours::white);
+}
+
+void GenericAudioProcessorEditor::resized()
+{
+ panel->setSize (getWidth(), getHeight());
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_GenericAudioProcessorEditor.cpp *********/
+
+/********* Start of inlined file: juce_Sampler.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+SamplerSound::SamplerSound (const String& name_,
+ AudioFormatReader& source,
+ const BitArray& midiNotes_,
+ const int midiNoteForNormalPitch,
+ const double attackTimeSecs,
+ const double releaseTimeSecs,
+ const double maxSampleLengthSeconds)
+ : name (name_),
+ midiNotes (midiNotes_),
+ midiRootNote (midiNoteForNormalPitch)
+{
+ sourceSampleRate = source.sampleRate;
+
+ if (sourceSampleRate <= 0 || source.lengthInSamples <= 0)
+ {
+ data = 0;
+ length = 0;
+ attackSamples = 0;
+ releaseSamples = 0;
+ }
+ else
+ {
+ length = jmin ((int) source.lengthInSamples,
+ (int) (maxSampleLengthSeconds * sourceSampleRate));
+
+ data = new AudioSampleBuffer (jmin (2, source.numChannels), length + 4);
+
+ data->readFromAudioReader (&source, 0, length + 4, 0, true, true);
+
+ attackSamples = roundDoubleToInt (attackTimeSecs * sourceSampleRate);
+ releaseSamples = roundDoubleToInt (releaseTimeSecs * sourceSampleRate);
+ }
+}
+
+SamplerSound::~SamplerSound()
+{
+ delete data;
+ data = 0;
+}
+
+bool SamplerSound::appliesToNote (const int midiNoteNumber)
+{
+ return midiNotes [midiNoteNumber];
+}
+
+bool SamplerSound::appliesToChannel (const int /*midiChannel*/)
+{
+ return true;
+}
+
+SamplerVoice::SamplerVoice()
+ : pitchRatio (0.0),
+ sourceSamplePosition (0.0),
+ lgain (0.0f),
+ rgain (0.0f),
+ isInAttack (false),
+ isInRelease (false)
+{
+}
+
+SamplerVoice::~SamplerVoice()
+{
+}
+
+bool SamplerVoice::canPlaySound (SynthesiserSound* sound)
+{
+ return dynamic_cast (sound) != 0;
+}
+
+void SamplerVoice::startNote (const int midiNoteNumber,
+ const float velocity,
+ SynthesiserSound* s,
+ const int /*currentPitchWheelPosition*/)
+{
+ const SamplerSound* const sound = dynamic_cast (s);
+ jassert (sound != 0); // this object can only play SamplerSounds!
+
+ if (sound != 0)
+ {
+ const double targetFreq = MidiMessage::getMidiNoteInHertz (midiNoteNumber);
+ const double naturalFreq = MidiMessage::getMidiNoteInHertz (sound->midiRootNote);
+
+ pitchRatio = (targetFreq * sound->sourceSampleRate) / (naturalFreq * getSampleRate());
+
+ sourceSamplePosition = 0.0;
+ lgain = velocity;
+ rgain = velocity;
+
+ isInAttack = (sound->attackSamples > 0);
+ isInRelease = false;
+
+ if (isInAttack)
+ {
+ attackReleaseLevel = 0.0f;
+ attackDelta = (float) (pitchRatio / sound->attackSamples);
+ }
+ else
+ {
+ attackReleaseLevel = 1.0f;
+ attackDelta = 0.0f;
+ }
+
+ if (sound->releaseSamples > 0)
+ {
+ releaseDelta = (float) (-pitchRatio / sound->releaseSamples);
+ }
+ else
+ {
+ releaseDelta = 0.0f;
+ }
+ }
+}
+
+void SamplerVoice::stopNote (const bool allowTailOff)
+{
+ if (allowTailOff)
+ {
+ isInAttack = false;
+ isInRelease = true;
+ }
+ else
+ {
+ clearCurrentNote();
+ }
+}
+
+void SamplerVoice::pitchWheelMoved (const int /*newValue*/)
+{
+}
+
+void SamplerVoice::controllerMoved (const int /*controllerNumber*/,
+ const int /*newValue*/)
+{
+}
+
+void SamplerVoice::renderNextBlock (AudioSampleBuffer& outputBuffer, int startSample, int numSamples)
+{
+ const SamplerSound* const playingSound = (SamplerSound*) (SynthesiserSound*) getCurrentlyPlayingSound();
+
+ if (playingSound != 0)
+ {
+ const float* const inL = playingSound->data->getSampleData (0, 0);
+ const float* const inR = playingSound->data->getNumChannels() > 1
+ ? playingSound->data->getSampleData (1, 0) : 0;
+
+ float* outL = outputBuffer.getSampleData (0, startSample);
+ float* outR = outputBuffer.getNumChannels() > 1 ? outputBuffer.getSampleData (1, startSample) : 0;
+
+ while (--numSamples >= 0)
+ {
+ const int pos = (int) sourceSamplePosition;
+ const float alpha = (float) (sourceSamplePosition - pos);
+ const float invAlpha = 1.0f - alpha;
+
+ // just using a very simple linear interpolation here..
+ float l = (inL [pos] * invAlpha + inL [pos + 1] * alpha);
+ float r = (inR != 0) ? (inR [pos] * invAlpha + inR [pos + 1] * alpha)
+ : l;
+
+ l *= lgain;
+ r *= rgain;
+
+ if (isInAttack)
+ {
+ l *= attackReleaseLevel;
+ r *= attackReleaseLevel;
+
+ attackReleaseLevel += attackDelta;
+
+ if (attackReleaseLevel >= 1.0f)
+ {
+ attackReleaseLevel = 1.0f;
+ isInAttack = false;
+ }
+ }
+ else if (isInRelease)
+ {
+ l *= attackReleaseLevel;
+ r *= attackReleaseLevel;
+
+ attackReleaseLevel += releaseDelta;
+
+ if (attackReleaseLevel <= 0.0f)
+ {
+ stopNote (false);
+ break;
+ }
+ }
+
+ if (outR != 0)
+ {
+ *outL++ += l;
+ *outR++ += r;
+ }
+ else
+ {
+ *outL++ += (l + r) * 0.5f;
+ }
+
+ sourceSamplePosition += pitchRatio;
+
+ if (sourceSamplePosition > playingSound->length)
+ {
+ stopNote (false);
+ break;
+ }
+ }
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_Sampler.cpp *********/
+
+/********* Start of inlined file: juce_Synthesiser.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+SynthesiserSound::SynthesiserSound()
+{
+}
+
+SynthesiserSound::~SynthesiserSound()
+{
+}
+
+SynthesiserVoice::SynthesiserVoice()
+ : currentSampleRate (44100.0),
+ currentlyPlayingNote (-1),
+ noteOnTime (0),
+ currentlyPlayingSound (0)
+{
+}
+
+SynthesiserVoice::~SynthesiserVoice()
+{
+}
+
+bool SynthesiserVoice::isPlayingChannel (const int midiChannel) const
+{
+ return currentlyPlayingSound != 0
+ && currentlyPlayingSound->appliesToChannel (midiChannel);
+}
+
+void SynthesiserVoice::setCurrentPlaybackSampleRate (const double newRate)
+{
+ currentSampleRate = newRate;
+}
+
+void SynthesiserVoice::clearCurrentNote()
+{
+ currentlyPlayingNote = -1;
+ currentlyPlayingSound = 0;
+}
+
+Synthesiser::Synthesiser()
+ : voices (2),
+ sounds (2),
+ sampleRate (0),
+ lastNoteOnCounter (0),
+ shouldStealNotes (true)
+{
+ zeromem (lastPitchWheelValues, sizeof (lastPitchWheelValues));
+}
+
+Synthesiser::~Synthesiser()
+{
+}
+
+SynthesiserVoice* Synthesiser::getVoice (const int index) const throw()
+{
+ const ScopedLock sl (lock);
+ return voices [index];
+}
+
+void Synthesiser::clearVoices()
+{
+ const ScopedLock sl (lock);
+ voices.clear();
+}
+
+void Synthesiser::addVoice (SynthesiserVoice* const newVoice)
+{
+ const ScopedLock sl (lock);
+ voices.add (newVoice);
+}
+
+void Synthesiser::removeVoice (const int index)
+{
+ const ScopedLock sl (lock);
+ voices.remove (index);
+}
+
+void Synthesiser::clearSounds()
+{
+ const ScopedLock sl (lock);
+ sounds.clear();
+}
+
+void Synthesiser::addSound (const SynthesiserSound::Ptr& newSound)
+{
+ const ScopedLock sl (lock);
+ sounds.add (newSound);
+}
+
+void Synthesiser::removeSound (const int index)
+{
+ const ScopedLock sl (lock);
+ sounds.remove (index);
+}
+
+void Synthesiser::setNoteStealingEnabled (const bool shouldStealNotes_)
+{
+ shouldStealNotes = shouldStealNotes_;
+}
+
+void Synthesiser::setCurrentPlaybackSampleRate (const double newRate)
+{
+ if (sampleRate != newRate)
+ {
+ const ScopedLock sl (lock);
+
+ allNotesOff (0, false);
+
+ sampleRate = newRate;
+
+ for (int i = voices.size(); --i >= 0;)
+ voices.getUnchecked (i)->setCurrentPlaybackSampleRate (newRate);
+ }
+}
+
+void Synthesiser::renderNextBlock (AudioSampleBuffer& outputBuffer,
+ const MidiBuffer& midiData,
+ int startSample,
+ int numSamples)
+{
+ // must set the sample rate before using this!
+ jassert (sampleRate != 0);
+
+ const ScopedLock sl (lock);
+
+ MidiBuffer::Iterator midiIterator (midiData);
+ midiIterator.setNextSamplePosition (startSample);
+ MidiMessage m (0xf4, 0.0);
+
+ while (numSamples > 0)
+ {
+ int midiEventPos;
+ const bool useEvent = midiIterator.getNextEvent (m, midiEventPos)
+ && midiEventPos < startSample + numSamples;
+
+ const int numThisTime = useEvent ? midiEventPos - startSample
+ : numSamples;
+
+ if (numThisTime > 0)
+ {
+ for (int i = voices.size(); --i >= 0;)
+ voices.getUnchecked (i)->renderNextBlock (outputBuffer, startSample, numThisTime);
+ }
+
+ if (useEvent)
+ {
+ if (m.isNoteOn())
+ {
+ const int channel = m.getChannel();
+
+ noteOn (channel,
+ m.getNoteNumber(),
+ m.getFloatVelocity());
+ }
+ else if (m.isNoteOff())
+ {
+ noteOff (m.getChannel(),
+ m.getNoteNumber(),
+ true);
+ }
+ else if (m.isAllNotesOff() || m.isAllSoundOff())
+ {
+ allNotesOff (m.getChannel(), true);
+ }
+ else if (m.isPitchWheel())
+ {
+ const int channel = m.getChannel();
+ const int wheelPos = m.getPitchWheelValue();
+ lastPitchWheelValues [channel - 1] = wheelPos;
+
+ handlePitchWheel (channel, wheelPos);
+ }
+ else if (m.isController())
+ {
+ handleController (m.getChannel(),
+ m.getControllerNumber(),
+ m.getControllerValue());
+ }
+ }
+
+ startSample += numThisTime;
+ numSamples -= numThisTime;
+ }
+}
+
+void Synthesiser::noteOn (const int midiChannel,
+ const int midiNoteNumber,
+ const float velocity)
+{
+ const ScopedLock sl (lock);
+
+ for (int i = sounds.size(); --i >= 0;)
+ {
+ SynthesiserSound* const sound = sounds.getUnchecked(i);
+
+ if (sound->appliesToNote (midiNoteNumber)
+ && sound->appliesToChannel (midiChannel))
+ {
+ startVoice (findFreeVoice (sound, shouldStealNotes),
+ sound, midiChannel, midiNoteNumber, velocity);
+ }
+ }
+}
+
+void Synthesiser::startVoice (SynthesiserVoice* const voice,
+ SynthesiserSound* const sound,
+ const int midiChannel,
+ const int midiNoteNumber,
+ const float velocity)
+{
+ if (voice != 0 && sound != 0)
+ {
+ voice->startNote (midiNoteNumber,
+ velocity,
+ sound,
+ lastPitchWheelValues [midiChannel - 1]);
+
+ voice->currentlyPlayingNote = midiNoteNumber;
+ voice->noteOnTime = ++lastNoteOnCounter;
+ voice->currentlyPlayingSound = sound;
+ }
+}
+
+void Synthesiser::noteOff (const int midiChannel,
+ const int midiNoteNumber,
+ const bool allowTailOff)
+{
+ const ScopedLock sl (lock);
+
+ for (int i = voices.size(); --i >= 0;)
+ {
+ SynthesiserVoice* const voice = voices.getUnchecked (i);
+
+ if (voice->getCurrentlyPlayingNote() == midiNoteNumber)
+ {
+ SynthesiserSound* const sound = voice->getCurrentlyPlayingSound();
+
+ if (sound != 0
+ && sound->appliesToNote (midiNoteNumber)
+ && sound->appliesToChannel (midiChannel))
+ {
+ voice->stopNote (allowTailOff);
+
+ // the subclass MUST call clearCurrentNote() if it's not tailing off! RTFM for stopNote()!
+ jassert (allowTailOff || (voice->getCurrentlyPlayingNote() < 0 && voice->getCurrentlyPlayingSound() == 0));
+ }
+ }
+ }
+}
+
+void Synthesiser::allNotesOff (const int midiChannel,
+ const bool allowTailOff)
+{
+ const ScopedLock sl (lock);
+
+ for (int i = voices.size(); --i >= 0;)
+ {
+ SynthesiserVoice* const voice = voices.getUnchecked (i);
+
+ if (midiChannel <= 0 || voice->isPlayingChannel (midiChannel))
+ voice->stopNote (allowTailOff);
+ }
+}
+
+void Synthesiser::handlePitchWheel (const int midiChannel,
+ const int wheelValue)
+{
+ const ScopedLock sl (lock);
+
+ for (int i = voices.size(); --i >= 0;)
+ {
+ SynthesiserVoice* const voice = voices.getUnchecked (i);
+
+ if (midiChannel <= 0 || voice->isPlayingChannel (midiChannel))
+ {
+ voice->pitchWheelMoved (wheelValue);
+ }
+ }
+}
+
+void Synthesiser::handleController (const int midiChannel,
+ const int controllerNumber,
+ const int controllerValue)
+{
+ const ScopedLock sl (lock);
+
+ for (int i = voices.size(); --i >= 0;)
+ {
+ SynthesiserVoice* const voice = voices.getUnchecked (i);
+
+ if (midiChannel <= 0 || voice->isPlayingChannel (midiChannel))
+ voice->controllerMoved (controllerNumber, controllerValue);
+ }
+}
+
+SynthesiserVoice* Synthesiser::findFreeVoice (SynthesiserSound* soundToPlay,
+ const bool stealIfNoneAvailable) const
+{
+ const ScopedLock sl (lock);
+
+ for (int i = voices.size(); --i >= 0;)
+ if (voices.getUnchecked (i)->getCurrentlyPlayingNote() < 0
+ && voices.getUnchecked (i)->canPlaySound (soundToPlay))
+ return voices.getUnchecked (i);
+
+ if (stealIfNoneAvailable)
+ {
+ // currently this just steals the one that's been playing the longest, but could be made a bit smarter..
+ SynthesiserVoice* oldest = 0;
+
+ for (int i = voices.size(); --i >= 0;)
+ {
+ SynthesiserVoice* const voice = voices.getUnchecked (i);
+
+ if (voice->canPlaySound (soundToPlay)
+ && (oldest == 0 || oldest->noteOnTime > voice->noteOnTime))
+ oldest = voice;
+ }
+
+ jassert (oldest != 0);
+ return oldest;
+ }
+
+ return 0;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_Synthesiser.cpp *********/
+
+/********* Start of inlined file: juce_FileBasedDocument.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+FileBasedDocument::FileBasedDocument (const String& fileExtension_,
+ const String& fileWildcard_,
+ const String& openFileDialogTitle_,
+ const String& saveFileDialogTitle_)
+ : changedSinceSave (false),
+ fileExtension (fileExtension_),
+ fileWildcard (fileWildcard_),
+ openFileDialogTitle (openFileDialogTitle_),
+ saveFileDialogTitle (saveFileDialogTitle_)
+{
+}
+
+FileBasedDocument::~FileBasedDocument()
+{
+}
+
+void FileBasedDocument::setChangedFlag (const bool hasChanged)
+{
+ changedSinceSave = hasChanged;
+}
+
+void FileBasedDocument::changed()
+{
+ changedSinceSave = true;
+ sendChangeMessage (this);
+}
+
+void FileBasedDocument::setFile (const File& newFile)
+{
+ if (documentFile != newFile)
+ {
+ documentFile = newFile;
+ changedSinceSave = true;
+ }
+}
+
+bool FileBasedDocument::loadFrom (const File& newFile,
+ const bool showMessageOnFailure)
+{
+ MouseCursor::showWaitCursor();
+
+ const File oldFile (documentFile);
+ documentFile = newFile;
+
+ String error;
+
+ if (newFile.existsAsFile())
+ {
+ error = loadDocument (newFile);
+
+ if (error.isEmpty())
+ {
+ setChangedFlag (false);
+ MouseCursor::hideWaitCursor();
+
+ setLastDocumentOpened (newFile);
+ return true;
+ }
+ }
+ else
+ {
+ error = "The file doesn't exist";
+ }
+
+ documentFile = oldFile;
+ MouseCursor::hideWaitCursor();
+
+ if (showMessageOnFailure)
+ {
+ AlertWindow::showMessageBox (AlertWindow::WarningIcon,
+ TRANS("Failed to open file..."),
+ TRANS("There was an error while trying to load the file:\n\n")
+ + newFile.getFullPathName()
+ + T("\n\n")
+ + error);
+ }
+
+ return false;
+}
+
+bool FileBasedDocument::loadFromUserSpecifiedFile (const bool showMessageOnFailure)
+{
+ FileChooser fc (openFileDialogTitle,
+ getLastDocumentOpened(),
+ fileWildcard);
+
+ if (fc.browseForFileToOpen())
+ return loadFrom (fc.getResult(), showMessageOnFailure);
+
+ return false;
+}
+
+FileBasedDocument::SaveResult FileBasedDocument::save (const bool askUserForFileIfNotSpecified,
+ const bool showMessageOnFailure)
+{
+ return saveAs (documentFile,
+ false,
+ askUserForFileIfNotSpecified,
+ showMessageOnFailure);
+}
+
+FileBasedDocument::SaveResult FileBasedDocument::saveAs (const File& newFile,
+ const bool warnAboutOverwritingExistingFiles,
+ const bool askUserForFileIfNotSpecified,
+ const bool showMessageOnFailure)
+{
+ if (newFile == File::nonexistent)
+ {
+ if (askUserForFileIfNotSpecified)
+ {
+ return saveAsInteractive (true);
+ }
+ else
+ {
+ // can't save to an unspecified file
+ jassertfalse
+ return failedToWriteToFile;
+ }
+ }
+
+ if (warnAboutOverwritingExistingFiles && newFile.exists())
+ {
+ if (! AlertWindow::showOkCancelBox (AlertWindow::WarningIcon,
+ TRANS("File already exists"),
+ TRANS("There's already a file called:\n\n")
+ + newFile.getFullPathName()
+ + TRANS("\n\nAre you sure you want to overwrite it?"),
+ TRANS("overwrite"),
+ TRANS("cancel")))
+ {
+ return userCancelledSave;
+ }
+ }
+
+ MouseCursor::showWaitCursor();
+
+ const File oldFile (documentFile);
+ documentFile = newFile;
+
+ String error (saveDocument (newFile));
+
+ if (error.isEmpty())
+ {
+ setChangedFlag (false);
+ MouseCursor::hideWaitCursor();
+
+ return savedOk;
+ }
+
+ documentFile = oldFile;
+ MouseCursor::hideWaitCursor();
+
+ if (showMessageOnFailure)
+ {
+ AlertWindow::showMessageBox (AlertWindow::WarningIcon,
+ TRANS("Error writing to file..."),
+ TRANS("An error occurred while trying to save \"")
+ + getDocumentTitle()
+ + TRANS("\" to the file:\n\n")
+ + newFile.getFullPathName()
+ + T("\n\n")
+ + error);
+ }
+
+ return failedToWriteToFile;
+}
+
+FileBasedDocument::SaveResult FileBasedDocument::saveIfNeededAndUserAgrees()
+{
+ if (! hasChangedSinceSaved())
+ return savedOk;
+
+ const int r = AlertWindow::showYesNoCancelBox (AlertWindow::QuestionIcon,
+ TRANS("Closing document..."),
+ TRANS("Do you want to save the changes to \"")
+ + getDocumentTitle() + T("\"?"),
+ TRANS("save"),
+ TRANS("discard changes"),
+ TRANS("cancel"));
+
+ if (r == 1)
+ {
+ // save changes
+ return save (true, true);
+ }
+ else if (r == 2)
+ {
+ // discard changes
+ return savedOk;
+ }
+
+ return userCancelledSave;
+}
+
+FileBasedDocument::SaveResult FileBasedDocument::saveAsInteractive (const bool warnAboutOverwritingExistingFiles)
+{
+ File f;
+
+ if (documentFile.existsAsFile())
+ f = documentFile;
+ else
+ f = getLastDocumentOpened();
+
+ String legalFilename (File::createLegalFileName (getDocumentTitle()));
+
+ if (legalFilename.isEmpty())
+ legalFilename = "unnamed";
+
+ if (f.existsAsFile() || f.getParentDirectory().isDirectory())
+ f = f.getSiblingFile (legalFilename);
+ else
+ f = File::getSpecialLocation (File::userDocumentsDirectory).getChildFile (legalFilename);
+
+ f = f.withFileExtension (fileExtension)
+ .getNonexistentSibling (true);
+
+ FileChooser fc (saveFileDialogTitle, f, fileWildcard);
+
+ if (fc.browseForFileToSave (warnAboutOverwritingExistingFiles))
+ {
+ setLastDocumentOpened (fc.getResult());
+
+ File chosen (fc.getResult());
+ if (chosen.getFileExtension().isEmpty())
+ chosen = chosen.withFileExtension (fileExtension);
+
+ return saveAs (chosen, false, false, true);
+ }
+
+ return userCancelledSave;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_FileBasedDocument.cpp *********/
+
+/********* Start of inlined file: juce_RecentlyOpenedFilesList.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+RecentlyOpenedFilesList::RecentlyOpenedFilesList()
+ : maxNumberOfItems (10)
+{
+}
+
+RecentlyOpenedFilesList::~RecentlyOpenedFilesList()
+{
+}
+
+void RecentlyOpenedFilesList::setMaxNumberOfItems (const int newMaxNumber)
+{
+ maxNumberOfItems = jmax (1, newMaxNumber);
+
+ while (getNumFiles() > maxNumberOfItems)
+ files.remove (getNumFiles() - 1);
+}
+
+int RecentlyOpenedFilesList::getNumFiles() const
+{
+ return files.size();
+}
+
+const File RecentlyOpenedFilesList::getFile (const int index) const
+{
+ return File (files [index]);
+}
+
+void RecentlyOpenedFilesList::clear()
+{
+ files.clear();
+}
+
+void RecentlyOpenedFilesList::addFile (const File& file)
+{
+ const String path (file.getFullPathName());
+
+ files.removeString (path, true);
+ files.insert (0, path);
+
+ setMaxNumberOfItems (maxNumberOfItems);
+}
+
+void RecentlyOpenedFilesList::removeNonExistentFiles()
+{
+ for (int i = getNumFiles(); --i >= 0;)
+ if (! getFile(i).exists())
+ files.remove (i);
+}
+
+int RecentlyOpenedFilesList::createPopupMenuItems (PopupMenu& menuToAddTo,
+ const int baseItemId,
+ const bool showFullPaths,
+ const bool dontAddNonExistentFiles,
+ const File** filesToAvoid)
+{
+ int num = 0;
+
+ for (int i = 0; i < getNumFiles(); ++i)
+ {
+ const File f (getFile(i));
+
+ if ((! dontAddNonExistentFiles) || f.exists())
+ {
+ bool needsAvoiding = false;
+
+ if (filesToAvoid != 0)
+ {
+ const File** files = filesToAvoid;
+
+ while (*files != 0)
+ {
+ if (f == **files)
+ {
+ needsAvoiding = true;
+ break;
+ }
+
+ ++files;
+ }
+ }
+
+ if (! needsAvoiding)
+ {
+ menuToAddTo.addItem (baseItemId + i,
+ showFullPaths ? f.getFullPathName()
+ : f.getFileName());
+ ++num;
+ }
+ }
+ }
+
+ return num;
+}
+
+const String RecentlyOpenedFilesList::toString() const
+{
+ return files.joinIntoString (T("\n"));
+}
+
+void RecentlyOpenedFilesList::restoreFromString (const String& stringifiedVersion)
+{
+ clear();
+ files.addLines (stringifiedVersion);
+
+ setMaxNumberOfItems (maxNumberOfItems);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_RecentlyOpenedFilesList.cpp *********/
+
+/********* Start of inlined file: juce_UndoManager.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+UndoManager::UndoManager (const int maxNumberOfUnitsToKeep,
+ const int minimumTransactions)
+ : totalUnitsStored (0),
+ nextIndex (0),
+ newTransaction (true),
+ reentrancyCheck (false)
+{
+ setMaxNumberOfStoredUnits (maxNumberOfUnitsToKeep,
+ minimumTransactions);
+}
+
+UndoManager::~UndoManager()
+{
+ clearUndoHistory();
+}
+
+void UndoManager::clearUndoHistory()
+{
+ transactions.clear();
+ transactionNames.clear();
+ totalUnitsStored = 0;
+ nextIndex = 0;
+ sendChangeMessage (this);
+}
+
+int UndoManager::getNumberOfUnitsTakenUpByStoredCommands() const
+{
+ return totalUnitsStored;
+}
+
+void UndoManager::setMaxNumberOfStoredUnits (const int maxNumberOfUnitsToKeep,
+ const int minimumTransactions)
+{
+ maxNumUnitsToKeep = jmax (1, maxNumberOfUnitsToKeep);
+ minimumTransactionsToKeep = jmax (1, minimumTransactions);
+}
+
+bool UndoManager::perform (UndoableAction* const command, const String& actionName)
+{
+ if (command != 0)
+ {
+ if (actionName.isNotEmpty())
+ currentTransactionName = actionName;
+
+ if (reentrancyCheck)
+ {
+ jassertfalse // don't call perform() recursively from the UndoableAction::perform() or
+ // undo() methods, or else these actions won't actually get done.
+
+ return false;
+ }
+ else
+ {
+ bool success = false;
+
+ JUCE_TRY
+ {
+ success = command->perform();
+ }
+ JUCE_CATCH_EXCEPTION
+
+ jassert (success);
+ if (success)
+ {
+ if (nextIndex > 0 && ! newTransaction)
+ {
+ OwnedArray* commandSet = transactions [nextIndex - 1];
+
+ jassert (commandSet != 0);
+ if (commandSet == 0)
+ return false;
+
+ commandSet->add (command);
+ }
+ else
+ {
+ OwnedArray* commandSet = new OwnedArray();
+ commandSet->add (command);
+ transactions.insert (nextIndex, commandSet);
+ transactionNames.insert (nextIndex, currentTransactionName);
+ ++nextIndex;
+ }
+
+ totalUnitsStored += command->getSizeInUnits();
+ newTransaction = false;
+ }
+
+ while (nextIndex < transactions.size())
+ {
+ const OwnedArray * const lastSet = transactions.getLast();
+
+ for (int i = lastSet->size(); --i >= 0;)
+ totalUnitsStored -= lastSet->getUnchecked (i)->getSizeInUnits();
+
+ transactions.removeLast();
+ transactionNames.remove (transactionNames.size() - 1);
+ }
+
+ while (nextIndex > 0
+ && totalUnitsStored > maxNumUnitsToKeep
+ && transactions.size() > minimumTransactionsToKeep)
+ {
+ const OwnedArray * const firstSet = transactions.getFirst();
+
+ for (int i = firstSet->size(); --i >= 0;)
+ totalUnitsStored -= firstSet->getUnchecked (i)->getSizeInUnits();
+
+ jassert (totalUnitsStored >= 0); // something fishy going on if this fails!
+
+ transactions.remove (0);
+ transactionNames.remove (0);
+ --nextIndex;
+ }
+
+ sendChangeMessage (this);
+
+ return success;
+ }
+ }
+
+ return false;
+}
+
+void UndoManager::beginNewTransaction (const String& actionName)
+{
+ newTransaction = true;
+ currentTransactionName = actionName;
+}
+
+void UndoManager::setCurrentTransactionName (const String& newName)
+{
+ currentTransactionName = newName;
+}
+
+bool UndoManager::canUndo() const
+{
+ return nextIndex > 0;
+}
+
+bool UndoManager::canRedo() const
+{
+ return nextIndex < transactions.size();
+}
+
+const String UndoManager::getUndoDescription() const
+{
+ return transactionNames [nextIndex - 1];
+}
+
+const String UndoManager::getRedoDescription() const
+{
+ return transactionNames [nextIndex];
+}
+
+bool UndoManager::undo()
+{
+ const OwnedArray* const commandSet = transactions [nextIndex - 1];
+
+ if (commandSet == 0)
+ return false;
+
+ reentrancyCheck = true;
+ bool failed = false;
+
+ for (int i = commandSet->size(); --i >= 0;)
+ {
+ if (! commandSet->getUnchecked(i)->undo())
+ {
+ jassertfalse
+ failed = true;
+ break;
+ }
+ }
+
+ reentrancyCheck = false;
+
+ if (failed)
+ {
+ clearUndoHistory();
+ }
+ else
+ {
+ --nextIndex;
+ }
+
+ beginNewTransaction();
+
+ sendChangeMessage (this);
+ return true;
+}
+
+bool UndoManager::redo()
+{
+ const OwnedArray* const commandSet = transactions [nextIndex];
+
+ if (commandSet == 0)
+ return false;
+
+ reentrancyCheck = true;
+ bool failed = false;
+
+ for (int i = 0; i < commandSet->size(); ++i)
+ {
+ if (! commandSet->getUnchecked(i)->perform())
+ {
+ jassertfalse
+ failed = true;
+ break;
+ }
+ }
+
+ reentrancyCheck = false;
+
+ if (failed)
+ {
+ clearUndoHistory();
+ }
+ else
+ {
+ ++nextIndex;
+ }
+
+ beginNewTransaction();
+
+ sendChangeMessage (this);
+ return true;
+}
+
+bool UndoManager::undoCurrentTransactionOnly()
+{
+ return newTransaction ? false
+ : undo();
+}
+
+void UndoManager::getActionsInCurrentTransaction (Array & actionsFound) const
+{
+ const OwnedArray * const commandSet = transactions [nextIndex - 1];
+
+ if (commandSet != 0 && ! newTransaction)
+ {
+ for (int i = 0; i < commandSet->size(); ++i)
+ actionsFound.add (commandSet->getUnchecked(i));
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_UndoManager.cpp *********/
+
+/********* Start of inlined file: juce_ActionBroadcaster.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ActionBroadcaster::ActionBroadcaster() throw()
+{
+ // are you trying to create this object before or after juce has been intialised??
+ jassert (MessageManager::instance != 0);
+}
+
+ActionBroadcaster::~ActionBroadcaster()
+{
+ // all event-based objects must be deleted BEFORE juce is shut down!
+ jassert (MessageManager::instance != 0);
+}
+
+void ActionBroadcaster::addActionListener (ActionListener* const listener)
+{
+ actionListenerList.addActionListener (listener);
+}
+
+void ActionBroadcaster::removeActionListener (ActionListener* const listener)
+{
+ jassert (actionListenerList.isValidMessageListener());
+
+ if (actionListenerList.isValidMessageListener())
+ actionListenerList.removeActionListener (listener);
+}
+
+void ActionBroadcaster::removeAllActionListeners()
+{
+ actionListenerList.removeAllActionListeners();
+}
+
+void ActionBroadcaster::sendActionMessage (const String& message) const
+{
+ actionListenerList.sendActionMessage (message);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ActionBroadcaster.cpp *********/
+
+/********* Start of inlined file: juce_ActionListenerList.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+// special message of our own with a string in it
+class ActionMessage : public Message
+{
+public:
+ const String message;
+
+ ActionMessage (const String& messageText,
+ void* const listener_) throw()
+ : message (messageText)
+ {
+ pointerParameter = listener_;
+ }
+
+ ~ActionMessage() throw()
+ {
+ }
+
+private:
+ ActionMessage (const ActionMessage&);
+ const ActionMessage& operator= (const ActionMessage&);
+};
+
+ActionListenerList::ActionListenerList() throw()
+{
+}
+
+ActionListenerList::~ActionListenerList() throw()
+{
+}
+
+void ActionListenerList::addActionListener (ActionListener* const listener) throw()
+{
+ const ScopedLock sl (actionListenerLock_);
+
+ jassert (listener != 0);
+ jassert (! actionListeners_.contains (listener)); // trying to add a listener to the list twice!
+
+ if (listener != 0)
+ actionListeners_.add (listener);
+}
+
+void ActionListenerList::removeActionListener (ActionListener* const listener) throw()
+{
+ const ScopedLock sl (actionListenerLock_);
+
+ jassert (actionListeners_.contains (listener)); // trying to remove a listener that isn't on the list!
+
+ actionListeners_.removeValue (listener);
+}
+
+void ActionListenerList::removeAllActionListeners() throw()
+{
+ const ScopedLock sl (actionListenerLock_);
+ actionListeners_.clear();
+}
+
+void ActionListenerList::sendActionMessage (const String& message) const
+{
+ const ScopedLock sl (actionListenerLock_);
+
+ for (int i = actionListeners_.size(); --i >= 0;)
+ {
+ postMessage (new ActionMessage (message,
+ (ActionListener*) actionListeners_.getUnchecked(i)));
+ }
+}
+
+void ActionListenerList::handleMessage (const Message& message)
+{
+ const ActionMessage& am = (const ActionMessage&) message;
+
+ if (actionListeners_.contains (am.pointerParameter))
+ ((ActionListener*) am.pointerParameter)->actionListenerCallback (am.message);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ActionListenerList.cpp *********/
+
+/********* Start of inlined file: juce_AsyncUpdater.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+AsyncUpdater::AsyncUpdater() throw()
+ : asyncMessagePending (false)
+{
+ internalAsyncHandler.owner = this;
+}
+
+AsyncUpdater::~AsyncUpdater()
+{
+}
+
+void AsyncUpdater::triggerAsyncUpdate() throw()
+{
+ if (! asyncMessagePending)
+ {
+ asyncMessagePending = true;
+ internalAsyncHandler.postMessage (new Message());
+ }
+}
+
+void AsyncUpdater::cancelPendingUpdate() throw()
+{
+ asyncMessagePending = false;
+}
+
+void AsyncUpdater::handleUpdateNowIfNeeded()
+{
+ if (asyncMessagePending)
+ {
+ asyncMessagePending = false;
+ handleAsyncUpdate();
+ }
+}
+
+void AsyncUpdater::AsyncUpdaterInternal::handleMessage (const Message&)
+{
+ owner->handleUpdateNowIfNeeded();
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_AsyncUpdater.cpp *********/
+
+/********* Start of inlined file: juce_ChangeBroadcaster.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ChangeBroadcaster::ChangeBroadcaster() throw()
+{
+ // are you trying to create this object before or after juce has been intialised??
+ jassert (MessageManager::instance != 0);
+}
+
+ChangeBroadcaster::~ChangeBroadcaster()
+{
+ // all event-based objects must be deleted BEFORE juce is shut down!
+ jassert (MessageManager::instance != 0);
+}
+
+void ChangeBroadcaster::addChangeListener (ChangeListener* const listener) throw()
+{
+ changeListenerList.addChangeListener (listener);
+}
+
+void ChangeBroadcaster::removeChangeListener (ChangeListener* const listener) throw()
+{
+ jassert (changeListenerList.isValidMessageListener());
+
+ if (changeListenerList.isValidMessageListener())
+ changeListenerList.removeChangeListener (listener);
+}
+
+void ChangeBroadcaster::removeAllChangeListeners() throw()
+{
+ changeListenerList.removeAllChangeListeners();
+}
+
+void ChangeBroadcaster::sendChangeMessage (void* objectThatHasChanged) throw()
+{
+ changeListenerList.sendChangeMessage (objectThatHasChanged);
+}
+
+void ChangeBroadcaster::sendSynchronousChangeMessage (void* objectThatHasChanged)
+{
+ changeListenerList.sendSynchronousChangeMessage (objectThatHasChanged);
+}
+
+void ChangeBroadcaster::dispatchPendingMessages()
+{
+ changeListenerList.dispatchPendingMessages();
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ChangeBroadcaster.cpp *********/
+
+/********* Start of inlined file: juce_ChangeListenerList.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ChangeListenerList::ChangeListenerList() throw()
+ : lastChangedObject (0),
+ messagePending (false)
+{
+}
+
+ChangeListenerList::~ChangeListenerList() throw()
+{
+}
+
+void ChangeListenerList::addChangeListener (ChangeListener* const listener) throw()
+{
+ const ScopedLock sl (lock);
+
+ jassert (listener != 0);
+
+ if (listener != 0)
+ listeners.add (listener);
+}
+
+void ChangeListenerList::removeChangeListener (ChangeListener* const listener) throw()
+{
+ const ScopedLock sl (lock);
+ listeners.removeValue (listener);
+}
+
+void ChangeListenerList::removeAllChangeListeners() throw()
+{
+ const ScopedLock sl (lock);
+ listeners.clear();
+}
+
+void ChangeListenerList::sendChangeMessage (void* const objectThatHasChanged) throw()
+{
+ const ScopedLock sl (lock);
+
+ if ((! messagePending) && (listeners.size() > 0))
+ {
+ lastChangedObject = objectThatHasChanged;
+ postMessage (new Message (0, 0, 0, objectThatHasChanged));
+ messagePending = true;
+ }
+}
+
+void ChangeListenerList::handleMessage (const Message& message)
+{
+ sendSynchronousChangeMessage (message.pointerParameter);
+}
+
+void ChangeListenerList::sendSynchronousChangeMessage (void* const objectThatHasChanged)
+{
+ const ScopedLock sl (lock);
+ messagePending = false;
+
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ ChangeListener* const l = (ChangeListener*) listeners.getUnchecked (i);
+
+ {
+ const ScopedUnlock tempUnlocker (lock);
+ l->changeListenerCallback (objectThatHasChanged);
+ }
+
+ i = jmin (i, listeners.size());
+ }
+}
+
+void ChangeListenerList::dispatchPendingMessages()
+{
+ if (messagePending)
+ sendSynchronousChangeMessage (lastChangedObject);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ChangeListenerList.cpp *********/
+
+/********* Start of inlined file: juce_InterprocessConnection.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+InterprocessConnection::InterprocessConnection (const bool callbacksOnMessageThread,
+ const uint32 magicMessageHeaderNumber)
+ : Thread ("Juce IPC connection"),
+ socket (0),
+ pipe (0),
+ callbackConnectionState (false),
+ useMessageThread (callbacksOnMessageThread),
+ magicMessageHeader (magicMessageHeaderNumber),
+ pipeReceiveMessageTimeout (-1)
+{
+}
+
+InterprocessConnection::~InterprocessConnection()
+{
+ callbackConnectionState = false;
+ disconnect();
+}
+
+bool InterprocessConnection::connectToSocket (const String& hostName,
+ const int portNumber,
+ const int timeOutMillisecs)
+{
+ disconnect();
+
+ const ScopedLock sl (pipeAndSocketLock);
+ socket = new StreamingSocket();
+
+ if (socket->connect (hostName, portNumber, timeOutMillisecs))
+ {
+ connectionMadeInt();
+ startThread();
+ return true;
+ }
+ else
+ {
+ deleteAndZero (socket);
+ return false;
+ }
+}
+
+bool InterprocessConnection::connectToPipe (const String& pipeName,
+ const int pipeReceiveMessageTimeoutMs)
+{
+ disconnect();
+
+ NamedPipe* const newPipe = new NamedPipe();
+
+ if (newPipe->openExisting (pipeName))
+ {
+ const ScopedLock sl (pipeAndSocketLock);
+ pipeReceiveMessageTimeout = pipeReceiveMessageTimeoutMs;
+ initialiseWithPipe (newPipe);
+ return true;
+ }
+ else
+ {
+ delete newPipe;
+ return false;
+ }
+}
+
+bool InterprocessConnection::createPipe (const String& pipeName,
+ const int pipeReceiveMessageTimeoutMs)
+{
+ disconnect();
+
+ NamedPipe* const newPipe = new NamedPipe();
+
+ if (newPipe->createNewPipe (pipeName))
+ {
+ const ScopedLock sl (pipeAndSocketLock);
+ pipeReceiveMessageTimeout = pipeReceiveMessageTimeoutMs;
+ initialiseWithPipe (newPipe);
+ return true;
+ }
+ else
+ {
+ delete newPipe;
+ return false;
+ }
+}
+
+void InterprocessConnection::disconnect()
+{
+ if (socket != 0)
+ socket->close();
+
+ if (pipe != 0)
+ {
+ pipe->cancelPendingReads();
+ pipe->close();
+ }
+
+ stopThread (4000);
+
+ {
+ const ScopedLock sl (pipeAndSocketLock);
+ deleteAndZero (socket);
+ deleteAndZero (pipe);
+ }
+
+ connectionLostInt();
+}
+
+bool InterprocessConnection::isConnected() const
+{
+ const ScopedLock sl (pipeAndSocketLock);
+
+ return ((socket != 0 && socket->isConnected())
+ || (pipe != 0 && pipe->isOpen()))
+ && isThreadRunning();
+}
+
+const String InterprocessConnection::getConnectedHostName() const
+{
+ if (pipe != 0)
+ {
+ return "localhost";
+ }
+ else if (socket != 0)
+ {
+ if (! socket->isLocal())
+ return socket->getHostName();
+
+ return "localhost";
+ }
+
+ return String::empty;
+}
+
+bool InterprocessConnection::sendMessage (const MemoryBlock& message)
+{
+ uint32 messageHeader[2];
+ messageHeader [0] = swapIfBigEndian (magicMessageHeader);
+ messageHeader [1] = swapIfBigEndian ((uint32) message.getSize());
+
+ MemoryBlock messageData (sizeof (messageHeader) + message.getSize());
+ messageData.copyFrom (messageHeader, 0, sizeof (messageHeader));
+ messageData.copyFrom (message.getData(), sizeof (messageHeader), message.getSize());
+
+ int bytesWritten = 0;
+
+ const ScopedLock sl (pipeAndSocketLock);
+
+ if (socket != 0)
+ {
+ bytesWritten = socket->write (messageData.getData(), messageData.getSize());
+ }
+ else if (pipe != 0)
+ {
+ bytesWritten = pipe->write (messageData.getData(), messageData.getSize());
+ }
+
+ if (bytesWritten < 0)
+ {
+ // error..
+ return false;
+ }
+
+ return (bytesWritten == messageData.getSize());
+}
+
+void InterprocessConnection::initialiseWithSocket (StreamingSocket* const socket_)
+{
+ jassert (socket == 0);
+ socket = socket_;
+ connectionMadeInt();
+ startThread();
+}
+
+void InterprocessConnection::initialiseWithPipe (NamedPipe* const pipe_)
+{
+ jassert (pipe == 0);
+ pipe = pipe_;
+ connectionMadeInt();
+ startThread();
+}
+
+const int messageMagicNumber = 0xb734128b;
+
+void InterprocessConnection::handleMessage (const Message& message)
+{
+ if (message.intParameter1 == messageMagicNumber)
+ {
+ switch (message.intParameter2)
+ {
+ case 0:
+ {
+ MemoryBlock* const data = (MemoryBlock*) message.pointerParameter;
+ messageReceived (*data);
+ delete data;
+ break;
+ }
+
+ case 1:
+ connectionMade();
+ break;
+
+ case 2:
+ connectionLost();
+ break;
+ }
+ }
+}
+
+void InterprocessConnection::connectionMadeInt()
+{
+ if (! callbackConnectionState)
+ {
+ callbackConnectionState = true;
+
+ if (useMessageThread)
+ postMessage (new Message (messageMagicNumber, 1, 0, 0));
+ else
+ connectionMade();
+ }
+}
+
+void InterprocessConnection::connectionLostInt()
+{
+ if (callbackConnectionState)
+ {
+ callbackConnectionState = false;
+
+ if (useMessageThread)
+ postMessage (new Message (messageMagicNumber, 2, 0, 0));
+ else
+ connectionLost();
+ }
+}
+
+void InterprocessConnection::deliverDataInt (const MemoryBlock& data)
+{
+ jassert (callbackConnectionState);
+
+ if (useMessageThread)
+ postMessage (new Message (messageMagicNumber, 0, 0, new MemoryBlock (data)));
+ else
+ messageReceived (data);
+}
+
+bool InterprocessConnection::readNextMessageInt()
+{
+ const int maximumMessageSize = 1024 * 1024 * 10; // sanity check
+
+ uint32 messageHeader[2];
+ const int bytes = (socket != 0) ? socket->read (messageHeader, sizeof (messageHeader))
+ : pipe->read (messageHeader, sizeof (messageHeader), pipeReceiveMessageTimeout);
+
+ if (bytes == sizeof (messageHeader)
+ && swapIfBigEndian (messageHeader[0]) == magicMessageHeader)
+ {
+ const int bytesInMessage = (int) swapIfBigEndian (messageHeader[1]);
+
+ if (bytesInMessage > 0 && bytesInMessage < maximumMessageSize)
+ {
+ MemoryBlock messageData (bytesInMessage, true);
+ int bytesRead = 0;
+
+ while (bytesRead < bytesInMessage)
+ {
+ if (threadShouldExit())
+ return false;
+
+ const int numThisTime = jmin (bytesInMessage, 65536);
+ const int bytesIn = (socket != 0) ? socket->read (((char*) messageData.getData()) + bytesRead, numThisTime)
+ : pipe->read (((char*) messageData.getData()) + bytesRead, numThisTime,
+ pipeReceiveMessageTimeout);
+
+ if (bytesIn <= 0)
+ break;
+
+ bytesRead += bytesIn;
+ }
+
+ if (bytesRead >= 0)
+ deliverDataInt (messageData);
+ }
+ }
+ else if (bytes < 0)
+ {
+ {
+ const ScopedLock sl (pipeAndSocketLock);
+ deleteAndZero (socket);
+ }
+
+ connectionLostInt();
+ return false;
+ }
+
+ return true;
+}
+
+void InterprocessConnection::run()
+{
+ while (! threadShouldExit())
+ {
+ if (socket != 0)
+ {
+ const int ready = socket->waitUntilReady (true, 0);
+
+ if (ready < 0)
+ {
+ {
+ const ScopedLock sl (pipeAndSocketLock);
+ deleteAndZero (socket);
+ }
+
+ connectionLostInt();
+ break;
+ }
+ else if (ready > 0)
+ {
+ if (! readNextMessageInt())
+ break;
+ }
+ else
+ {
+ Thread::sleep (2);
+ }
+ }
+ else if (pipe != 0)
+ {
+ if (! pipe->isOpen())
+ {
+ {
+ const ScopedLock sl (pipeAndSocketLock);
+ deleteAndZero (pipe);
+ }
+
+ connectionLostInt();
+ break;
+ }
+ else
+ {
+ if (! readNextMessageInt())
+ break;
+ }
+ }
+ else
+ {
+ break;
+ }
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_InterprocessConnection.cpp *********/
+
+/********* Start of inlined file: juce_InterprocessConnectionServer.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+InterprocessConnectionServer::InterprocessConnectionServer()
+ : Thread ("Juce IPC server"),
+ socket (0)
+{
+}
+
+InterprocessConnectionServer::~InterprocessConnectionServer()
+{
+ stop();
+}
+
+bool InterprocessConnectionServer::beginWaitingForSocket (const int portNumber)
+{
+ stop();
+
+ socket = new StreamingSocket();
+
+ if (socket->createListener (portNumber))
+ {
+ startThread();
+ return true;
+ }
+
+ deleteAndZero (socket);
+ return false;
+}
+
+void InterprocessConnectionServer::stop()
+{
+ signalThreadShouldExit();
+
+ if (socket != 0)
+ socket->close();
+
+ stopThread (4000);
+
+ deleteAndZero (socket);
+}
+
+void InterprocessConnectionServer::run()
+{
+ while ((! threadShouldExit()) && socket != 0)
+ {
+ StreamingSocket* const clientSocket = socket->waitForNextConnection();
+
+ if (clientSocket != 0)
+ {
+ InterprocessConnection* newConnection = createConnectionObject();
+
+ if (newConnection != 0)
+ {
+ newConnection->initialiseWithSocket (clientSocket);
+ }
+ else
+ {
+ delete clientSocket;
+ }
+ }
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_InterprocessConnectionServer.cpp *********/
+
+/********* Start of inlined file: juce_Message.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+Message::Message() throw()
+{
+}
+
+Message::~Message() throw()
+{
+}
+
+Message::Message (const int intParameter1_,
+ const int intParameter2_,
+ const int intParameter3_,
+ void* const pointerParameter_) throw()
+ : intParameter1 (intParameter1_),
+ intParameter2 (intParameter2_),
+ intParameter3 (intParameter3_),
+ pointerParameter (pointerParameter_)
+{
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_Message.cpp *********/
+
+/********* Start of inlined file: juce_MessageListener.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+MessageListener::MessageListener() throw()
+{
+ // are you trying to create a messagelistener before or after juce has been intialised??
+ jassert (MessageManager::instance != 0);
+
+ if (MessageManager::instance != 0)
+ MessageManager::instance->messageListeners.add (this);
+}
+
+MessageListener::~MessageListener()
+{
+ if (MessageManager::instance != 0)
+ MessageManager::instance->messageListeners.removeValue (this);
+}
+
+void MessageListener::postMessage (Message* const message) const throw()
+{
+ message->messageRecipient = const_cast (this);
+
+ if (MessageManager::instance == 0)
+ MessageManager::getInstance();
+
+ MessageManager::instance->postMessageToQueue (message);
+}
+
+bool MessageListener::isValidMessageListener() const throw()
+{
+ return (MessageManager::instance != 0)
+ && MessageManager::instance->messageListeners.contains (this);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_MessageListener.cpp *********/
+
+/********* Start of inlined file: juce_MessageManager.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+// platform-specific functions..
+bool juce_dispatchNextMessageOnSystemQueue (bool returnIfNoPendingMessages);
+bool juce_postMessageToSystemQueue (void* message);
+
+MessageManager* MessageManager::instance = 0;
+
+static const int quitMessageId = 0xfffff321;
+
+MessageManager::MessageManager() throw()
+ : broadcastListeners (0),
+ quitMessagePosted (false),
+ quitMessageReceived (false),
+ useMaximumForceWhenQuitting (true),
+ messageCounter (0),
+ lastMessageCounter (-1),
+ isInMessageDispatcher (0),
+ needToGetRidOfWaitCursor (false),
+ timeBeforeWaitCursor (0),
+ lastActivityCheckOkTime (0)
+{
+ currentLockingThreadId = messageThreadId = Thread::getCurrentThreadId();
+}
+
+MessageManager::~MessageManager() throw()
+{
+ jassert (instance == this);
+ instance = 0;
+ deleteAndZero (broadcastListeners);
+
+ doPlatformSpecificShutdown();
+}
+
+MessageManager* MessageManager::getInstance() throw()
+{
+ if (instance == 0)
+ {
+ instance = new MessageManager();
+ doPlatformSpecificInitialisation();
+
+ instance->setTimeBeforeShowingWaitCursor (500);
+ }
+
+ return instance;
+}
+
+void MessageManager::postMessageToQueue (Message* const message)
+{
+ if (quitMessagePosted || ! juce_postMessageToSystemQueue (message))
+ delete message;
+}
+
+// not for public use..
+void MessageManager::deliverMessage (void* message)
+{
+ const MessageManagerLock lock;
+
+ Message* const m = (Message*) message;
+ MessageListener* const recipient = m->messageRecipient;
+
+ if (messageListeners.contains (recipient))
+ {
+ JUCE_TRY
+ {
+ recipient->handleMessage (*m);
+ }
+ JUCE_CATCH_EXCEPTION
+
+ if (needToGetRidOfWaitCursor)
+ {
+ needToGetRidOfWaitCursor = false;
+ MouseCursor::hideWaitCursor();
+ }
+
+ ++messageCounter;
+ }
+ else if (recipient == 0 && m->intParameter1 == quitMessageId)
+ {
+ quitMessageReceived = true;
+ useMaximumForceWhenQuitting = (m->intParameter2 != 0);
+ }
+
+ delete m;
+}
+
+bool MessageManager::dispatchNextMessage (const bool returnImmediatelyIfNoMessages,
+ bool* const wasAMessageDispatched)
+{
+ if (quitMessageReceived)
+ {
+ if (wasAMessageDispatched != 0)
+ *wasAMessageDispatched = false;
+
+ return false;
+ }
+
+ ++isInMessageDispatcher;
+
+ bool result = false;
+
+ JUCE_TRY
+ {
+ result = juce_dispatchNextMessageOnSystemQueue (returnImmediatelyIfNoMessages);
+
+ if (wasAMessageDispatched != 0)
+ *wasAMessageDispatched = result;
+
+ if (instance == 0)
+ return false;
+ }
+ JUCE_CATCH_EXCEPTION
+
+ --isInMessageDispatcher;
+ ++messageCounter;
+
+ return result || ! returnImmediatelyIfNoMessages;
+}
+
+void MessageManager::dispatchPendingMessages (int maxNumberOfMessagesToDispatch)
+{
+ jassert (isThisTheMessageThread()); // must only be called by the message thread
+
+ while (--maxNumberOfMessagesToDispatch >= 0 && ! quitMessageReceived)
+ {
+ ++isInMessageDispatcher;
+
+ bool carryOn = false;
+
+ JUCE_TRY
+ {
+ carryOn = juce_dispatchNextMessageOnSystemQueue (true);
+ }
+ JUCE_CATCH_EXCEPTION
+
+ --isInMessageDispatcher;
+ ++messageCounter;
+
+ if (! carryOn)
+ break;
+ }
+}
+
+bool MessageManager::runDispatchLoop()
+{
+ jassert (isThisTheMessageThread()); // must only be called by the message thread
+
+ while (dispatchNextMessage())
+ {
+ }
+
+ return useMaximumForceWhenQuitting;
+}
+
+void MessageManager::postQuitMessage (const bool useMaximumForce)
+{
+ Message* const m = new Message (quitMessageId, (useMaximumForce) ? 1 : 0, 0, 0);
+ m->messageRecipient = 0;
+ postMessageToQueue (m);
+
+ quitMessagePosted = true;
+}
+
+bool MessageManager::hasQuitMessageBeenPosted() const throw()
+{
+ return quitMessagePosted;
+}
+
+void MessageManager::deliverBroadcastMessage (const String& value)
+{
+ if (broadcastListeners != 0)
+ broadcastListeners->sendActionMessage (value);
+}
+
+void MessageManager::registerBroadcastListener (ActionListener* const listener) throw()
+{
+ if (broadcastListeners == 0)
+ broadcastListeners = new ActionListenerList();
+
+ broadcastListeners->addActionListener (listener);
+}
+
+void MessageManager::deregisterBroadcastListener (ActionListener* const listener) throw()
+{
+ if (broadcastListeners != 0)
+ broadcastListeners->removeActionListener (listener);
+}
+
+// This gets called occasionally by the timer thread (to save using an extra thread
+// for it).
+void MessageManager::inactivityCheckCallback() throw()
+{
+ if (instance != 0)
+ instance->inactivityCheckCallbackInt();
+}
+
+void MessageManager::inactivityCheckCallbackInt() throw()
+{
+ const unsigned int now = Time::getApproximateMillisecondCounter();
+
+ if (isInMessageDispatcher > 0
+ && lastMessageCounter == messageCounter
+ && timeBeforeWaitCursor > 0
+ && lastActivityCheckOkTime > 0
+ && ! ModifierKeys::getCurrentModifiersRealtime().isAnyMouseButtonDown())
+ {
+ if (now >= lastActivityCheckOkTime + timeBeforeWaitCursor
+ && ! needToGetRidOfWaitCursor)
+ {
+ // been in the same message call too long..
+ MouseCursor::showWaitCursor();
+ needToGetRidOfWaitCursor = true;
+ }
+ }
+ else
+ {
+ lastActivityCheckOkTime = now;
+ lastMessageCounter = messageCounter;
+ }
+}
+
+void MessageManager::delayWaitCursor() throw()
+{
+ if (instance != 0)
+ {
+ instance->messageCounter++;
+
+ if (instance->needToGetRidOfWaitCursor)
+ {
+ instance->needToGetRidOfWaitCursor = false;
+ MouseCursor::hideWaitCursor();
+ }
+ }
+}
+
+void MessageManager::setTimeBeforeShowingWaitCursor (const int millisecs) throw()
+{
+ // if this is a bit too small you'll get a lot of unwanted hourglass cursors..
+ jassert (millisecs <= 0 || millisecs > 200);
+
+ timeBeforeWaitCursor = millisecs;
+
+ if (millisecs > 0)
+ startTimer (millisecs / 2); // (see timerCallback() for explanation of this)
+ else
+ stopTimer();
+}
+
+void MessageManager::timerCallback()
+{
+ // dummy callback - the message manager is just a Timer to ensure that there are always
+ // some events coming in - otherwise it'll show the egg-timer/beachball-of-death.
+ ++messageCounter;
+}
+
+int MessageManager::getTimeBeforeShowingWaitCursor() const throw()
+{
+ return timeBeforeWaitCursor;
+}
+
+bool MessageManager::isThisTheMessageThread() const throw()
+{
+ return Thread::getCurrentThreadId() == messageThreadId;
+}
+
+void MessageManager::setCurrentMessageThread (const int threadId) throw()
+{
+ messageThreadId = threadId;
+}
+
+bool MessageManager::currentThreadHasLockedMessageManager() const throw()
+{
+ return Thread::getCurrentThreadId() == currentLockingThreadId;
+}
+
+MessageManagerLock::MessageManagerLock() throw()
+ : locked (false)
+{
+ if (MessageManager::instance != 0)
+ {
+ MessageManager::instance->messageDispatchLock.enter();
+ lastLockingThreadId = MessageManager::instance->currentLockingThreadId;
+ MessageManager::instance->currentLockingThreadId = Thread::getCurrentThreadId();
+ locked = true;
+ }
+}
+
+MessageManagerLock::MessageManagerLock (Thread* const thread) throw()
+ : locked (false)
+{
+ jassert (thread != 0); // This will only work if you give it a valid thread!
+
+ if (MessageManager::instance != 0)
+ {
+ for (;;)
+ {
+ if (MessageManager::instance->messageDispatchLock.tryEnter())
+ {
+ locked = true;
+ lastLockingThreadId = MessageManager::instance->currentLockingThreadId;
+ MessageManager::instance->currentLockingThreadId = Thread::getCurrentThreadId();
+ break;
+ }
+
+ if (thread != 0 && thread->threadShouldExit())
+ break;
+
+ Thread::sleep (1);
+ }
+ }
+}
+
+MessageManagerLock::~MessageManagerLock() throw()
+{
+ if (locked && MessageManager::instance != 0)
+ {
+ MessageManager::instance->currentLockingThreadId = lastLockingThreadId;
+ MessageManager::instance->messageDispatchLock.exit();
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_MessageManager.cpp *********/
+
+/********* Start of inlined file: juce_MultiTimer.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+class InternalMultiTimerCallback : public Timer
+{
+public:
+ InternalMultiTimerCallback (const int timerId_, MultiTimer& owner_)
+ : timerId (timerId_),
+ owner (owner_)
+ {
+ }
+
+ ~InternalMultiTimerCallback()
+ {
+ }
+
+ void timerCallback()
+ {
+ owner.timerCallback (timerId);
+ }
+
+ const int timerId;
+
+private:
+ MultiTimer& owner;
+};
+
+MultiTimer::MultiTimer() throw()
+{
+}
+
+MultiTimer::MultiTimer (const MultiTimer&) throw()
+{
+}
+
+MultiTimer::~MultiTimer()
+{
+ const ScopedLock sl (timerListLock);
+
+ for (int i = timers.size(); --i >= 0;)
+ delete (InternalMultiTimerCallback*) timers.getUnchecked(i);
+
+ timers.clear();
+}
+
+void MultiTimer::startTimer (const int timerId, const int intervalInMilliseconds) throw()
+{
+ const ScopedLock sl (timerListLock);
+
+ for (int i = timers.size(); --i >= 0;)
+ {
+ InternalMultiTimerCallback* const t = (InternalMultiTimerCallback*) timers.getUnchecked(i);
+
+ if (t->timerId == timerId)
+ {
+ t->startTimer (intervalInMilliseconds);
+ return;
+ }
+ }
+
+ InternalMultiTimerCallback* const newTimer = new InternalMultiTimerCallback (timerId, *this);
+ timers.add (newTimer);
+ newTimer->startTimer (intervalInMilliseconds);
+}
+
+void MultiTimer::stopTimer (const int timerId) throw()
+{
+ const ScopedLock sl (timerListLock);
+
+ for (int i = timers.size(); --i >= 0;)
+ {
+ InternalMultiTimerCallback* const t = (InternalMultiTimerCallback*) timers.getUnchecked(i);
+
+ if (t->timerId == timerId)
+ t->stopTimer();
+ }
+}
+
+bool MultiTimer::isTimerRunning (const int timerId) const throw()
+{
+ const ScopedLock sl (timerListLock);
+
+ for (int i = timers.size(); --i >= 0;)
+ {
+ const InternalMultiTimerCallback* const t = (InternalMultiTimerCallback*) timers.getUnchecked(i);
+ if (t->timerId == timerId)
+ return t->isTimerRunning();
+ }
+
+ return false;
+}
+
+int MultiTimer::getTimerInterval (const int timerId) const throw()
+{
+ const ScopedLock sl (timerListLock);
+
+ for (int i = timers.size(); --i >= 0;)
+ {
+ const InternalMultiTimerCallback* const t = (InternalMultiTimerCallback*) timers.getUnchecked(i);
+ if (t->timerId == timerId)
+ return t->getTimerInterval();
+ }
+
+ return 0;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_MultiTimer.cpp *********/
+
+/********* Start of inlined file: juce_Timer.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+class InternalTimerThread : private Thread,
+ private MessageListener,
+ private DeletedAtShutdown,
+ private AsyncUpdater
+{
+private:
+ friend class Timer;
+ static InternalTimerThread* instance;
+ static CriticalSection lock;
+
+ Timer* volatile firstTimer;
+ bool volatile callbackNeeded;
+
+ InternalTimerThread (const InternalTimerThread&);
+ const InternalTimerThread& operator= (const InternalTimerThread&);
+
+ void addTimer (Timer* const t) throw()
+ {
+#ifdef JUCE_DEBUG
+ Timer* tt = firstTimer;
+
+ while (tt != 0)
+ {
+ // trying to add a timer that's already here - shouldn't get to this point,
+ // so if you get this assertion, let me know!
+ jassert (tt != t);
+
+ tt = tt->next;
+ }
+
+ jassert (t->previous == 0 && t->next == 0);
+#endif
+
+ Timer* i = firstTimer;
+
+ if (i == 0 || i->countdownMs > t->countdownMs)
+ {
+ t->next = firstTimer;
+ firstTimer = t;
+ }
+ else
+ {
+ while (i->next != 0 && i->next->countdownMs <= t->countdownMs)
+ i = i->next;
+
+ jassert (i != 0);
+
+ t->next = i->next;
+ t->previous = i;
+ i->next = t;
+ }
+
+ if (t->next != 0)
+ t->next->previous = t;
+
+ jassert ((t->next == 0 || t->next->countdownMs >= t->countdownMs)
+ && (t->previous == 0 || t->previous->countdownMs <= t->countdownMs));
+
+ notify();
+ }
+
+ void removeTimer (Timer* const t) throw()
+ {
+#ifdef JUCE_DEBUG
+ Timer* tt = firstTimer;
+ bool found = false;
+
+ while (tt != 0)
+ {
+ if (tt == t)
+ {
+ found = true;
+ break;
+ }
+
+ tt = tt->next;
+ }
+
+ // trying to remove a timer that's not here - shouldn't get to this point,
+ // so if you get this assertion, let me know!
+ jassert (found);
+#endif
+
+ if (t->previous != 0)
+ {
+ jassert (firstTimer != t);
+ t->previous->next = t->next;
+ }
+ else
+ {
+ jassert (firstTimer == t);
+ firstTimer = t->next;
+ }
+
+ if (t->next != 0)
+ t->next->previous = t->previous;
+
+ t->next = 0;
+ t->previous = 0;
+ }
+
+ void decrementAllCounters (const int numMillisecs) const
+ {
+ Timer* t = firstTimer;
+
+ while (t != 0)
+ {
+ t->countdownMs -= numMillisecs;
+ t = t->next;
+ }
+ }
+
+ void handleAsyncUpdate()
+ {
+ startThread (7);
+ }
+
+public:
+ InternalTimerThread()
+ : Thread ("Juce Timer"),
+ firstTimer (0),
+ callbackNeeded (false)
+ {
+ triggerAsyncUpdate();
+ }
+
+ ~InternalTimerThread() throw()
+ {
+ stopThread (4000);
+
+ jassert (instance == this || instance == 0);
+ if (instance == this)
+ instance = 0;
+ }
+
+ void run()
+ {
+ uint32 lastTime = Time::getMillisecondCounter();
+ uint32 lastMessageManagerCallback = lastTime;
+
+ while (! threadShouldExit())
+ {
+ uint32 now = Time::getMillisecondCounter();
+
+ if (now <= lastTime)
+ {
+ wait (2);
+ continue;
+ }
+
+ const int elapsed = now - lastTime;
+ lastTime = now;
+
+ lock.enter();
+ decrementAllCounters (elapsed);
+ const int timeUntilFirstTimer = (firstTimer != 0) ? firstTimer->countdownMs
+ : 1000;
+ lock.exit();
+
+ if (timeUntilFirstTimer <= 0)
+ {
+ callbackNeeded = true;
+ postMessage (new Message());
+
+ // sometimes, our message could get discarded by the OS (particularly when running as an RTAS when the app has a modal loop),
+ // so this is how long to wait before assuming the message has been lost and trying again.
+ const uint32 messageDeliveryTimeout = now + 2000;
+
+ while (callbackNeeded)
+ {
+ wait (4);
+
+ if (threadShouldExit())
+ return;
+
+ now = Time::getMillisecondCounter();
+
+ if (now > lastMessageManagerCallback + 200)
+ {
+ lastMessageManagerCallback = now;
+ MessageManager::inactivityCheckCallback();
+ }
+
+ if (now > messageDeliveryTimeout)
+ break;
+ }
+ }
+ else
+ {
+ // don't wait for too long because running this loop also helps keep the
+ // Time::getApproximateMillisecondTimer value stay up-to-date
+ wait (jlimit (1, 50, timeUntilFirstTimer));
+ }
+
+ if (now > lastMessageManagerCallback + 200)
+ {
+ lastMessageManagerCallback = now;
+ MessageManager::inactivityCheckCallback();
+ }
+ }
+ }
+
+ void handleMessage (const Message&)
+ {
+ const ScopedLock sl (lock);
+
+ while (firstTimer != 0 && firstTimer->countdownMs <= 0)
+ {
+ Timer* const t = firstTimer;
+ t->countdownMs = t->periodMs;
+
+ removeTimer (t);
+ addTimer (t);
+
+ const ScopedUnlock ul (lock);
+ callbackNeeded = false;
+
+ JUCE_TRY
+ {
+ t->timerCallback();
+ }
+ JUCE_CATCH_EXCEPTION
+ }
+
+ callbackNeeded = false;
+ }
+
+ static void callAnyTimersSynchronously()
+ {
+ if (InternalTimerThread::instance != 0)
+ {
+ const Message m;
+ InternalTimerThread::instance->handleMessage (m);
+ }
+ }
+
+ static inline void add (Timer* const tim) throw()
+ {
+ if (instance == 0)
+ instance = new InternalTimerThread();
+
+ instance->addTimer (tim);
+ }
+
+ static inline void remove (Timer* const tim) throw()
+ {
+ if (instance != 0)
+ instance->removeTimer (tim);
+ }
+
+ static inline void resetCounter (Timer* const tim,
+ const int newCounter) throw()
+ {
+ if (instance != 0)
+ {
+ tim->countdownMs = newCounter;
+ tim->periodMs = newCounter;
+
+ if ((tim->next != 0 && tim->next->countdownMs < tim->countdownMs)
+ || (tim->previous != 0 && tim->previous->countdownMs > tim->countdownMs))
+ {
+ instance->removeTimer (tim);
+ instance->addTimer (tim);
+ }
+ }
+ }
+};
+
+InternalTimerThread* InternalTimerThread::instance = 0;
+CriticalSection InternalTimerThread::lock;
+
+void juce_callAnyTimersSynchronously()
+{
+ InternalTimerThread::callAnyTimersSynchronously();
+}
+
+#ifdef JUCE_DEBUG
+static SortedSet activeTimers;
+#endif
+
+Timer::Timer() throw()
+ : countdownMs (0),
+ periodMs (0),
+ previous (0),
+ next (0)
+{
+#ifdef JUCE_DEBUG
+ activeTimers.add (this);
+#endif
+}
+
+Timer::Timer (const Timer&) throw()
+ : countdownMs (0),
+ periodMs (0),
+ previous (0),
+ next (0)
+{
+#ifdef JUCE_DEBUG
+ activeTimers.add (this);
+#endif
+}
+
+Timer::~Timer()
+{
+ stopTimer();
+
+#ifdef JUCE_DEBUG
+ activeTimers.removeValue (this);
+#endif
+}
+
+void Timer::startTimer (const int interval) throw()
+{
+ const ScopedLock sl (InternalTimerThread::lock);
+
+#ifdef JUCE_DEBUG
+ // this isn't a valid object! Your timer might be a dangling pointer or something..
+ jassert (activeTimers.contains (this));
+#endif
+
+ if (periodMs == 0)
+ {
+ countdownMs = interval;
+ periodMs = jmax (1, interval);
+ InternalTimerThread::add (this);
+ }
+ else
+ {
+ InternalTimerThread::resetCounter (this, interval);
+ }
+}
+
+void Timer::stopTimer() throw()
+{
+ const ScopedLock sl (InternalTimerThread::lock);
+
+#ifdef JUCE_DEBUG
+ // this isn't a valid object! Your timer might be a dangling pointer or something..
+ jassert (activeTimers.contains (this));
+#endif
+
+ if (periodMs > 0)
+ {
+ InternalTimerThread::remove (this);
+ periodMs = 0;
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_Timer.cpp *********/
+
+/********* Start of inlined file: juce_Component.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+Component* Component::componentUnderMouse = 0;
+Component* Component::currentlyFocusedComponent = 0;
+
+static Array modalComponentStack (4), modalComponentReturnValueKeys (4);
+static Array modalReturnValues (4);
+
+static const int customCommandMessage = 0x7fff0001;
+static const int exitModalStateMessage = 0x7fff0002;
+
+// these are also used by ComponentPeer
+int64 juce_recentMouseDownTimes [4] = { 0, 0, 0, 0 };
+int juce_recentMouseDownX [4] = { 0, 0, 0, 0 };
+int juce_recentMouseDownY [4] = { 0, 0, 0, 0 };
+Component* juce_recentMouseDownComponent [4] = { 0, 0, 0, 0 };
+int juce_LastMousePosX = 0;
+int juce_LastMousePosY = 0;
+int juce_MouseClickCounter = 0;
+bool juce_MouseHasMovedSignificantlySincePressed = false;
+
+static int countMouseClicks() throw()
+{
+ int numClicks = 0;
+
+ if (juce_recentMouseDownTimes[0] != 0)
+ {
+ if (! juce_MouseHasMovedSignificantlySincePressed)
+ ++numClicks;
+
+ for (int i = 1; i < numElementsInArray (juce_recentMouseDownTimes); ++i)
+ {
+ if (juce_recentMouseDownTimes[0] - juce_recentMouseDownTimes [i]
+ < (int) (MouseEvent::getDoubleClickTimeout() * (1.0 + 0.25 * (i - 1)))
+ && abs (juce_recentMouseDownX[0] - juce_recentMouseDownX[i]) < 8
+ && abs (juce_recentMouseDownY[0] - juce_recentMouseDownY[i]) < 8
+ && juce_recentMouseDownComponent[0] == juce_recentMouseDownComponent [i])
+ {
+ ++numClicks;
+ }
+ else
+ {
+ break;
+ }
+ }
+ }
+
+ return numClicks;
+}
+
+static int unboundedMouseOffsetX = 0;
+static int unboundedMouseOffsetY = 0;
+static bool isUnboundedMouseModeOn = false;
+static bool isCursorVisibleUntilOffscreen;
+
+#define checkMessageManagerIsLocked jassert (MessageManager::getInstance()->currentThreadHasLockedMessageManager());
+
+static uint32 nextComponentUID = 0;
+
+Component::Component() throw()
+ : parentComponent_ (0),
+ componentUID (++nextComponentUID),
+ numDeepMouseListeners (0),
+ childComponentList_ (16),
+ lookAndFeel_ (0),
+ effect_ (0),
+ bufferedImage_ (0),
+ mouseListeners_ (0),
+ keyListeners_ (0),
+ componentListeners_ (0),
+ propertySet_ (0),
+ componentFlags_ (0)
+{
+}
+
+Component::Component (const String& name) throw()
+ : componentName_ (name),
+ parentComponent_ (0),
+ componentUID (++nextComponentUID),
+ numDeepMouseListeners (0),
+ childComponentList_ (16),
+ lookAndFeel_ (0),
+ effect_ (0),
+ bufferedImage_ (0),
+ mouseListeners_ (0),
+ keyListeners_ (0),
+ componentListeners_ (0),
+ propertySet_ (0),
+ componentFlags_ (0)
+{
+}
+
+Component::~Component()
+{
+ if (parentComponent_ != 0)
+ {
+ parentComponent_->removeChildComponent (this);
+ }
+ else if ((currentlyFocusedComponent == this)
+ || isParentOf (currentlyFocusedComponent))
+ {
+ giveAwayFocus();
+ }
+
+ if (componentUnderMouse == this)
+ componentUnderMouse = 0;
+
+ if (flags.hasHeavyweightPeerFlag)
+ removeFromDesktop();
+
+ modalComponentStack.removeValue (this);
+
+ for (int i = childComponentList_.size(); --i >= 0;)
+ childComponentList_.getUnchecked(i)->parentComponent_ = 0;
+
+ delete bufferedImage_;
+ delete mouseListeners_;
+ delete keyListeners_;
+ delete componentListeners_;
+ delete propertySet_;
+}
+
+void Component::setName (const String& name)
+{
+ // if component methods are being called from threads other than the message
+ // thread, you'll need to use a MessageManagerLock object to make sure it's thread-safe.
+ checkMessageManagerIsLocked
+
+ if (componentName_ != name)
+ {
+ componentName_ = name;
+
+ if (flags.hasHeavyweightPeerFlag)
+ {
+ ComponentPeer* const peer = getPeer();
+
+ jassert (peer != 0);
+ if (peer != 0)
+ peer->setTitle (name);
+ }
+
+ if (componentListeners_ != 0)
+ {
+ const ComponentDeletionWatcher deletionChecker (this);
+
+ for (int i = componentListeners_->size(); --i >= 0;)
+ {
+ ((ComponentListener*) componentListeners_->getUnchecked (i))
+ ->componentNameChanged (*this);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, componentListeners_->size());
+ }
+ }
+
+ }
+}
+
+void Component::setVisible (bool shouldBeVisible)
+{
+ if (flags.visibleFlag != shouldBeVisible)
+ {
+ // if component methods are being called from threads other than the message
+ // thread, you'll need to use a MessageManagerLock object to make sure it's thread-safe.
+ checkMessageManagerIsLocked
+
+ const ComponentDeletionWatcher deletionChecker (this);
+
+ flags.visibleFlag = shouldBeVisible;
+
+ internalRepaint (0, 0, getWidth(), getHeight());
+
+ sendFakeMouseMove();
+
+ if (! shouldBeVisible)
+ {
+ if (currentlyFocusedComponent == this
+ || isParentOf (currentlyFocusedComponent))
+ {
+ if (parentComponent_ != 0)
+ parentComponent_->grabKeyboardFocus();
+ else
+ giveAwayFocus();
+ }
+ }
+
+ sendVisibilityChangeMessage();
+
+ if ((! deletionChecker.hasBeenDeleted()) && flags.hasHeavyweightPeerFlag)
+ {
+ ComponentPeer* const peer = getPeer();
+
+ jassert (peer != 0);
+ if (peer != 0)
+ {
+ peer->setVisible (shouldBeVisible);
+ internalHierarchyChanged();
+ }
+ }
+ }
+}
+
+void Component::visibilityChanged()
+{
+}
+
+void Component::sendVisibilityChangeMessage()
+{
+ const ComponentDeletionWatcher deletionChecker (this);
+
+ visibilityChanged();
+
+ if ((! deletionChecker.hasBeenDeleted()) && componentListeners_ != 0)
+ {
+ for (int i = componentListeners_->size(); --i >= 0;)
+ {
+ ((ComponentListener*) componentListeners_->getUnchecked (i))
+ ->componentVisibilityChanged (*this);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, componentListeners_->size());
+ }
+ }
+}
+
+bool Component::isShowing() const throw()
+{
+ if (flags.visibleFlag)
+ {
+ if (parentComponent_ != 0)
+ {
+ return parentComponent_->isShowing();
+ }
+ else
+ {
+ const ComponentPeer* const peer = getPeer();
+
+ return peer != 0 && ! peer->isMinimised();
+ }
+ }
+
+ return false;
+}
+
+class FadeOutProxyComponent : public Component,
+ public Timer
+{
+public:
+ FadeOutProxyComponent (Component* comp,
+ const int fadeLengthMs,
+ const int deltaXToMove,
+ const int deltaYToMove,
+ const float scaleFactorAtEnd)
+ : lastTime (0),
+ alpha (1.0f),
+ scale (1.0f)
+ {
+ image = comp->createComponentSnapshot (Rectangle (0, 0, comp->getWidth(), comp->getHeight()));
+ setBounds (comp->getBounds());
+ comp->getParentComponent()->addAndMakeVisible (this);
+ toBehind (comp);
+
+ alphaChangePerMs = -1.0f / (float)fadeLengthMs;
+
+ centreX = comp->getX() + comp->getWidth() * 0.5f;
+ xChangePerMs = deltaXToMove / (float)fadeLengthMs;
+
+ centreY = comp->getY() + comp->getHeight() * 0.5f;
+ yChangePerMs = deltaYToMove / (float)fadeLengthMs;
+
+ scaleChangePerMs = (scaleFactorAtEnd - 1.0f) / (float)fadeLengthMs;
+
+ setInterceptsMouseClicks (false, false);
+
+ // 30 fps is enough for a fade, but we need a higher rate if it's moving as well..
+ startTimer (1000 / ((deltaXToMove == 0 && deltaYToMove == 0) ? 30 : 50));
+ }
+
+ ~FadeOutProxyComponent()
+ {
+ delete image;
+ }
+
+ void paint (Graphics& g)
+ {
+ g.setOpacity (alpha);
+
+ g.drawImage (image,
+ 0, 0, getWidth(), getHeight(),
+ 0, 0, image->getWidth(), image->getHeight());
+ }
+
+ void timerCallback()
+ {
+ const uint32 now = Time::getMillisecondCounter();
+
+ if (lastTime == 0)
+ lastTime = now;
+
+ const int msPassed = (now > lastTime) ? now - lastTime : 0;
+ lastTime = now;
+
+ alpha += alphaChangePerMs * msPassed;
+
+ if (alpha > 0)
+ {
+ if (xChangePerMs != 0.0f || yChangePerMs != 0.0f || scaleChangePerMs != 0.0f)
+ {
+ centreX += xChangePerMs * msPassed;
+ centreY += yChangePerMs * msPassed;
+ scale += scaleChangePerMs * msPassed;
+
+ const int w = roundFloatToInt (image->getWidth() * scale);
+ const int h = roundFloatToInt (image->getHeight() * scale);
+
+ setBounds (roundFloatToInt (centreX) - w / 2,
+ roundFloatToInt (centreY) - h / 2,
+ w, h);
+ }
+
+ repaint();
+ }
+ else
+ {
+ delete this;
+ }
+ }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ Image* image;
+ uint32 lastTime;
+ float alpha, alphaChangePerMs;
+ float centreX, xChangePerMs;
+ float centreY, yChangePerMs;
+ float scale, scaleChangePerMs;
+
+ FadeOutProxyComponent (const FadeOutProxyComponent&);
+ const FadeOutProxyComponent& operator= (const FadeOutProxyComponent&);
+};
+
+void Component::fadeOutComponent (const int millisecondsToFade,
+ const int deltaXToMove,
+ const int deltaYToMove,
+ const float scaleFactorAtEnd)
+{
+ //xxx won't work for comps without parents
+ if (isShowing() && millisecondsToFade > 0)
+ new FadeOutProxyComponent (this, millisecondsToFade,
+ deltaXToMove, deltaYToMove, scaleFactorAtEnd);
+
+ setVisible (false);
+}
+
+bool Component::isValidComponent() const throw()
+{
+ return (this != 0) && isValidMessageListener();
+}
+
+void* Component::getWindowHandle() const throw()
+{
+ const ComponentPeer* const peer = getPeer();
+
+ if (peer != 0)
+ return peer->getNativeHandle();
+
+ return 0;
+}
+
+void Component::addToDesktop (int styleWanted, void* nativeWindowToAttachTo)
+{
+ // if component methods are being called from threads other than the message
+ // thread, you'll need to use a MessageManagerLock object to make sure it's thread-safe.
+ checkMessageManagerIsLocked
+
+ if (! isOpaque())
+ styleWanted |= ComponentPeer::windowIsSemiTransparent;
+
+ int currentStyleFlags = 0;
+
+ // don't use getPeer(), so that we only get the peer that's specifically
+ // for this comp, and not for one of its parents.
+ ComponentPeer* peer = ComponentPeer::getPeerFor (this);
+
+ if (peer != 0)
+ currentStyleFlags = peer->getStyleFlags();
+
+ if (styleWanted != currentStyleFlags || ! flags.hasHeavyweightPeerFlag)
+ {
+ const ComponentDeletionWatcher deletionChecker (this);
+
+#if JUCE_LINUX
+ // it's wise to give the component a non-zero size before
+ // putting it on the desktop, as X windows get confused by this, and
+ // a (1, 1) minimum size is enforced here.
+ setSize (jmax (1, getWidth()),
+ jmax (1, getHeight()));
+#endif
+
+ int x = 0, y = 0;
+ relativePositionToGlobal (x, y);
+
+ bool wasFullscreen = false;
+ bool wasMinimised = false;
+ ComponentBoundsConstrainer* currentConstainer = 0;
+ Rectangle oldNonFullScreenBounds;
+
+ if (peer != 0)
+ {
+ wasFullscreen = peer->isFullScreen();
+ wasMinimised = peer->isMinimised();
+ currentConstainer = peer->getConstrainer();
+ oldNonFullScreenBounds = peer->getNonFullScreenBounds();
+
+ removeFromDesktop();
+ }
+
+ if (parentComponent_ != 0)
+ parentComponent_->removeChildComponent (this);
+
+ if (! deletionChecker.hasBeenDeleted())
+ {
+ flags.hasHeavyweightPeerFlag = true;
+
+ peer = createNewPeer (styleWanted, nativeWindowToAttachTo);
+
+ Desktop::getInstance().addDesktopComponent (this);
+
+ bounds_.setPosition (x, y);
+ peer->setBounds (x, y, getWidth(), getHeight(), false);
+
+ peer->setVisible (isVisible());
+
+ if (wasFullscreen)
+ {
+ peer->setFullScreen (true);
+ peer->setNonFullScreenBounds (oldNonFullScreenBounds);
+ }
+
+ if (wasMinimised)
+ peer->setMinimised (true);
+
+ if (isAlwaysOnTop())
+ peer->setAlwaysOnTop (true);
+
+ peer->setConstrainer (currentConstainer);
+
+ repaint();
+ }
+
+ internalHierarchyChanged();
+ }
+}
+
+void Component::removeFromDesktop()
+{
+ // if component methods are being called from threads other than the message
+ // thread, you'll need to use a MessageManagerLock object to make sure it's thread-safe.
+ checkMessageManagerIsLocked
+
+ if (flags.hasHeavyweightPeerFlag)
+ {
+ ComponentPeer* const peer = ComponentPeer::getPeerFor (this);
+
+ flags.hasHeavyweightPeerFlag = false;
+
+ jassert (peer != 0);
+ delete peer;
+
+ Desktop::getInstance().removeDesktopComponent (this);
+ }
+}
+
+bool Component::isOnDesktop() const throw()
+{
+ return flags.hasHeavyweightPeerFlag;
+}
+
+void Component::userTriedToCloseWindow()
+{
+ /* This means that the user's trying to get rid of your window with the 'close window' system
+ menu option (on windows) or possibly the task manager - you should really handle this
+ and delete or hide your component in an appropriate way.
+
+ If you want to ignore the event and don't want to trigger this assertion, just override
+ this method and do nothing.
+ */
+ jassertfalse
+}
+
+void Component::minimisationStateChanged (bool)
+{
+}
+
+void Component::setOpaque (const bool shouldBeOpaque) throw()
+{
+ if (shouldBeOpaque != flags.opaqueFlag)
+ {
+ flags.opaqueFlag = shouldBeOpaque;
+
+ if (flags.hasHeavyweightPeerFlag)
+ {
+ const ComponentPeer* const peer = ComponentPeer::getPeerFor (this);
+
+ if (peer != 0)
+ {
+ // to make it recreate the heavyweight window
+ addToDesktop (peer->getStyleFlags());
+ }
+ }
+
+ repaint();
+ }
+}
+
+bool Component::isOpaque() const throw()
+{
+ return flags.opaqueFlag;
+}
+
+void Component::setBufferedToImage (const bool shouldBeBuffered) throw()
+{
+ if (shouldBeBuffered != flags.bufferToImageFlag)
+ {
+ deleteAndZero (bufferedImage_);
+ flags.bufferToImageFlag = shouldBeBuffered;
+ }
+}
+
+void Component::toFront (const bool setAsForeground)
+{
+ // if component methods are being called from threads other than the message
+ // thread, you'll need to use a MessageManagerLock object to make sure it's thread-safe.
+ checkMessageManagerIsLocked
+
+ if (flags.hasHeavyweightPeerFlag)
+ {
+ ComponentPeer* const peer = getPeer();
+
+ if (peer != 0)
+ {
+ peer->toFront (setAsForeground);
+
+ if (setAsForeground && ! hasKeyboardFocus (true))
+ grabKeyboardFocus();
+ }
+ }
+ else if (parentComponent_ != 0)
+ {
+ if (parentComponent_->childComponentList_.getLast() != this)
+ {
+ const int index = parentComponent_->childComponentList_.indexOf (this);
+
+ if (index >= 0)
+ {
+ int insertIndex = -1;
+
+ if (! flags.alwaysOnTopFlag)
+ {
+ insertIndex = parentComponent_->childComponentList_.size() - 1;
+
+ while (insertIndex > 0
+ && parentComponent_->childComponentList_.getUnchecked (insertIndex)->isAlwaysOnTop())
+ {
+ --insertIndex;
+ }
+ }
+
+ if (index != insertIndex)
+ {
+ parentComponent_->childComponentList_.move (index, insertIndex);
+ sendFakeMouseMove();
+
+ repaintParent();
+ }
+ }
+ }
+
+ if (setAsForeground)
+ {
+ internalBroughtToFront();
+ grabKeyboardFocus();
+ }
+ }
+}
+
+void Component::toBehind (Component* const other)
+{
+ if (other != 0)
+ {
+ // the two components must belong to the same parent..
+ jassert (parentComponent_ == other->parentComponent_);
+
+ if (parentComponent_ != 0)
+ {
+ const int index = parentComponent_->childComponentList_.indexOf (this);
+ int otherIndex = parentComponent_->childComponentList_.indexOf (other);
+
+ if (index >= 0
+ && otherIndex >= 0
+ && index != otherIndex - 1
+ && other != this)
+ {
+ if (index < otherIndex)
+ --otherIndex;
+
+ parentComponent_->childComponentList_.move (index, otherIndex);
+
+ sendFakeMouseMove();
+ repaintParent();
+ }
+ }
+ else if (isOnDesktop())
+ {
+ jassert (other->isOnDesktop());
+
+ if (other->isOnDesktop())
+ {
+ ComponentPeer* const us = getPeer();
+ ComponentPeer* const them = other->getPeer();
+
+ jassert (us != 0 && them != 0);
+ if (us != 0 && them != 0)
+ us->toBehind (them);
+ }
+ }
+ }
+}
+
+void Component::toBack()
+{
+ if (isOnDesktop())
+ {
+ jassertfalse //xxx need to add this to native window
+ }
+ else if (parentComponent_ != 0
+ && parentComponent_->childComponentList_.getFirst() != this)
+ {
+ const int index = parentComponent_->childComponentList_.indexOf (this);
+
+ if (index > 0)
+ {
+ int insertIndex = 0;
+
+ if (flags.alwaysOnTopFlag)
+ {
+ while (insertIndex < parentComponent_->childComponentList_.size()
+ && ! parentComponent_->childComponentList_.getUnchecked (insertIndex)->isAlwaysOnTop())
+ {
+ ++insertIndex;
+ }
+ }
+
+ if (index != insertIndex)
+ {
+ parentComponent_->childComponentList_.move (index, insertIndex);
+
+ sendFakeMouseMove();
+ repaintParent();
+ }
+ }
+ }
+}
+
+void Component::setAlwaysOnTop (const bool shouldStayOnTop)
+{
+ if (shouldStayOnTop != flags.alwaysOnTopFlag)
+ {
+ flags.alwaysOnTopFlag = shouldStayOnTop;
+
+ if (isOnDesktop())
+ {
+ ComponentPeer* const peer = getPeer();
+
+ jassert (peer != 0);
+ if (peer != 0)
+ {
+ if (! peer->setAlwaysOnTop (shouldStayOnTop))
+ {
+ // some kinds of peer can't change their always-on-top status, so
+ // for these, we'll need to create a new window
+ const int oldFlags = peer->getStyleFlags();
+ removeFromDesktop();
+ addToDesktop (oldFlags);
+ }
+ }
+ }
+
+ if (shouldStayOnTop)
+ toFront (false);
+
+ internalHierarchyChanged();
+ }
+}
+
+bool Component::isAlwaysOnTop() const throw()
+{
+ return flags.alwaysOnTopFlag;
+}
+
+int Component::proportionOfWidth (const float proportion) const throw()
+{
+ return roundDoubleToInt (proportion * bounds_.getWidth());
+}
+
+int Component::proportionOfHeight (const float proportion) const throw()
+{
+ return roundDoubleToInt (proportion * bounds_.getHeight());
+}
+
+int Component::getParentWidth() const throw()
+{
+ return (parentComponent_ != 0) ? parentComponent_->getWidth()
+ : getParentMonitorArea().getWidth();
+}
+
+int Component::getParentHeight() const throw()
+{
+ return (parentComponent_ != 0) ? parentComponent_->getHeight()
+ : getParentMonitorArea().getHeight();
+}
+
+int Component::getScreenX() const throw()
+{
+ return (parentComponent_ != 0) ? parentComponent_->getScreenX() + getX()
+ : (flags.hasHeavyweightPeerFlag ? getPeer()->getScreenX()
+ : getX());
+}
+
+int Component::getScreenY() const throw()
+{
+ return (parentComponent_ != 0) ? parentComponent_->getScreenY() + getY()
+ : (flags.hasHeavyweightPeerFlag ? getPeer()->getScreenY()
+ : getY());
+}
+
+void Component::relativePositionToGlobal (int& x, int& y) const throw()
+{
+ const Component* c = this;
+
+ do
+ {
+ if (c->flags.hasHeavyweightPeerFlag)
+ {
+ c->getPeer()->relativePositionToGlobal (x, y);
+ break;
+ }
+
+ x += c->getX();
+ y += c->getY();
+ c = c->parentComponent_;
+ }
+ while (c != 0);
+}
+
+void Component::globalPositionToRelative (int& x, int& y) const throw()
+{
+ if (flags.hasHeavyweightPeerFlag)
+ {
+ getPeer()->globalPositionToRelative (x, y);
+ }
+ else
+ {
+ if (parentComponent_ != 0)
+ parentComponent_->globalPositionToRelative (x, y);
+
+ x -= getX();
+ y -= getY();
+ }
+}
+
+void Component::relativePositionToOtherComponent (const Component* const targetComponent, int& x, int& y) const throw()
+{
+ if (targetComponent != 0)
+ {
+ const Component* c = this;
+
+ do
+ {
+ if (c == targetComponent)
+ return;
+
+ if (c->flags.hasHeavyweightPeerFlag)
+ {
+ c->getPeer()->relativePositionToGlobal (x, y);
+ break;
+ }
+
+ x += c->getX();
+ y += c->getY();
+ c = c->parentComponent_;
+ }
+ while (c != 0);
+
+ targetComponent->globalPositionToRelative (x, y);
+ }
+}
+
+void Component::setBounds (int x, int y, int w, int h)
+{
+ // if component methods are being called from threads other than the message
+ // thread, you'll need to use a MessageManagerLock object to make sure it's thread-safe.
+ checkMessageManagerIsLocked
+
+ if (w < 0) w = 0;
+ if (h < 0) h = 0;
+
+ const bool wasResized = (getWidth() != w || getHeight() != h);
+ const bool wasMoved = (getX() != x || getY() != y);
+
+#ifdef JUCE_DEBUG
+ // It's a very bad idea to try to resize a window during its paint() method!
+ jassert (! (flags.isInsidePaintCall && wasResized && isOnDesktop()));
+#endif
+
+ if (wasMoved || wasResized)
+ {
+ if (flags.visibleFlag)
+ {
+ // send a fake mouse move to trigger enter/exit messages if needed..
+ sendFakeMouseMove();
+
+ if (! flags.hasHeavyweightPeerFlag)
+ repaintParent();
+ }
+
+ bounds_.setBounds (x, y, w, h);
+
+ if (wasResized)
+ repaint();
+ else if (! flags.hasHeavyweightPeerFlag)
+ repaintParent();
+
+ if (flags.hasHeavyweightPeerFlag)
+ {
+ ComponentPeer* const peer = getPeer();
+
+ if (peer != 0)
+ {
+ if (wasMoved && wasResized)
+ peer->setBounds (getX(), getY(), getWidth(), getHeight(), false);
+ else if (wasMoved)
+ peer->setPosition (getX(), getY());
+ else if (wasResized)
+ peer->setSize (getWidth(), getHeight());
+ }
+ }
+
+ sendMovedResizedMessages (wasMoved, wasResized);
+ }
+}
+
+void Component::sendMovedResizedMessages (const bool wasMoved, const bool wasResized)
+{
+ JUCE_TRY
+ {
+ if (wasMoved)
+ moved();
+
+ if (wasResized)
+ {
+ resized();
+
+ for (int i = childComponentList_.size(); --i >= 0;)
+ {
+ childComponentList_.getUnchecked(i)->parentSizeChanged();
+
+ i = jmin (i, childComponentList_.size());
+ }
+ }
+
+ if (parentComponent_ != 0)
+ parentComponent_->childBoundsChanged (this);
+
+ if (componentListeners_ != 0)
+ {
+ const ComponentDeletionWatcher deletionChecker (this);
+
+ for (int i = componentListeners_->size(); --i >= 0;)
+ {
+ ((ComponentListener*) componentListeners_->getUnchecked (i))
+ ->componentMovedOrResized (*this, wasMoved, wasResized);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, componentListeners_->size());
+ }
+ }
+ }
+ JUCE_CATCH_EXCEPTION
+}
+
+void Component::setSize (const int w, const int h)
+{
+ setBounds (getX(), getY(), w, h);
+}
+
+void Component::setTopLeftPosition (const int x, const int y)
+{
+ setBounds (x, y, getWidth(), getHeight());
+}
+
+void Component::setTopRightPosition (const int x, const int y)
+{
+ setTopLeftPosition (x - getWidth(), y);
+}
+
+void Component::setBounds (const Rectangle& r)
+{
+ setBounds (r.getX(),
+ r.getY(),
+ r.getWidth(),
+ r.getHeight());
+}
+
+void Component::setBoundsRelative (const float x, const float y,
+ const float w, const float h)
+{
+ const int pw = getParentWidth();
+ const int ph = getParentHeight();
+
+ setBounds (roundFloatToInt (x * pw),
+ roundFloatToInt (y * ph),
+ roundFloatToInt (w * pw),
+ roundFloatToInt (h * ph));
+}
+
+void Component::setCentrePosition (const int x, const int y)
+{
+ setTopLeftPosition (x - getWidth() / 2,
+ y - getHeight() / 2);
+}
+
+void Component::setCentreRelative (const float x, const float y)
+{
+ setCentrePosition (roundFloatToInt (getParentWidth() * x),
+ roundFloatToInt (getParentHeight() * y));
+}
+
+void Component::centreWithSize (const int width, const int height)
+{
+ setBounds ((getParentWidth() - width) / 2,
+ (getParentHeight() - height) / 2,
+ width,
+ height);
+}
+
+void Component::setBoundsInset (const BorderSize& borders)
+{
+ setBounds (borders.getLeft(),
+ borders.getTop(),
+ getParentWidth() - (borders.getLeftAndRight()),
+ getParentHeight() - (borders.getTopAndBottom()));
+}
+
+void Component::setBoundsToFit (int x, int y, int width, int height,
+ const Justification& justification,
+ const bool onlyReduceInSize)
+{
+ // it's no good calling this method unless both the component and
+ // target rectangle have a finite size.
+ jassert (getWidth() > 0 && getHeight() > 0 && width > 0 && height > 0);
+
+ if (getWidth() > 0 && getHeight() > 0
+ && width > 0 && height > 0)
+ {
+ int newW, newH;
+
+ if (onlyReduceInSize && getWidth() <= width && getHeight() <= height)
+ {
+ newW = getWidth();
+ newH = getHeight();
+ }
+ else
+ {
+ const double imageRatio = getHeight() / (double) getWidth();
+ const double targetRatio = height / (double) width;
+
+ if (imageRatio <= targetRatio)
+ {
+ newW = width;
+ newH = jmin (height, roundDoubleToInt (newW * imageRatio));
+ }
+ else
+ {
+ newH = height;
+ newW = jmin (width, roundDoubleToInt (newH / imageRatio));
+ }
+ }
+
+ if (newW > 0 && newH > 0)
+ {
+ int newX, newY;
+ justification.applyToRectangle (newX, newY, newW, newH,
+ x, y, width, height);
+
+ setBounds (newX, newY, newW, newH);
+ }
+ }
+}
+
+bool Component::hitTest (int x, int y)
+{
+ if (! flags.ignoresMouseClicksFlag)
+ return true;
+
+ if (flags.allowChildMouseClicksFlag)
+ {
+ for (int i = getNumChildComponents(); --i >= 0;)
+ {
+ Component* const c = getChildComponent (i);
+
+ if (c->isVisible()
+ && c->bounds_.contains (x, y)
+ && c->hitTest (x - c->getX(),
+ y - c->getY()))
+ {
+ return true;
+ }
+ }
+ }
+
+ return false;
+}
+
+void Component::setInterceptsMouseClicks (const bool allowClicks,
+ const bool allowClicksOnChildComponents) throw()
+{
+ flags.ignoresMouseClicksFlag = ! allowClicks;
+ flags.allowChildMouseClicksFlag = allowClicksOnChildComponents;
+}
+
+void Component::getInterceptsMouseClicks (bool& allowsClicksOnThisComponent,
+ bool& allowsClicksOnChildComponents) const throw()
+{
+ allowsClicksOnThisComponent = ! flags.ignoresMouseClicksFlag;
+ allowsClicksOnChildComponents = flags.allowChildMouseClicksFlag;
+}
+
+bool Component::contains (const int x, const int y)
+{
+ if (((unsigned int) x) < (unsigned int) getWidth()
+ && ((unsigned int) y) < (unsigned int) getHeight()
+ && hitTest (x, y))
+ {
+ if (parentComponent_ != 0)
+ {
+ return parentComponent_->contains (x + getX(),
+ y + getY());
+ }
+ else if (flags.hasHeavyweightPeerFlag)
+ {
+ const ComponentPeer* const peer = getPeer();
+
+ if (peer != 0)
+ return peer->contains (x, y, true);
+ }
+ }
+
+ return false;
+}
+
+bool Component::reallyContains (int x, int y, const bool returnTrueIfWithinAChild)
+{
+ if (! contains (x, y))
+ return false;
+
+ Component* p = this;
+
+ while (p->parentComponent_ != 0)
+ {
+ x += p->getX();
+ y += p->getY();
+
+ p = p->parentComponent_;
+ }
+
+ const Component* const c = p->getComponentAt (x, y);
+
+ return (c == this) || (returnTrueIfWithinAChild && isParentOf (c));
+}
+
+Component* Component::getComponentAt (const int x, const int y)
+{
+ if (flags.visibleFlag
+ && ((unsigned int) x) < (unsigned int) getWidth()
+ && ((unsigned int) y) < (unsigned int) getHeight()
+ && hitTest (x, y))
+ {
+ for (int i = childComponentList_.size(); --i >= 0;)
+ {
+ Component* const child = childComponentList_.getUnchecked(i);
+
+ Component* const c = child->getComponentAt (x - child->getX(),
+ y - child->getY());
+
+ if (c != 0)
+ return c;
+ }
+
+ return this;
+ }
+
+ return 0;
+}
+
+void Component::addChildComponent (Component* const child, int zOrder)
+{
+ // if component methods are being called from threads other than the message
+ // thread, you'll need to use a MessageManagerLock object to make sure it's thread-safe.
+ checkMessageManagerIsLocked
+
+ if (child != 0 && child->parentComponent_ != this)
+ {
+ if (child->parentComponent_ != 0)
+ child->parentComponent_->removeChildComponent (child);
+ else
+ child->removeFromDesktop();
+
+ child->parentComponent_ = this;
+
+ if (child->isVisible())
+ child->repaintParent();
+
+ if (! child->isAlwaysOnTop())
+ {
+ if (zOrder < 0)
+ zOrder = childComponentList_.size();
+
+ while (zOrder > 0)
+ {
+ if (! childComponentList_.getUnchecked (zOrder - 1)->isAlwaysOnTop())
+ break;
+
+ --zOrder;
+ }
+ }
+
+ childComponentList_.insert (zOrder, child);
+
+ child->internalHierarchyChanged();
+ internalChildrenChanged();
+ }
+}
+
+void Component::addAndMakeVisible (Component* const child, int zOrder)
+{
+ if (child != 0)
+ {
+ child->setVisible (true);
+ addChildComponent (child, zOrder);
+ }
+}
+
+void Component::removeChildComponent (Component* const child)
+{
+ removeChildComponent (childComponentList_.indexOf (child));
+}
+
+Component* Component::removeChildComponent (const int index)
+{
+ // if component methods are being called from threads other than the message
+ // thread, you'll need to use a MessageManagerLock object to make sure it's thread-safe.
+ checkMessageManagerIsLocked
+
+ Component* const child = childComponentList_ [index];
+
+ if (child != 0)
+ {
+ sendFakeMouseMove();
+ child->repaintParent();
+
+ childComponentList_.remove (index);
+ child->parentComponent_ = 0;
+
+ JUCE_TRY
+ {
+ if ((currentlyFocusedComponent == child)
+ || child->isParentOf (currentlyFocusedComponent))
+ {
+ // get rid first to force the grabKeyboardFocus to change to us.
+ giveAwayFocus();
+ grabKeyboardFocus();
+ }
+ }
+#if JUCE_CATCH_UNHANDLED_EXCEPTIONS
+ catch (const std::exception& e)
+ {
+ currentlyFocusedComponent = 0;
+ Desktop::getInstance().triggerFocusCallback();
+ JUCEApplication::sendUnhandledException (&e, __FILE__, __LINE__);
+ }
+ catch (...)
+ {
+ currentlyFocusedComponent = 0;
+ Desktop::getInstance().triggerFocusCallback();
+ JUCEApplication::sendUnhandledException (0, __FILE__, __LINE__);
+ }
+#endif
+
+ child->internalHierarchyChanged();
+ internalChildrenChanged();
+ }
+
+ return child;
+}
+
+void Component::removeAllChildren()
+{
+ for (int i = childComponentList_.size(); --i >= 0;)
+ removeChildComponent (i);
+}
+
+void Component::deleteAllChildren()
+{
+ for (int i = childComponentList_.size(); --i >= 0;)
+ delete (removeChildComponent (i));
+}
+
+int Component::getNumChildComponents() const throw()
+{
+ return childComponentList_.size();
+}
+
+Component* Component::getChildComponent (const int index) const throw()
+{
+ return childComponentList_ [index];
+}
+
+int Component::getIndexOfChildComponent (const Component* const child) const throw()
+{
+ return childComponentList_.indexOf (const_cast (child));
+}
+
+Component* Component::getTopLevelComponent() const throw()
+{
+ const Component* comp = this;
+
+ while (comp->parentComponent_ != 0)
+ comp = comp->parentComponent_;
+
+ return (Component*) comp;
+}
+
+bool Component::isParentOf (const Component* possibleChild) const throw()
+{
+ while (possibleChild->isValidComponent())
+ {
+ possibleChild = possibleChild->parentComponent_;
+
+ if (possibleChild == this)
+ return true;
+ }
+
+ return false;
+}
+
+void Component::parentHierarchyChanged()
+{
+}
+
+void Component::childrenChanged()
+{
+}
+
+void Component::internalChildrenChanged()
+{
+ const ComponentDeletionWatcher deletionChecker (this);
+ const bool hasListeners = componentListeners_ != 0;
+
+ childrenChanged();
+
+ if (hasListeners)
+ {
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ for (int i = componentListeners_->size(); --i >= 0;)
+ {
+ ((ComponentListener*) componentListeners_->getUnchecked (i))
+ ->componentChildrenChanged (*this);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, componentListeners_->size());
+ }
+ }
+}
+
+void Component::internalHierarchyChanged()
+{
+ parentHierarchyChanged();
+
+ const ComponentDeletionWatcher deletionChecker (this);
+
+ if (componentListeners_ != 0)
+ {
+ for (int i = componentListeners_->size(); --i >= 0;)
+ {
+ ((ComponentListener*) componentListeners_->getUnchecked (i))
+ ->componentParentHierarchyChanged (*this);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, componentListeners_->size());
+ }
+ }
+
+ for (int i = childComponentList_.size(); --i >= 0;)
+ {
+ childComponentList_.getUnchecked (i)->internalHierarchyChanged();
+
+ // you really shouldn't delete the parent component during a callback telling you
+ // that it's changed..
+ jassert (! deletionChecker.hasBeenDeleted());
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, childComponentList_.size());
+ }
+}
+
+void* Component::runModalLoopCallback (void* userData)
+{
+ return (void*) (pointer_sized_int) ((Component*) userData)->runModalLoop();
+}
+
+int Component::runModalLoop()
+{
+ if (! MessageManager::getInstance()->isThisTheMessageThread())
+ {
+ // use a callback so this can be called from non-gui threads
+ return (int) (pointer_sized_int)
+ MessageManager::getInstance()
+ ->callFunctionOnMessageThread (&runModalLoopCallback, (void*) this);
+ }
+
+ Component* const prevFocused = getCurrentlyFocusedComponent();
+
+ ComponentDeletionWatcher* deletionChecker = 0;
+ if (prevFocused != 0)
+ deletionChecker = new ComponentDeletionWatcher (prevFocused);
+
+ if (! isCurrentlyModal())
+ enterModalState();
+
+ JUCE_TRY
+ {
+ while (flags.currentlyModalFlag && flags.visibleFlag)
+ {
+ if (! MessageManager::getInstance()->dispatchNextMessage())
+ break;
+
+ // check whether this component was deleted during the last message
+ if (! isValidMessageListener())
+ break;
+ }
+ }
+#if JUCE_CATCH_UNHANDLED_EXCEPTIONS
+ catch (const std::exception& e)
+ {
+ JUCEApplication::sendUnhandledException (&e, __FILE__, __LINE__);
+ return 0;
+ }
+ catch (...)
+ {
+ JUCEApplication::sendUnhandledException (0, __FILE__, __LINE__);
+ return 0;
+ }
+#endif
+
+ const int modalIndex = modalComponentReturnValueKeys.indexOf (this);
+ int returnValue = 0;
+
+ if (modalIndex >= 0)
+ {
+ modalComponentReturnValueKeys.remove (modalIndex);
+ returnValue = modalReturnValues.remove (modalIndex);
+ }
+
+ modalComponentStack.removeValue (this);
+
+ if (deletionChecker != 0)
+ {
+ if (! deletionChecker->hasBeenDeleted())
+ prevFocused->grabKeyboardFocus();
+
+ delete deletionChecker;
+ }
+
+ return returnValue;
+}
+
+void Component::enterModalState (const bool takeKeyboardFocus)
+{
+ // if component methods are being called from threads other than the message
+ // thread, you'll need to use a MessageManagerLock object to make sure it's thread-safe.
+ checkMessageManagerIsLocked
+
+ // Check for an attempt to make a component modal when it already is!
+ // This can cause nasty problems..
+ jassert (! flags.currentlyModalFlag);
+
+ if (! isCurrentlyModal())
+ {
+ modalComponentStack.add (this);
+ modalComponentReturnValueKeys.add (this);
+ modalReturnValues.add (0);
+
+ flags.currentlyModalFlag = true;
+ setVisible (true);
+
+ if (takeKeyboardFocus)
+ grabKeyboardFocus();
+ }
+}
+
+void Component::exitModalState (const int returnValue)
+{
+ if (isCurrentlyModal())
+ {
+ if (MessageManager::getInstance()->isThisTheMessageThread())
+ {
+ const int modalIndex = modalComponentReturnValueKeys.indexOf (this);
+
+ if (modalIndex >= 0)
+ {
+ modalReturnValues.set (modalIndex, returnValue);
+ }
+ else
+ {
+ modalComponentReturnValueKeys.add (this);
+ modalReturnValues.add (returnValue);
+ }
+
+ modalComponentStack.removeValue (this);
+
+ flags.currentlyModalFlag = false;
+ }
+ else
+ {
+ postMessage (new Message (exitModalStateMessage, returnValue, 0, 0));
+ }
+ }
+}
+
+bool Component::isCurrentlyModal() const throw()
+{
+ return flags.currentlyModalFlag
+ && getCurrentlyModalComponent() == this;
+}
+
+bool Component::isCurrentlyBlockedByAnotherModalComponent() const throw()
+{
+ Component* const mc = getCurrentlyModalComponent();
+
+ return mc != 0
+ && mc != this
+ && (! mc->isParentOf (this))
+ && ! mc->canModalEventBeSentToComponent (this);
+}
+
+Component* JUCE_CALLTYPE Component::getCurrentlyModalComponent() throw()
+{
+ Component* const c = (Component*) modalComponentStack.getLast();
+
+ return c->isValidComponent() ? c : 0;
+}
+
+void Component::setBroughtToFrontOnMouseClick (const bool shouldBeBroughtToFront) throw()
+{
+ flags.bringToFrontOnClickFlag = shouldBeBroughtToFront;
+}
+
+bool Component::isBroughtToFrontOnMouseClick() const throw()
+{
+ return flags.bringToFrontOnClickFlag;
+}
+
+void Component::setMouseCursor (const MouseCursor& cursor) throw()
+{
+ cursor_ = cursor;
+
+ if (flags.visibleFlag)
+ {
+ int mx, my;
+ getMouseXYRelative (mx, my);
+
+ if (flags.draggingFlag || reallyContains (mx, my, false))
+ {
+ internalUpdateMouseCursor (false);
+ }
+ }
+}
+
+const MouseCursor Component::getMouseCursor()
+{
+ return cursor_;
+}
+
+void Component::updateMouseCursor() const throw()
+{
+ sendFakeMouseMove();
+}
+
+void Component::internalUpdateMouseCursor (const bool forcedUpdate) throw()
+{
+ ComponentPeer* const peer = getPeer();
+
+ if (peer != 0)
+ {
+ MouseCursor mc (getMouseCursor());
+
+ if (isUnboundedMouseModeOn && (unboundedMouseOffsetX != 0
+ || unboundedMouseOffsetY != 0
+ || ! isCursorVisibleUntilOffscreen))
+ {
+ mc = MouseCursor::NoCursor;
+ }
+
+ static void* currentCursorHandle = 0;
+
+ if (forcedUpdate || mc.getHandle() != currentCursorHandle)
+ {
+ currentCursorHandle = mc.getHandle();
+ mc.showInWindow (peer);
+ }
+ }
+}
+
+void Component::setRepaintsOnMouseActivity (const bool shouldRepaint) throw()
+{
+ flags.repaintOnMouseActivityFlag = shouldRepaint;
+}
+
+void Component::repaintParent() throw()
+{
+ if (flags.visibleFlag)
+ internalRepaint (0, 0, getWidth(), getHeight());
+}
+
+void Component::repaint() throw()
+{
+ repaint (0, 0, getWidth(), getHeight());
+}
+
+void Component::repaint (const int x, const int y,
+ const int w, const int h) throw()
+{
+ deleteAndZero (bufferedImage_);
+
+ if (flags.visibleFlag)
+ internalRepaint (x, y, w, h);
+}
+
+void Component::internalRepaint (int x, int y, int w, int h)
+{
+ // if component methods are being called from threads other than the message
+ // thread, you'll need to use a MessageManagerLock object to make sure it's thread-safe.
+ checkMessageManagerIsLocked
+
+ if (x < 0)
+ {
+ w += x;
+ x = 0;
+ }
+
+ if (x + w > getWidth())
+ w = getWidth() - x;
+
+ if (w > 0)
+ {
+ if (y < 0)
+ {
+ h += y;
+ y = 0;
+ }
+
+ if (y + h > getHeight())
+ h = getHeight() - y;
+
+ if (h > 0)
+ {
+ if (parentComponent_ != 0)
+ {
+ x += getX();
+ y += getY();
+
+ if (parentComponent_->flags.visibleFlag)
+ parentComponent_->internalRepaint (x, y, w, h);
+ }
+ else if (flags.hasHeavyweightPeerFlag)
+ {
+ ComponentPeer* const peer = getPeer();
+
+ if (peer != 0)
+ peer->repaint (x, y, w, h);
+ }
+ }
+ }
+}
+
+void Component::paintEntireComponent (Graphics& originalContext)
+{
+ jassert (! originalContext.isClipEmpty());
+
+#ifdef JUCE_DEBUG
+ flags.isInsidePaintCall = true;
+#endif
+
+ Graphics* g = &originalContext;
+ Image* effectImage = 0;
+
+ if (effect_ != 0)
+ {
+ effectImage = new Image (flags.opaqueFlag ? Image::RGB : Image::ARGB,
+ getWidth(), getHeight(),
+ ! flags.opaqueFlag);
+
+ g = new Graphics (*effectImage);
+ }
+
+ g->saveState();
+ clipObscuredRegions (*g, g->getClipBounds(), 0, 0);
+
+ if (! g->isClipEmpty())
+ {
+ if (bufferedImage_ != 0)
+ {
+ g->setColour (Colours::black);
+ g->drawImageAt (bufferedImage_, 0, 0);
+ }
+ else
+ {
+ if (flags.bufferToImageFlag)
+ {
+ if (bufferedImage_ == 0)
+ {
+ bufferedImage_ = new Image (flags.opaqueFlag ? Image::RGB : Image::ARGB,
+ getWidth(), getHeight(), ! flags.opaqueFlag);
+
+ Graphics imG (*bufferedImage_);
+ paint (imG);
+ }
+
+ g->setColour (Colours::black);
+ g->drawImageAt (bufferedImage_, 0, 0);
+ }
+ else
+ {
+ paint (*g);
+ g->resetToDefaultState();
+ }
+ }
+ }
+
+ g->restoreState();
+
+ for (int i = 0; i < childComponentList_.size(); ++i)
+ {
+ Component* const child = childComponentList_.getUnchecked (i);
+
+ if (child->isVisible())
+ {
+ g->saveState();
+
+ if (g->reduceClipRegion (child->getX(), child->getY(),
+ child->getWidth(), child->getHeight()))
+ {
+ for (int j = i + 1; j < childComponentList_.size(); ++j)
+ {
+ const Component* const sibling = childComponentList_.getUnchecked (j);
+
+ if (sibling->flags.opaqueFlag && sibling->isVisible())
+ g->excludeClipRegion (sibling->getX(), sibling->getY(),
+ sibling->getWidth(), sibling->getHeight());
+ }
+
+ if (! g->isClipEmpty())
+ {
+ g->setOrigin (child->getX(), child->getY());
+
+ child->paintEntireComponent (*g);
+ }
+ }
+
+ g->restoreState();
+ }
+ }
+
+ JUCE_TRY
+ {
+ g->saveState();
+ paintOverChildren (*g);
+ g->restoreState();
+ }
+ JUCE_CATCH_EXCEPTION
+
+ if (effect_ != 0)
+ {
+ delete g;
+
+ effect_->applyEffect (*effectImage, originalContext);
+ delete effectImage;
+ }
+
+#ifdef JUCE_DEBUG
+ flags.isInsidePaintCall = false;
+#endif
+}
+
+Image* Component::createComponentSnapshot (const Rectangle& areaToGrab,
+ const bool clipImageToComponentBounds)
+{
+ Rectangle r (areaToGrab);
+
+ if (clipImageToComponentBounds)
+ r = r.getIntersection (Rectangle (0, 0, getWidth(), getHeight()));
+
+ Image* const componentImage = new Image (flags.opaqueFlag ? Image::RGB : Image::ARGB,
+ jmax (1, r.getWidth()),
+ jmax (1, r.getHeight()),
+ true);
+
+ Graphics imageContext (*componentImage);
+ imageContext.setOrigin (-r.getX(),
+ -r.getY());
+
+ paintEntireComponent (imageContext);
+
+ return componentImage;
+}
+
+void Component::setComponentEffect (ImageEffectFilter* const effect)
+{
+ if (effect_ != effect)
+ {
+ effect_ = effect;
+ repaint();
+ }
+}
+
+LookAndFeel& Component::getLookAndFeel() const throw()
+{
+ const Component* c = this;
+
+ do
+ {
+ if (c->lookAndFeel_ != 0)
+ return *(c->lookAndFeel_);
+
+ c = c->parentComponent_;
+ }
+ while (c != 0);
+
+ return LookAndFeel::getDefaultLookAndFeel();
+}
+
+void Component::setLookAndFeel (LookAndFeel* const newLookAndFeel)
+{
+ if (lookAndFeel_ != newLookAndFeel)
+ {
+ lookAndFeel_ = newLookAndFeel;
+
+ sendLookAndFeelChange();
+ }
+}
+
+void Component::lookAndFeelChanged()
+{
+}
+
+void Component::sendLookAndFeelChange()
+{
+ repaint();
+
+ lookAndFeelChanged();
+
+ // (it's not a great idea to do anything that would delete this component
+ // during the lookAndFeelChanged() callback)
+ jassert (isValidComponent());
+
+ const ComponentDeletionWatcher deletionChecker (this);
+
+ for (int i = childComponentList_.size(); --i >= 0;)
+ {
+ childComponentList_.getUnchecked (i)->sendLookAndFeelChange();
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, childComponentList_.size());
+ }
+}
+
+static const String getColourPropertyName (const int colourId) throw()
+{
+ String s;
+ s.preallocateStorage (18);
+ s << T("jcclr_") << colourId;
+ return s;
+}
+
+const Colour Component::findColour (const int colourId, const bool inheritFromParent) const throw()
+{
+ const String customColour (getComponentProperty (getColourPropertyName (colourId),
+ inheritFromParent,
+ String::empty));
+
+ if (customColour.isNotEmpty())
+ return Colour (customColour.getIntValue());
+
+ return getLookAndFeel().findColour (colourId);
+}
+
+bool Component::isColourSpecified (const int colourId) const throw()
+{
+ return getComponentProperty (getColourPropertyName (colourId),
+ false,
+ String::empty).isNotEmpty();
+}
+
+void Component::removeColour (const int colourId)
+{
+ if (isColourSpecified (colourId))
+ {
+ removeComponentProperty (getColourPropertyName (colourId));
+ colourChanged();
+ }
+}
+
+void Component::setColour (const int colourId, const Colour& colour)
+{
+ const String colourName (getColourPropertyName (colourId));
+ const String customColour (getComponentProperty (colourName, false, String::empty));
+
+ if (customColour.isEmpty() || Colour (customColour.getIntValue()) != colour)
+ {
+ setComponentProperty (colourName, colour);
+ colourChanged();
+ }
+}
+
+void Component::copyAllExplicitColoursTo (Component& target) const throw()
+{
+ if (propertySet_ != 0)
+ {
+ const StringPairArray& props = propertySet_->getAllProperties();
+ const StringArray& keys = props.getAllKeys();
+
+ for (int i = 0; i < keys.size(); ++i)
+ {
+ if (keys[i].startsWith (T("jcclr_")))
+ {
+ target.setComponentProperty (keys[i],
+ props.getAllValues() [i]);
+ }
+ }
+
+ target.colourChanged();
+ }
+}
+
+void Component::colourChanged()
+{
+}
+
+const Rectangle Component::getUnclippedArea() const
+{
+ int x = 0, y = 0, w = getWidth(), h = getHeight();
+
+ Component* p = parentComponent_;
+ int px = getX();
+ int py = getY();
+
+ while (p != 0)
+ {
+ if (! Rectangle::intersectRectangles (x, y, w, h, -px, -py, p->getWidth(), p->getHeight()))
+ return Rectangle();
+
+ px += p->getX();
+ py += p->getY();
+ p = p->parentComponent_;
+ }
+
+ return Rectangle (x, y, w, h);
+}
+
+void Component::clipObscuredRegions (Graphics& g, const Rectangle& clipRect,
+ const int deltaX, const int deltaY) const throw()
+{
+ for (int i = childComponentList_.size(); --i >= 0;)
+ {
+ const Component* const c = childComponentList_.getUnchecked(i);
+
+ if (c->isVisible())
+ {
+ Rectangle newClip (clipRect.getIntersection (c->bounds_));
+
+ if (! newClip.isEmpty())
+ {
+ if (c->isOpaque())
+ {
+ g.excludeClipRegion (deltaX + newClip.getX(),
+ deltaY + newClip.getY(),
+ newClip.getWidth(),
+ newClip.getHeight());
+ }
+ else
+ {
+ newClip.translate (-c->getX(), -c->getY());
+ c->clipObscuredRegions (g, newClip,
+ c->getX() + deltaX,
+ c->getY() + deltaY);
+ }
+ }
+ }
+ }
+}
+
+void Component::getVisibleArea (RectangleList& result,
+ const bool includeSiblings) const
+{
+ result.clear();
+ const Rectangle unclipped (getUnclippedArea());
+
+ if (! unclipped.isEmpty())
+ {
+ result.add (unclipped);
+
+ if (includeSiblings)
+ {
+ const Component* const c = getTopLevelComponent();
+
+ int x = 0, y = 0;
+ c->relativePositionToOtherComponent (this, x, y);
+
+ c->subtractObscuredRegions (result, x, y,
+ Rectangle (0, 0, c->getWidth(), c->getHeight()),
+ this);
+ }
+
+ subtractObscuredRegions (result, 0, 0, unclipped, 0);
+ result.consolidate();
+ }
+}
+
+void Component::subtractObscuredRegions (RectangleList& result,
+ const int deltaX,
+ const int deltaY,
+ const Rectangle& clipRect,
+ const Component* const compToAvoid) const throw()
+{
+ for (int i = childComponentList_.size(); --i >= 0;)
+ {
+ const Component* const c = childComponentList_.getUnchecked(i);
+
+ if (c != compToAvoid && c->isVisible())
+ {
+ if (c->isOpaque())
+ {
+ Rectangle childBounds (c->bounds_.getIntersection (clipRect));
+ childBounds.translate (deltaX, deltaY);
+
+ result.subtract (childBounds);
+ }
+ else
+ {
+ Rectangle newClip (clipRect.getIntersection (c->bounds_));
+ newClip.translate (-c->getX(), -c->getY());
+
+ c->subtractObscuredRegions (result,
+ c->getX() + deltaX,
+ c->getY() + deltaY,
+ newClip,
+ compToAvoid);
+ }
+ }
+ }
+}
+
+void Component::mouseEnter (const MouseEvent&)
+{
+ // base class does nothing
+}
+
+void Component::mouseExit (const MouseEvent&)
+{
+ // base class does nothing
+}
+
+void Component::mouseDown (const MouseEvent&)
+{
+ // base class does nothing
+}
+
+void Component::mouseUp (const MouseEvent&)
+{
+ // base class does nothing
+}
+
+void Component::mouseDrag (const MouseEvent&)
+{
+ // base class does nothing
+}
+
+void Component::mouseMove (const MouseEvent&)
+{
+ // base class does nothing
+}
+
+void Component::mouseDoubleClick (const MouseEvent&)
+{
+ // base class does nothing
+}
+
+void Component::mouseWheelMove (const MouseEvent& e, float wheelIncrementX, float wheelIncrementY)
+{
+ // the base class just passes this event up to its parent..
+
+ if (parentComponent_ != 0)
+ parentComponent_->mouseWheelMove (e.getEventRelativeTo (parentComponent_),
+ wheelIncrementX, wheelIncrementY);
+}
+
+void Component::resized()
+{
+ // base class does nothing
+}
+
+void Component::moved()
+{
+ // base class does nothing
+}
+
+void Component::childBoundsChanged (Component*)
+{
+ // base class does nothing
+}
+
+void Component::parentSizeChanged()
+{
+ // base class does nothing
+}
+
+void Component::addComponentListener (ComponentListener* const newListener) throw()
+{
+ if (componentListeners_ == 0)
+ componentListeners_ = new VoidArray (4);
+
+ componentListeners_->addIfNotAlreadyThere (newListener);
+}
+
+void Component::removeComponentListener (ComponentListener* const listenerToRemove) throw()
+{
+ jassert (isValidComponent());
+
+ if (componentListeners_ != 0)
+ componentListeners_->removeValue (listenerToRemove);
+}
+
+void Component::inputAttemptWhenModal()
+{
+ getTopLevelComponent()->toFront (true);
+
+ getLookAndFeel().playAlertSound();
+}
+
+bool Component::canModalEventBeSentToComponent (const Component*)
+{
+ return false;
+}
+
+void Component::internalModalInputAttempt()
+{
+ Component* const current = getCurrentlyModalComponent();
+
+ if (current != 0)
+ current->inputAttemptWhenModal();
+}
+
+void Component::paint (Graphics&)
+{
+ // all painting is done in the subclasses
+
+ jassert (! isOpaque()); // if your component's opaque, you've gotta paint it!
+}
+
+void Component::paintOverChildren (Graphics&)
+{
+ // all painting is done in the subclasses
+}
+
+void Component::handleMessage (const Message& message)
+{
+ if (message.intParameter1 == exitModalStateMessage)
+ {
+ exitModalState (message.intParameter2);
+ }
+ else if (message.intParameter1 == customCommandMessage)
+ {
+ handleCommandMessage (message.intParameter2);
+ }
+}
+
+void Component::postCommandMessage (const int commandId) throw()
+{
+ postMessage (new Message (customCommandMessage, commandId, 0, 0));
+}
+
+void Component::handleCommandMessage (int)
+{
+ // used by subclasses
+}
+
+void Component::addMouseListener (MouseListener* const newListener,
+ const bool wantsEventsForAllNestedChildComponents) throw()
+{
+ // if component methods are being called from threads other than the message
+ // thread, you'll need to use a MessageManagerLock object to make sure it's thread-safe.
+ checkMessageManagerIsLocked
+
+ if (mouseListeners_ == 0)
+ mouseListeners_ = new VoidArray (4);
+
+ if (! mouseListeners_->contains (newListener))
+ {
+ if (wantsEventsForAllNestedChildComponents)
+ {
+ mouseListeners_->insert (0, newListener);
+ ++numDeepMouseListeners;
+ }
+ else
+ {
+ mouseListeners_->add (newListener);
+ }
+ }
+}
+
+void Component::removeMouseListener (MouseListener* const listenerToRemove) throw()
+{
+ // if component methods are being called from threads other than the message
+ // thread, you'll need to use a MessageManagerLock object to make sure it's thread-safe.
+ checkMessageManagerIsLocked
+
+ if (mouseListeners_ != 0)
+ {
+ const int index = mouseListeners_->indexOf (listenerToRemove);
+
+ if (index >= 0)
+ {
+ if (index < numDeepMouseListeners)
+ --numDeepMouseListeners;
+
+ mouseListeners_->remove (index);
+ }
+ }
+}
+
+void Component::internalMouseEnter (int x, int y, int64 time)
+{
+ if (isCurrentlyBlockedByAnotherModalComponent())
+ {
+ // if something else is modal, always just show a normal mouse cursor
+ if (componentUnderMouse == this)
+ {
+ ComponentPeer* const peer = getPeer();
+
+ if (peer != 0)
+ {
+ MouseCursor mc (MouseCursor::NormalCursor);
+ mc.showInWindow (peer);
+ }
+ }
+
+ return;
+ }
+
+ if (! flags.mouseInsideFlag)
+ {
+ flags.mouseInsideFlag = true;
+ flags.mouseOverFlag = true;
+ flags.draggingFlag = false;
+
+ if (isValidComponent())
+ {
+ const ComponentDeletionWatcher deletionChecker (this);
+
+ if (flags.repaintOnMouseActivityFlag)
+ repaint();
+
+ const MouseEvent me (x, y,
+ ModifierKeys::getCurrentModifiers(),
+ this,
+ Time (time),
+ x, y,
+ Time (time),
+ 0, false);
+
+ mouseEnter (me);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ Desktop::getInstance().resetTimer();
+
+ for (int i = Desktop::getInstance().mouseListeners.size(); --i >= 0;)
+ {
+ ((MouseListener*) Desktop::getInstance().mouseListeners[i])->mouseEnter (me);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, Desktop::getInstance().mouseListeners.size());
+ }
+
+ if (mouseListeners_ != 0)
+ {
+ for (int i = mouseListeners_->size(); --i >= 0;)
+ {
+ ((MouseListener*) mouseListeners_->getUnchecked(i))->mouseEnter (me);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, mouseListeners_->size());
+ }
+ }
+
+ const Component* p = parentComponent_;
+
+ while (p != 0)
+ {
+ const ComponentDeletionWatcher parentDeletionChecker (p);
+
+ for (int i = p->numDeepMouseListeners; --i >= 0;)
+ {
+ ((MouseListener*) (p->mouseListeners_->getUnchecked(i)))->mouseEnter (me);
+
+ if (deletionChecker.hasBeenDeleted() || parentDeletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, p->numDeepMouseListeners);
+ }
+
+ p = p->parentComponent_;
+ }
+ }
+ }
+
+ if (componentUnderMouse == this)
+ internalUpdateMouseCursor (true);
+}
+
+void Component::internalMouseExit (int x, int y, int64 time)
+{
+ const ComponentDeletionWatcher deletionChecker (this);
+
+ if (flags.draggingFlag)
+ {
+ internalMouseUp (ModifierKeys::getCurrentModifiers().getRawFlags(), x, y, time);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+ }
+
+ enableUnboundedMouseMovement (false);
+
+ if (flags.mouseInsideFlag || flags.mouseOverFlag)
+ {
+ flags.mouseInsideFlag = false;
+ flags.mouseOverFlag = false;
+ flags.draggingFlag = false;
+
+ if (flags.repaintOnMouseActivityFlag)
+ repaint();
+
+ const MouseEvent me (x, y,
+ ModifierKeys::getCurrentModifiers(),
+ this,
+ Time (time),
+ x, y,
+ Time (time),
+ 0, false);
+ mouseExit (me);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ Desktop::getInstance().resetTimer();
+
+ for (int i = Desktop::getInstance().mouseListeners.size(); --i >= 0;)
+ {
+ ((MouseListener*) Desktop::getInstance().mouseListeners[i])->mouseExit (me);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, Desktop::getInstance().mouseListeners.size());
+ }
+
+ if (mouseListeners_ != 0)
+ {
+ for (int i = mouseListeners_->size(); --i >= 0;)
+ {
+ ((MouseListener*) mouseListeners_->getUnchecked (i))->mouseExit (me);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, mouseListeners_->size());
+ }
+ }
+
+ const Component* p = parentComponent_;
+
+ while (p != 0)
+ {
+ const ComponentDeletionWatcher parentDeletionChecker (p);
+
+ for (int i = p->numDeepMouseListeners; --i >= 0;)
+ {
+ ((MouseListener*) (p->mouseListeners_->getUnchecked (i)))->mouseExit (me);
+
+ if (deletionChecker.hasBeenDeleted() || parentDeletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, p->numDeepMouseListeners);
+ }
+
+ p = p->parentComponent_;
+ }
+ }
+}
+
+class InternalDragRepeater : public Timer
+{
+public:
+ InternalDragRepeater()
+ {}
+
+ ~InternalDragRepeater()
+ {}
+
+ void timerCallback()
+ {
+ Component* const c = Component::getComponentUnderMouse();
+
+ if (c != 0 && c->isMouseButtonDown())
+ {
+ int x, y;
+ c->getMouseXYRelative (x, y);
+
+ // the offsets have been added on, so must be taken off before calling the
+ // drag.. otherwise they'll be added twice
+ x -= unboundedMouseOffsetX;
+ y -= unboundedMouseOffsetY;
+
+ c->internalMouseDrag (x, y, Time::currentTimeMillis());
+ }
+ }
+
+ juce_UseDebuggingNewOperator
+};
+
+static InternalDragRepeater* dragRepeater = 0;
+
+void Component::beginDragAutoRepeat (const int interval)
+{
+ if (interval > 0)
+ {
+ if (dragRepeater == 0)
+ dragRepeater = new InternalDragRepeater();
+
+ if (dragRepeater->getTimerInterval() != interval)
+ dragRepeater->startTimer (interval);
+ }
+ else
+ {
+ deleteAndZero (dragRepeater);
+ }
+}
+
+void Component::internalMouseDown (const int x, const int y)
+{
+ const ComponentDeletionWatcher deletionChecker (this);
+
+ if (isCurrentlyBlockedByAnotherModalComponent())
+ {
+ internalModalInputAttempt();
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ // If processing the input attempt has exited the modal loop, we'll allow the event
+ // to be delivered..
+ if (isCurrentlyBlockedByAnotherModalComponent())
+ {
+ // allow blocked mouse-events to go to global listeners..
+ const MouseEvent me (x, y,
+ ModifierKeys::getCurrentModifiers(),
+ this,
+ Time (juce_recentMouseDownTimes[0]),
+ x, y,
+ Time (juce_recentMouseDownTimes[0]),
+ countMouseClicks(),
+ false);
+
+ Desktop::getInstance().resetTimer();
+
+ for (int i = Desktop::getInstance().mouseListeners.size(); --i >= 0;)
+ {
+ ((MouseListener*) Desktop::getInstance().mouseListeners[i])->mouseDown (me);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, Desktop::getInstance().mouseListeners.size());
+ }
+
+ return;
+ }
+ }
+
+ {
+ Component* c = this;
+
+ while (c != 0)
+ {
+ if (c->isBroughtToFrontOnMouseClick())
+ {
+ c->toFront (true);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+ }
+
+ c = c->parentComponent_;
+ }
+ }
+
+ if (! flags.dontFocusOnMouseClickFlag)
+ grabFocusInternal (focusChangedByMouseClick);
+
+ if (! deletionChecker.hasBeenDeleted())
+ {
+ flags.draggingFlag = true;
+ flags.mouseOverFlag = true;
+
+ if (flags.repaintOnMouseActivityFlag)
+ repaint();
+
+ const MouseEvent me (x, y,
+ ModifierKeys::getCurrentModifiers(),
+ this,
+ Time (juce_recentMouseDownTimes[0]),
+ x, y,
+ Time (juce_recentMouseDownTimes[0]),
+ countMouseClicks(),
+ false);
+ mouseDown (me);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ Desktop::getInstance().resetTimer();
+
+ for (int i = Desktop::getInstance().mouseListeners.size(); --i >= 0;)
+ {
+ ((MouseListener*) Desktop::getInstance().mouseListeners[i])->mouseDown (me);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, Desktop::getInstance().mouseListeners.size());
+ }
+
+ if (mouseListeners_ != 0)
+ {
+ for (int i = mouseListeners_->size(); --i >= 0;)
+ {
+ ((MouseListener*) mouseListeners_->getUnchecked (i))->mouseDown (me);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, mouseListeners_->size());
+ }
+ }
+
+ const Component* p = parentComponent_;
+
+ while (p != 0)
+ {
+ const ComponentDeletionWatcher parentDeletionChecker (p);
+
+ for (int i = p->numDeepMouseListeners; --i >= 0;)
+ {
+ ((MouseListener*) (p->mouseListeners_->getUnchecked (i)))->mouseDown (me);
+
+ if (deletionChecker.hasBeenDeleted() || parentDeletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, p->numDeepMouseListeners);
+ }
+
+ p = p->parentComponent_;
+ }
+ }
+}
+
+void Component::internalMouseUp (const int oldModifiers, int x, int y, const int64 time)
+{
+ if (isValidComponent() && flags.draggingFlag)
+ {
+ flags.draggingFlag = false;
+ deleteAndZero (dragRepeater);
+
+ x += unboundedMouseOffsetX;
+ y += unboundedMouseOffsetY;
+ juce_LastMousePosX = x;
+ juce_LastMousePosY = y;
+ relativePositionToGlobal (juce_LastMousePosX, juce_LastMousePosY);
+
+ const ComponentDeletionWatcher deletionChecker (this);
+
+ if (flags.repaintOnMouseActivityFlag)
+ repaint();
+
+ int mdx = juce_recentMouseDownX[0];
+ int mdy = juce_recentMouseDownY[0];
+ globalPositionToRelative (mdx, mdy);
+
+ const MouseEvent me (x, y,
+ oldModifiers,
+ this,
+ Time (time),
+ mdx, mdy,
+ Time (juce_recentMouseDownTimes [0]),
+ countMouseClicks(),
+ juce_MouseHasMovedSignificantlySincePressed
+ || juce_recentMouseDownTimes[0] + 300 < time);
+
+ mouseUp (me);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ Desktop::getInstance().resetTimer();
+
+ for (int i = Desktop::getInstance().mouseListeners.size(); --i >= 0;)
+ {
+ ((MouseListener*) Desktop::getInstance().mouseListeners[i])->mouseUp (me);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, Desktop::getInstance().mouseListeners.size());
+ }
+
+ if (mouseListeners_ != 0)
+ {
+ for (int i = mouseListeners_->size(); --i >= 0;)
+ {
+ ((MouseListener*) mouseListeners_->getUnchecked (i))->mouseUp (me);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, mouseListeners_->size());
+ }
+ }
+
+ {
+ const Component* p = parentComponent_;
+
+ while (p != 0)
+ {
+ const ComponentDeletionWatcher parentDeletionChecker (p);
+
+ for (int i = p->numDeepMouseListeners; --i >= 0;)
+ {
+ ((MouseListener*) (p->mouseListeners_->getUnchecked (i)))->mouseUp (me);
+
+ if (deletionChecker.hasBeenDeleted() || parentDeletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, p->numDeepMouseListeners);
+ }
+
+ p = p->parentComponent_;
+ }
+ }
+
+ // check for double-click
+ if (me.getNumberOfClicks() >= 2)
+ {
+ const int numListeners = (mouseListeners_ != 0) ? mouseListeners_->size() : 0;
+
+ mouseDoubleClick (me);
+
+ int i;
+ for (i = Desktop::getInstance().mouseListeners.size(); --i >= 0;)
+ {
+ ((MouseListener*) Desktop::getInstance().mouseListeners[i])->mouseDoubleClick (me);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, Desktop::getInstance().mouseListeners.size());
+ }
+
+ for (i = numListeners; --i >= 0;)
+ {
+ if (deletionChecker.hasBeenDeleted() || mouseListeners_ == 0)
+ return;
+
+ MouseListener* const ml = (MouseListener*)((*mouseListeners_)[i]);
+ if (ml != 0)
+ ml->mouseDoubleClick (me);
+ }
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ const Component* p = parentComponent_;
+
+ while (p != 0)
+ {
+ const ComponentDeletionWatcher parentDeletionChecker (p);
+
+ for (i = p->numDeepMouseListeners; --i >= 0;)
+ {
+ ((MouseListener*) (p->mouseListeners_->getUnchecked (i)))->mouseDoubleClick (me);
+
+ if (deletionChecker.hasBeenDeleted() || parentDeletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, p->numDeepMouseListeners);
+ }
+
+ p = p->parentComponent_;
+ }
+ }
+ }
+
+ enableUnboundedMouseMovement (false);
+}
+
+void Component::internalMouseDrag (int x, int y, const int64 time)
+{
+ if (isValidComponent() && flags.draggingFlag)
+ {
+ flags.mouseOverFlag = reallyContains (x, y, false);
+
+ x += unboundedMouseOffsetX;
+ y += unboundedMouseOffsetY;
+ juce_LastMousePosX = x;
+ juce_LastMousePosY = y;
+ relativePositionToGlobal (juce_LastMousePosX, juce_LastMousePosY);
+
+ juce_MouseHasMovedSignificantlySincePressed
+ = juce_MouseHasMovedSignificantlySincePressed
+ || abs (juce_recentMouseDownX[0] - juce_LastMousePosX) >= 4
+ || abs (juce_recentMouseDownY[0] - juce_LastMousePosY) >= 4;
+
+ const ComponentDeletionWatcher deletionChecker (this);
+
+ int mdx = juce_recentMouseDownX[0];
+ int mdy = juce_recentMouseDownY[0];
+ globalPositionToRelative (mdx, mdy);
+
+ const MouseEvent me (x, y,
+ ModifierKeys::getCurrentModifiers(),
+ this,
+ Time (time),
+ mdx, mdy,
+ Time (juce_recentMouseDownTimes[0]),
+ countMouseClicks(),
+ juce_MouseHasMovedSignificantlySincePressed
+ || juce_recentMouseDownTimes[0] + 300 < time);
+
+ mouseDrag (me);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ Desktop::getInstance().resetTimer();
+
+ for (int i = Desktop::getInstance().mouseListeners.size(); --i >= 0;)
+ {
+ ((MouseListener*) Desktop::getInstance().mouseListeners[i])->mouseDrag (me);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, Desktop::getInstance().mouseListeners.size());
+ }
+
+ if (mouseListeners_ != 0)
+ {
+ for (int i = mouseListeners_->size(); --i >= 0;)
+ {
+ ((MouseListener*) mouseListeners_->getUnchecked (i))->mouseDrag (me);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, mouseListeners_->size());
+ }
+ }
+
+ const Component* p = parentComponent_;
+
+ while (p != 0)
+ {
+ const ComponentDeletionWatcher parentDeletionChecker (p);
+
+ for (int i = p->numDeepMouseListeners; --i >= 0;)
+ {
+ ((MouseListener*) (p->mouseListeners_->getUnchecked (i)))->mouseDrag (me);
+
+ if (deletionChecker.hasBeenDeleted() || parentDeletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, p->numDeepMouseListeners);
+ }
+
+ p = p->parentComponent_;
+ }
+
+ if (this == componentUnderMouse)
+ {
+ if (isUnboundedMouseModeOn)
+ {
+ Rectangle screenArea (getParentMonitorArea().expanded (-2, -2));
+
+ int mx, my;
+ Desktop::getMousePosition (mx, my);
+
+ if (! screenArea.contains (mx, my))
+ {
+ int deltaX = 0, deltaY = 0;
+
+ if (mx <= screenArea.getX() || mx >= screenArea.getRight())
+ deltaX = getScreenX() + getWidth() / 2 - mx;
+
+ if (my <= screenArea.getY() || my >= screenArea.getBottom())
+ deltaY = getScreenY() + getHeight() / 2 - my;
+
+ unboundedMouseOffsetX -= deltaX;
+ unboundedMouseOffsetY -= deltaY;
+
+ Desktop::setMousePosition (mx + deltaX,
+ my + deltaY);
+ }
+ else if (isCursorVisibleUntilOffscreen
+ && (unboundedMouseOffsetX != 0 || unboundedMouseOffsetY != 0)
+ && screenArea.contains (mx + unboundedMouseOffsetX,
+ my + unboundedMouseOffsetY))
+ {
+ mx += unboundedMouseOffsetX;
+ my += unboundedMouseOffsetY;
+ unboundedMouseOffsetX = 0;
+ unboundedMouseOffsetY = 0;
+
+ Desktop::setMousePosition (mx, my);
+ }
+ }
+
+ internalUpdateMouseCursor (false);
+ }
+ }
+}
+
+void Component::internalMouseMove (const int x, const int y, const int64 time)
+{
+ const ComponentDeletionWatcher deletionChecker (this);
+
+ if (isValidComponent())
+ {
+ const MouseEvent me (x, y,
+ ModifierKeys::getCurrentModifiers(),
+ this,
+ Time (time),
+ x, y,
+ Time (time),
+ 0, false);
+
+ if (isCurrentlyBlockedByAnotherModalComponent())
+ {
+ // allow blocked mouse-events to go to global listeners..
+ Desktop::getInstance().sendMouseMove();
+ }
+ else
+ {
+ if (this == componentUnderMouse)
+ internalUpdateMouseCursor (false);
+
+ flags.mouseOverFlag = true;
+
+ mouseMove (me);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ Desktop::getInstance().resetTimer();
+
+ for (int i = Desktop::getInstance().mouseListeners.size(); --i >= 0;)
+ {
+ ((MouseListener*) Desktop::getInstance().mouseListeners[i])->mouseMove (me);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, Desktop::getInstance().mouseListeners.size());
+ }
+
+ if (mouseListeners_ != 0)
+ {
+ for (int i = mouseListeners_->size(); --i >= 0;)
+ {
+ ((MouseListener*) mouseListeners_->getUnchecked (i))->mouseMove (me);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, mouseListeners_->size());
+ }
+ }
+
+ const Component* p = parentComponent_;
+
+ while (p != 0)
+ {
+ const ComponentDeletionWatcher parentDeletionChecker (p);
+
+ for (int i = p->numDeepMouseListeners; --i >= 0;)
+ {
+ ((MouseListener*) (p->mouseListeners_->getUnchecked (i)))->mouseMove (me);
+
+ if (deletionChecker.hasBeenDeleted() || parentDeletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, p->numDeepMouseListeners);
+ }
+
+ p = p->parentComponent_;
+ }
+ }
+ }
+}
+
+void Component::internalMouseWheel (const int intAmountX, const int intAmountY, const int64 time)
+{
+ const ComponentDeletionWatcher deletionChecker (this);
+
+ const float wheelIncrementX = intAmountX * (1.0f / 256.0f);
+ const float wheelIncrementY = intAmountY * (1.0f / 256.0f);
+
+ int mx, my;
+ getMouseXYRelative (mx, my);
+
+ const MouseEvent me (mx, my,
+ ModifierKeys::getCurrentModifiers(),
+ this,
+ Time (time),
+ mx, my,
+ Time (time),
+ 0, false);
+
+ if (isCurrentlyBlockedByAnotherModalComponent())
+ {
+ // allow blocked mouse-events to go to global listeners..
+ for (int i = Desktop::getInstance().mouseListeners.size(); --i >= 0;)
+ {
+ ((MouseListener*) Desktop::getInstance().mouseListeners[i])->mouseWheelMove (me, wheelIncrementX, wheelIncrementY);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, Desktop::getInstance().mouseListeners.size());
+ }
+ }
+ else
+ {
+ mouseWheelMove (me, wheelIncrementX, wheelIncrementY);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ for (int i = Desktop::getInstance().mouseListeners.size(); --i >= 0;)
+ {
+ ((MouseListener*) Desktop::getInstance().mouseListeners[i])->mouseWheelMove (me, wheelIncrementX, wheelIncrementY);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, Desktop::getInstance().mouseListeners.size());
+ }
+
+ if (mouseListeners_ != 0)
+ {
+ for (int i = mouseListeners_->size(); --i >= 0;)
+ {
+ ((MouseListener*) mouseListeners_->getUnchecked (i))->mouseWheelMove (me, wheelIncrementX, wheelIncrementY);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, mouseListeners_->size());
+ }
+ }
+
+ const Component* p = parentComponent_;
+
+ while (p != 0)
+ {
+ const ComponentDeletionWatcher parentDeletionChecker (p);
+
+ for (int i = p->numDeepMouseListeners; --i >= 0;)
+ {
+ ((MouseListener*) (p->mouseListeners_->getUnchecked (i)))->mouseWheelMove (me, wheelIncrementX, wheelIncrementY);
+
+ if (deletionChecker.hasBeenDeleted() || parentDeletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, p->numDeepMouseListeners);
+ }
+
+ p = p->parentComponent_;
+ }
+
+ sendFakeMouseMove();
+ }
+}
+
+void Component::sendFakeMouseMove() const
+{
+ ComponentPeer* const peer = getPeer();
+
+ if (peer != 0)
+ peer->sendFakeMouseMove();
+}
+
+void Component::broughtToFront()
+{
+}
+
+void Component::internalBroughtToFront()
+{
+ if (isValidComponent())
+ {
+ if (flags.hasHeavyweightPeerFlag)
+ Desktop::getInstance().componentBroughtToFront (this);
+
+ const ComponentDeletionWatcher deletionChecker (this);
+ broughtToFront();
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ if (componentListeners_ != 0)
+ {
+ for (int i = componentListeners_->size(); --i >= 0;)
+ {
+ ((ComponentListener*) componentListeners_->getUnchecked (i))
+ ->componentBroughtToFront (*this);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, componentListeners_->size());
+ }
+ }
+
+ // when brought to the front and there's a modal component blocking this one,
+ // we need to bring the modal one to the front instead..
+
+ Component* const cm = getCurrentlyModalComponent();
+
+ if (cm != 0 && cm->getTopLevelComponent() != getTopLevelComponent())
+ {
+ cm->getTopLevelComponent()->toFront (false);
+ }
+ }
+}
+
+void Component::focusGained (FocusChangeType)
+{
+ // base class does nothing
+}
+
+void Component::internalFocusGain (const FocusChangeType cause)
+{
+ const ComponentDeletionWatcher deletionChecker (this);
+
+ focusGained (cause);
+
+ if (! deletionChecker.hasBeenDeleted())
+ internalChildFocusChange (cause);
+}
+
+void Component::focusLost (FocusChangeType)
+{
+ // base class does nothing
+}
+
+void Component::internalFocusLoss (const FocusChangeType cause)
+{
+ const ComponentDeletionWatcher deletionChecker (this);
+
+ focusLost (focusChangedDirectly);
+
+ if (! deletionChecker.hasBeenDeleted())
+ internalChildFocusChange (cause);
+}
+
+void Component::focusOfChildComponentChanged (FocusChangeType /*cause*/)
+{
+ // base class does nothing
+}
+
+void Component::internalChildFocusChange (FocusChangeType cause)
+{
+ const bool childIsNowFocused = hasKeyboardFocus (true);
+
+ if (flags.childCompFocusedFlag != childIsNowFocused)
+ {
+ flags.childCompFocusedFlag = childIsNowFocused;
+
+ const ComponentDeletionWatcher deletionChecker (this);
+ focusOfChildComponentChanged (cause);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+ }
+
+ if (parentComponent_ != 0)
+ parentComponent_->internalChildFocusChange (cause);
+}
+
+bool Component::isEnabled() const throw()
+{
+ return (! flags.isDisabledFlag)
+ && (parentComponent_ == 0 || parentComponent_->isEnabled());
+}
+
+void Component::setEnabled (const bool shouldBeEnabled)
+{
+ if (flags.isDisabledFlag == shouldBeEnabled)
+ {
+ flags.isDisabledFlag = ! shouldBeEnabled;
+
+ // if any parent components are disabled, setting our flag won't make a difference,
+ // so no need to send a change message
+ if (parentComponent_ == 0 || parentComponent_->isEnabled())
+ sendEnablementChangeMessage();
+ }
+}
+
+void Component::sendEnablementChangeMessage()
+{
+ const ComponentDeletionWatcher deletionChecker (this);
+
+ enablementChanged();
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ for (int i = getNumChildComponents(); --i >= 0;)
+ {
+ Component* const c = getChildComponent (i);
+
+ if (c != 0)
+ {
+ c->sendEnablementChangeMessage();
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+ }
+ }
+}
+
+void Component::enablementChanged()
+{
+}
+
+void Component::setWantsKeyboardFocus (const bool wantsFocus) throw()
+{
+ flags.wantsFocusFlag = wantsFocus;
+}
+
+void Component::setMouseClickGrabsKeyboardFocus (const bool shouldGrabFocus)
+{
+ flags.dontFocusOnMouseClickFlag = ! shouldGrabFocus;
+}
+
+bool Component::getMouseClickGrabsKeyboardFocus() const throw()
+{
+ return ! flags.dontFocusOnMouseClickFlag;
+}
+
+bool Component::getWantsKeyboardFocus() const throw()
+{
+ return flags.wantsFocusFlag && ! flags.isDisabledFlag;
+}
+
+void Component::setFocusContainer (const bool isFocusContainer) throw()
+{
+ flags.isFocusContainerFlag = isFocusContainer;
+}
+
+bool Component::isFocusContainer() const throw()
+{
+ return flags.isFocusContainerFlag;
+}
+
+int Component::getExplicitFocusOrder() const throw()
+{
+ return getComponentPropertyInt (T("_jexfo"), false, 0);
+}
+
+void Component::setExplicitFocusOrder (const int newFocusOrderIndex) throw()
+{
+ setComponentProperty (T("_jexfo"), newFocusOrderIndex);
+}
+
+KeyboardFocusTraverser* Component::createFocusTraverser()
+{
+ if (flags.isFocusContainerFlag || parentComponent_ == 0)
+ return new KeyboardFocusTraverser();
+
+ return parentComponent_->createFocusTraverser();
+}
+
+void Component::takeKeyboardFocus (const FocusChangeType cause)
+{
+ // give the focus to this component
+ if (currentlyFocusedComponent != this)
+ {
+ JUCE_TRY
+ {
+ // get the focus onto our desktop window
+ ComponentPeer* const peer = getPeer();
+
+ if (peer != 0)
+ {
+ const ComponentDeletionWatcher deletionChecker (this);
+
+ peer->grabFocus();
+
+ if (peer->isFocused() && currentlyFocusedComponent != this)
+ {
+ Component* const componentLosingFocus = currentlyFocusedComponent;
+
+ currentlyFocusedComponent = this;
+
+ Desktop::getInstance().triggerFocusCallback();
+
+ // call this after setting currentlyFocusedComponent so that the one that's
+ // losing it has a chance to see where focus is going
+ if (componentLosingFocus->isValidComponent())
+ componentLosingFocus->internalFocusLoss (cause);
+
+ if (currentlyFocusedComponent == this)
+ {
+ focusGained (cause);
+
+ if (! deletionChecker.hasBeenDeleted())
+ internalChildFocusChange (cause);
+ }
+ }
+ }
+ }
+#if JUCE_CATCH_UNHANDLED_EXCEPTIONS
+ catch (const std::exception& e)
+ {
+ currentlyFocusedComponent = 0;
+ Desktop::getInstance().triggerFocusCallback();
+ JUCEApplication::sendUnhandledException (&e, __FILE__, __LINE__);
+ }
+ catch (...)
+ {
+ currentlyFocusedComponent = 0;
+ Desktop::getInstance().triggerFocusCallback();
+ JUCEApplication::sendUnhandledException (0, __FILE__, __LINE__);
+ }
+#endif
+ }
+}
+
+void Component::grabFocusInternal (const FocusChangeType cause, const bool canTryParent)
+{
+ if (isShowing())
+ {
+ if (flags.wantsFocusFlag && (isEnabled() || parentComponent_ == 0))
+ {
+ takeKeyboardFocus (cause);
+ }
+ else
+ {
+ if (isParentOf (currentlyFocusedComponent)
+ && currentlyFocusedComponent->isShowing())
+ {
+ // do nothing if the focused component is actually a child of ours..
+ }
+ else
+ {
+ // find the default child component..
+ KeyboardFocusTraverser* const traverser = createFocusTraverser();
+
+ if (traverser != 0)
+ {
+ Component* const defaultComp = traverser->getDefaultComponent (this);
+ delete traverser;
+
+ if (defaultComp != 0)
+ {
+ defaultComp->grabFocusInternal (cause, false);
+ return;
+ }
+ }
+
+ if (canTryParent && parentComponent_ != 0)
+ {
+ // if no children want it and we're allowed to try our parent comp,
+ // then pass up to parent, which will try our siblings.
+ parentComponent_->grabFocusInternal (cause, true);
+ }
+ }
+ }
+ }
+}
+
+void Component::grabKeyboardFocus()
+{
+ // if component methods are being called from threads other than the message
+ // thread, you'll need to use a MessageManagerLock object to make sure it's thread-safe.
+ checkMessageManagerIsLocked
+
+ grabFocusInternal (focusChangedDirectly);
+}
+
+void Component::moveKeyboardFocusToSibling (const bool moveToNext)
+{
+ // if component methods are being called from threads other than the message
+ // thread, you'll need to use a MessageManagerLock object to make sure it's thread-safe.
+ checkMessageManagerIsLocked
+
+ if (parentComponent_ != 0)
+ {
+ KeyboardFocusTraverser* const traverser = createFocusTraverser();
+
+ if (traverser != 0)
+ {
+ Component* const nextComp = moveToNext ? traverser->getNextComponent (this)
+ : traverser->getPreviousComponent (this);
+ delete traverser;
+
+ if (nextComp != 0)
+ {
+ if (nextComp->isCurrentlyBlockedByAnotherModalComponent())
+ {
+ const ComponentDeletionWatcher deletionChecker (nextComp);
+ internalModalInputAttempt();
+
+ if (deletionChecker.hasBeenDeleted()
+ || nextComp->isCurrentlyBlockedByAnotherModalComponent())
+ return;
+ }
+
+ nextComp->grabFocusInternal (focusChangedByTabKey);
+ return;
+ }
+ }
+
+ parentComponent_->moveKeyboardFocusToSibling (moveToNext);
+ }
+}
+
+bool Component::hasKeyboardFocus (const bool trueIfChildIsFocused) const throw()
+{
+ return (currentlyFocusedComponent == this)
+ || (trueIfChildIsFocused && isParentOf (currentlyFocusedComponent));
+}
+
+Component* JUCE_CALLTYPE Component::getCurrentlyFocusedComponent() throw()
+{
+ return currentlyFocusedComponent;
+}
+
+void Component::giveAwayFocus()
+{
+ // use a copy so we can clear the value before the call
+ Component* const componentLosingFocus = currentlyFocusedComponent;
+ currentlyFocusedComponent = 0;
+ Desktop::getInstance().triggerFocusCallback();
+
+ if (componentLosingFocus->isValidComponent())
+ componentLosingFocus->internalFocusLoss (focusChangedDirectly);
+}
+
+bool Component::isMouseOver() const throw()
+{
+ return flags.mouseOverFlag;
+}
+
+bool Component::isMouseButtonDown() const throw()
+{
+ return flags.draggingFlag;
+}
+
+bool Component::isMouseOverOrDragging() const throw()
+{
+ return flags.mouseOverFlag || flags.draggingFlag;
+}
+
+bool JUCE_CALLTYPE Component::isMouseButtonDownAnywhere() throw()
+{
+ return ModifierKeys::getCurrentModifiers().isAnyMouseButtonDown();
+}
+
+void Component::getMouseXYRelative (int& mx, int& my) const throw()
+{
+ Desktop::getMousePosition (mx, my);
+ globalPositionToRelative (mx, my);
+
+ mx += unboundedMouseOffsetX;
+ my += unboundedMouseOffsetY;
+}
+
+void Component::enableUnboundedMouseMovement (bool enable,
+ bool keepCursorVisibleUntilOffscreen) throw()
+{
+ enable = enable && isMouseButtonDown();
+ isCursorVisibleUntilOffscreen = keepCursorVisibleUntilOffscreen;
+
+ if (enable != isUnboundedMouseModeOn)
+ {
+ if ((! enable) && ((! isCursorVisibleUntilOffscreen)
+ || unboundedMouseOffsetX != 0
+ || unboundedMouseOffsetY != 0))
+ {
+ // when released, return the mouse to within the component's bounds
+
+ int mx, my;
+ getMouseXYRelative (mx, my);
+
+ mx = jlimit (0, getWidth(), mx);
+ my = jlimit (0, getHeight(), my);
+
+ relativePositionToGlobal (mx, my);
+
+ Desktop::setMousePosition (mx, my);
+ }
+
+ isUnboundedMouseModeOn = enable;
+ unboundedMouseOffsetX = 0;
+ unboundedMouseOffsetY = 0;
+
+ internalUpdateMouseCursor (true);
+ }
+}
+
+Component* JUCE_CALLTYPE Component::getComponentUnderMouse() throw()
+{
+ return componentUnderMouse;
+}
+
+const Rectangle Component::getParentMonitorArea() const throw()
+{
+ int centreX = getWidth() / 2;
+ int centreY = getHeight() / 2;
+ relativePositionToGlobal (centreX, centreY);
+
+ return Desktop::getInstance().getMonitorAreaContaining (centreX, centreY);
+}
+
+void Component::addKeyListener (KeyListener* const newListener) throw()
+{
+ if (keyListeners_ == 0)
+ keyListeners_ = new VoidArray (4);
+
+ keyListeners_->addIfNotAlreadyThere (newListener);
+}
+
+void Component::removeKeyListener (KeyListener* const listenerToRemove) throw()
+{
+ if (keyListeners_ != 0)
+ keyListeners_->removeValue (listenerToRemove);
+}
+
+bool Component::keyPressed (const KeyPress&)
+{
+ return false;
+}
+
+bool Component::keyStateChanged()
+{
+ return false;
+}
+
+void Component::modifierKeysChanged (const ModifierKeys& modifiers)
+{
+ if (parentComponent_ != 0)
+ parentComponent_->modifierKeysChanged (modifiers);
+}
+
+void Component::internalModifierKeysChanged()
+{
+ sendFakeMouseMove();
+
+ modifierKeysChanged (ModifierKeys::getCurrentModifiers());
+}
+
+ComponentPeer* Component::getPeer() const throw()
+{
+ if (flags.hasHeavyweightPeerFlag)
+ return ComponentPeer::getPeerFor (this);
+ else if (parentComponent_ != 0)
+ return parentComponent_->getPeer();
+ else
+ return 0;
+}
+
+const String Component::getComponentProperty (const String& keyName,
+ const bool useParentComponentIfNotFound,
+ const String& defaultReturnValue) const throw()
+{
+ if (propertySet_ != 0 && ((! useParentComponentIfNotFound) || propertySet_->containsKey (keyName)))
+ return propertySet_->getValue (keyName, defaultReturnValue);
+
+ if (useParentComponentIfNotFound && (parentComponent_ != 0))
+ return parentComponent_->getComponentProperty (keyName, true, defaultReturnValue);
+
+ return defaultReturnValue;
+}
+
+int Component::getComponentPropertyInt (const String& keyName,
+ const bool useParentComponentIfNotFound,
+ const int defaultReturnValue) const throw()
+{
+ if (propertySet_ != 0 && ((! useParentComponentIfNotFound) || propertySet_->containsKey (keyName)))
+ return propertySet_->getIntValue (keyName, defaultReturnValue);
+
+ if (useParentComponentIfNotFound && (parentComponent_ != 0))
+ return parentComponent_->getComponentPropertyInt (keyName, true, defaultReturnValue);
+
+ return defaultReturnValue;
+}
+
+double Component::getComponentPropertyDouble (const String& keyName,
+ const bool useParentComponentIfNotFound,
+ const double defaultReturnValue) const throw()
+{
+ if (propertySet_ != 0 && ((! useParentComponentIfNotFound) || propertySet_->containsKey (keyName)))
+ return propertySet_->getDoubleValue (keyName, defaultReturnValue);
+
+ if (useParentComponentIfNotFound && (parentComponent_ != 0))
+ return parentComponent_->getComponentPropertyDouble (keyName, true, defaultReturnValue);
+
+ return defaultReturnValue;
+}
+
+bool Component::getComponentPropertyBool (const String& keyName,
+ const bool useParentComponentIfNotFound,
+ const bool defaultReturnValue) const throw()
+{
+ if (propertySet_ != 0 && ((! useParentComponentIfNotFound) || propertySet_->containsKey (keyName)))
+ return propertySet_->getBoolValue (keyName, defaultReturnValue);
+
+ if (useParentComponentIfNotFound && (parentComponent_ != 0))
+ return parentComponent_->getComponentPropertyBool (keyName, true, defaultReturnValue);
+
+ return defaultReturnValue;
+}
+
+const Colour Component::getComponentPropertyColour (const String& keyName,
+ const bool useParentComponentIfNotFound,
+ const Colour& defaultReturnValue) const throw()
+{
+ return Colour ((uint32) getComponentPropertyInt (keyName,
+ useParentComponentIfNotFound,
+ defaultReturnValue.getARGB()));
+}
+
+void Component::setComponentProperty (const String& keyName, const String& value) throw()
+{
+ if (propertySet_ == 0)
+ propertySet_ = new PropertySet();
+
+ propertySet_->setValue (keyName, value);
+}
+
+void Component::setComponentProperty (const String& keyName, const int value) throw()
+{
+ if (propertySet_ == 0)
+ propertySet_ = new PropertySet();
+
+ propertySet_->setValue (keyName, value);
+}
+
+void Component::setComponentProperty (const String& keyName, const double value) throw()
+{
+ if (propertySet_ == 0)
+ propertySet_ = new PropertySet();
+
+ propertySet_->setValue (keyName, value);
+}
+
+void Component::setComponentProperty (const String& keyName, const bool value) throw()
+{
+ if (propertySet_ == 0)
+ propertySet_ = new PropertySet();
+
+ propertySet_->setValue (keyName, value);
+}
+
+void Component::setComponentProperty (const String& keyName, const Colour& colour) throw()
+{
+ setComponentProperty (keyName, (int) colour.getARGB());
+}
+
+void Component::removeComponentProperty (const String& keyName) throw()
+{
+ if (propertySet_ != 0)
+ propertySet_->removeValue (keyName);
+}
+
+ComponentDeletionWatcher::ComponentDeletionWatcher (const Component* const componentToWatch_) throw()
+ : componentToWatch (componentToWatch_),
+ componentUID (componentToWatch_->getComponentUID())
+{
+ // not possible to check on an already-deleted object..
+ jassert (componentToWatch_->isValidComponent());
+}
+
+ComponentDeletionWatcher::~ComponentDeletionWatcher() throw() {}
+
+bool ComponentDeletionWatcher::hasBeenDeleted() const throw()
+{
+ return ! (componentToWatch->isValidComponent()
+ && componentToWatch->getComponentUID() == componentUID);
+}
+
+const Component* ComponentDeletionWatcher::getComponent() const throw()
+{
+ return hasBeenDeleted() ? 0 : componentToWatch;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_Component.cpp *********/
+
+/********* Start of inlined file: juce_ComponentListener.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+void ComponentListener::componentMovedOrResized (Component&, bool, bool)
+{
+}
+
+void ComponentListener::componentBroughtToFront (Component&)
+{
+}
+
+void ComponentListener::componentVisibilityChanged (Component&)
+{
+}
+
+void ComponentListener::componentChildrenChanged (Component&)
+{
+}
+
+void ComponentListener::componentParentHierarchyChanged (Component&)
+{
+}
+
+void ComponentListener::componentNameChanged (Component&)
+{
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ComponentListener.cpp *********/
+
+/********* Start of inlined file: juce_Desktop.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+extern void juce_updateMultiMonitorInfo (Array & monitorCoords,
+ const bool clipToWorkArea) throw();
+
+static Desktop* juce_desktopInstance = 0;
+
+Desktop::Desktop() throw()
+ : mouseListeners (2),
+ desktopComponents (4),
+ monitorCoordsClipped (2),
+ monitorCoordsUnclipped (2),
+ lastMouseX (0),
+ lastMouseY (0)
+{
+ refreshMonitorSizes();
+}
+
+Desktop::~Desktop() throw()
+{
+ jassert (juce_desktopInstance == this);
+ juce_desktopInstance = 0;
+
+ // doh! If you don't delete all your windows before exiting, you're going to
+ // be leaking memory!
+ jassert (desktopComponents.size() == 0);
+}
+
+Desktop& JUCE_CALLTYPE Desktop::getInstance() throw()
+{
+ if (juce_desktopInstance == 0)
+ juce_desktopInstance = new Desktop();
+
+ return *juce_desktopInstance;
+}
+
+void Desktop::refreshMonitorSizes() throw()
+{
+ const Array oldClipped (monitorCoordsClipped);
+ const Array oldUnclipped (monitorCoordsUnclipped);
+
+ monitorCoordsClipped.clear();
+ monitorCoordsUnclipped.clear();
+ juce_updateMultiMonitorInfo (monitorCoordsClipped, true);
+ juce_updateMultiMonitorInfo (monitorCoordsUnclipped, false);
+ jassert (monitorCoordsClipped.size() > 0
+ && monitorCoordsClipped.size() == monitorCoordsUnclipped.size());
+
+ if (oldClipped != monitorCoordsClipped
+ || oldUnclipped != monitorCoordsUnclipped)
+ {
+ for (int i = ComponentPeer::getNumPeers(); --i >= 0;)
+ {
+ ComponentPeer* const p = ComponentPeer::getPeer (i);
+ if (p != 0)
+ p->handleScreenSizeChange();
+ }
+ }
+}
+
+int Desktop::getNumDisplayMonitors() const throw()
+{
+ return monitorCoordsClipped.size();
+}
+
+const Rectangle Desktop::getDisplayMonitorCoordinates (const int index, const bool clippedToWorkArea) const throw()
+{
+ return clippedToWorkArea ? monitorCoordsClipped [index]
+ : monitorCoordsUnclipped [index];
+}
+
+const RectangleList Desktop::getAllMonitorDisplayAreas (const bool clippedToWorkArea) const throw()
+{
+ RectangleList rl;
+
+ for (int i = 0; i < getNumDisplayMonitors(); ++i)
+ rl.addWithoutMerging (getDisplayMonitorCoordinates (i, clippedToWorkArea));
+
+ return rl;
+}
+
+const Rectangle Desktop::getMainMonitorArea (const bool clippedToWorkArea) const throw()
+{
+ return getDisplayMonitorCoordinates (0, clippedToWorkArea);
+}
+
+const Rectangle Desktop::getMonitorAreaContaining (int cx, int cy, const bool clippedToWorkArea) const throw()
+{
+ Rectangle best (getMainMonitorArea (clippedToWorkArea));
+ double bestDistance = 1.0e10;
+
+ for (int i = getNumDisplayMonitors(); --i >= 0;)
+ {
+ const Rectangle rect (getDisplayMonitorCoordinates (i, clippedToWorkArea));
+
+ if (rect.contains (cx, cy))
+ return rect;
+
+ const double distance = juce_hypot ((double) (rect.getCentreX() - cx),
+ (double) (rect.getCentreY() - cy));
+
+ if (distance < bestDistance)
+ {
+ bestDistance = distance;
+ best = rect;
+ }
+ }
+
+ return best;
+}
+
+int Desktop::getNumComponents() const throw()
+{
+ return desktopComponents.size();
+}
+
+Component* Desktop::getComponent (const int index) const throw()
+{
+ return (Component*) desktopComponents [index];
+}
+
+Component* Desktop::findComponentAt (const int screenX,
+ const int screenY) const
+{
+ for (int i = desktopComponents.size(); --i >= 0;)
+ {
+ Component* const c = (Component*) desktopComponents.getUnchecked(i);
+
+ int x = screenX, y = screenY;
+ c->globalPositionToRelative (x, y);
+
+ if (c->contains (x, y))
+ return c->getComponentAt (x, y);
+ }
+
+ return 0;
+}
+
+void Desktop::addDesktopComponent (Component* const c) throw()
+{
+ jassert (c != 0);
+ jassert (! desktopComponents.contains (c));
+ desktopComponents.addIfNotAlreadyThere (c);
+}
+
+void Desktop::removeDesktopComponent (Component* const c) throw()
+{
+ desktopComponents.removeValue (c);
+}
+
+void Desktop::componentBroughtToFront (Component* const c) throw()
+{
+ const int index = desktopComponents.indexOf (c);
+ jassert (index >= 0);
+
+ if (index >= 0)
+ desktopComponents.move (index, -1);
+}
+
+// from Component.cpp
+extern int juce_recentMouseDownX [4];
+extern int juce_recentMouseDownY [4];
+extern int juce_MouseClickCounter;
+
+void Desktop::getLastMouseDownPosition (int& x, int& y) throw()
+{
+ x = juce_recentMouseDownX [0];
+ y = juce_recentMouseDownY [0];
+}
+
+int Desktop::getMouseButtonClickCounter() throw()
+{
+ return juce_MouseClickCounter;
+}
+
+void Desktop::addGlobalMouseListener (MouseListener* const listener) throw()
+{
+ jassert (listener != 0);
+
+ if (listener != 0)
+ {
+ mouseListeners.add (listener);
+ resetTimer();
+ }
+}
+
+void Desktop::removeGlobalMouseListener (MouseListener* const listener) throw()
+{
+ mouseListeners.removeValue (listener);
+ resetTimer();
+}
+
+void Desktop::addFocusChangeListener (FocusChangeListener* const listener) throw()
+{
+ jassert (listener != 0);
+
+ if (listener != 0)
+ focusListeners.add (listener);
+}
+
+void Desktop::removeFocusChangeListener (FocusChangeListener* const listener) throw()
+{
+ focusListeners.removeValue (listener);
+}
+
+void Desktop::triggerFocusCallback() throw()
+{
+ triggerAsyncUpdate();
+}
+
+void Desktop::handleAsyncUpdate()
+{
+ for (int i = focusListeners.size(); --i >= 0;)
+ {
+ ((FocusChangeListener*) focusListeners.getUnchecked (i))->globalFocusChanged (Component::getCurrentlyFocusedComponent());
+ i = jmin (i, focusListeners.size());
+ }
+}
+
+void Desktop::timerCallback()
+{
+ int x, y;
+ getMousePosition (x, y);
+
+ if (lastMouseX != x || lastMouseY != y)
+ sendMouseMove();
+}
+
+void Desktop::sendMouseMove()
+{
+ if (mouseListeners.size() > 0)
+ {
+ startTimer (20);
+
+ int x, y;
+ getMousePosition (x, y);
+ lastMouseX = x;
+ lastMouseY = y;
+
+ Component* const target = findComponentAt (x, y);
+
+ if (target != 0)
+ {
+ target->globalPositionToRelative (x, y);
+
+ ComponentDeletionWatcher deletionChecker (target);
+
+ const MouseEvent me (x, y,
+ ModifierKeys::getCurrentModifiers(),
+ target,
+ Time::getCurrentTime(),
+ x, y,
+ Time::getCurrentTime(),
+ 0, false);
+
+ for (int i = mouseListeners.size(); --i >= 0;)
+ {
+ if (ModifierKeys::getCurrentModifiers().isAnyMouseButtonDown())
+ ((MouseListener*) mouseListeners[i])->mouseDrag (me);
+ else
+ ((MouseListener*) mouseListeners[i])->mouseMove (me);
+
+ if (deletionChecker.hasBeenDeleted())
+ return;
+
+ i = jmin (i, mouseListeners.size());
+ }
+ }
+ }
+}
+
+void Desktop::resetTimer() throw()
+{
+ if (mouseListeners.size() == 0)
+ stopTimer();
+ else
+ startTimer (100);
+
+ getMousePosition (lastMouseX, lastMouseY);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_Desktop.cpp *********/
+
+/********* Start of inlined file: juce_ArrowButton.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ArrowButton::ArrowButton (const String& name,
+ float arrowDirectionInRadians,
+ const Colour& arrowColour)
+ : Button (name),
+ colour (arrowColour)
+{
+ path.lineTo (0.0f, 1.0f);
+ path.lineTo (1.0f, 0.5f);
+ path.closeSubPath();
+
+ path.applyTransform (AffineTransform::rotation (float_Pi * 2.0f * arrowDirectionInRadians,
+ 0.5f, 0.5f));
+
+ setComponentEffect (&shadow);
+ buttonStateChanged();
+}
+
+ArrowButton::~ArrowButton()
+{
+}
+
+void ArrowButton::paintButton (Graphics& g,
+ bool /*isMouseOverButton*/,
+ bool /*isButtonDown*/)
+{
+ g.setColour (colour);
+
+ g.fillPath (path, path.getTransformToScaleToFit ((float) offset,
+ (float) offset,
+ (float) (getWidth() - 3),
+ (float) (getHeight() - 3),
+ false));
+}
+
+void ArrowButton::buttonStateChanged()
+{
+ offset = (isDown()) ? 1 : 0;
+
+ shadow.setShadowProperties ((isDown()) ? 1.2f : 3.0f,
+ 0.3f, -1, 0);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ArrowButton.cpp *********/
+
+/********* Start of inlined file: juce_Button.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+Button::Button (const String& name)
+ : Component (name),
+ shortcuts (2),
+ keySource (0),
+ text (name),
+ buttonListeners (2),
+ repeatTimer (0),
+ buttonPressTime (0),
+ lastTimeCallbackTime (0),
+ commandManagerToUse (0),
+ autoRepeatDelay (-1),
+ autoRepeatSpeed (0),
+ autoRepeatMinimumDelay (-1),
+ radioGroupId (0),
+ commandID (0),
+ connectedEdgeFlags (0),
+ buttonState (buttonNormal),
+ isOn (false),
+ clickTogglesState (false),
+ needsToRelease (false),
+ needsRepainting (false),
+ isKeyDown (false),
+ triggerOnMouseDown (false),
+ generateTooltip (false)
+{
+ setWantsKeyboardFocus (true);
+}
+
+Button::~Button()
+{
+ if (commandManagerToUse != 0)
+ commandManagerToUse->removeListener (this);
+
+ delete repeatTimer;
+ clearShortcuts();
+}
+
+void Button::setButtonText (const String& newText) throw()
+{
+ if (text != newText)
+ {
+ text = newText;
+ repaint();
+ }
+}
+
+void Button::setTooltip (const String& newTooltip)
+{
+ SettableTooltipClient::setTooltip (newTooltip);
+ generateTooltip = false;
+}
+
+const String Button::getTooltip()
+{
+ if (generateTooltip && commandManagerToUse != 0 && commandID != 0)
+ {
+ String tt (commandManagerToUse->getDescriptionOfCommand (commandID));
+
+ Array keyPresses (commandManagerToUse->getKeyMappings()->getKeyPressesAssignedToCommand (commandID));
+
+ for (int i = 0; i < keyPresses.size(); ++i)
+ {
+ const String key (keyPresses.getReference(i).getTextDescription());
+
+ if (key.length() == 1)
+ tt << " [shortcut: '" << key << "']";
+ else
+ tt << " [" << key << ']';
+ }
+
+ return tt;
+ }
+
+ return SettableTooltipClient::getTooltip();
+}
+
+void Button::setConnectedEdges (const int connectedEdgeFlags_) throw()
+{
+ if (connectedEdgeFlags != connectedEdgeFlags_)
+ {
+ connectedEdgeFlags = connectedEdgeFlags_;
+ repaint();
+ }
+}
+
+void Button::setToggleState (const bool shouldBeOn,
+ const bool sendChangeNotification)
+{
+ if (shouldBeOn != isOn)
+ {
+ const ComponentDeletionWatcher deletionWatcher (this);
+
+ isOn = shouldBeOn;
+ repaint();
+
+ if (sendChangeNotification)
+ sendClickMessage (ModifierKeys());
+
+ if ((! deletionWatcher.hasBeenDeleted()) && isOn)
+ turnOffOtherButtonsInGroup (sendChangeNotification);
+ }
+}
+
+void Button::setClickingTogglesState (const bool shouldToggle) throw()
+{
+ clickTogglesState = shouldToggle;
+
+ // if you've got clickTogglesState turned on, you shouldn't also connect the button
+ // up to be a command invoker. Instead, your command handler must flip the state of whatever
+ // it is that this button represents, and the button will update its state to reflect this
+ // in the applicationCommandListChanged() method.
+ jassert (commandManagerToUse == 0 || ! clickTogglesState);
+}
+
+bool Button::getClickingTogglesState() const throw()
+{
+ return clickTogglesState;
+}
+
+void Button::setRadioGroupId (const int newGroupId)
+{
+ if (radioGroupId != newGroupId)
+ {
+ radioGroupId = newGroupId;
+
+ if (isOn)
+ turnOffOtherButtonsInGroup (true);
+ }
+}
+
+void Button::turnOffOtherButtonsInGroup (const bool sendChangeNotification)
+{
+ Component* const p = getParentComponent();
+
+ if (p != 0 && radioGroupId != 0)
+ {
+ const ComponentDeletionWatcher deletionWatcher (this);
+
+ for (int i = p->getNumChildComponents(); --i >= 0;)
+ {
+ Component* const c = p->getChildComponent (i);
+
+ if (c != this)
+ {
+ Button* const b = dynamic_cast (c);
+
+ if (b != 0 && b->getRadioGroupId() == radioGroupId)
+ {
+ b->setToggleState (false, sendChangeNotification);
+
+ if (deletionWatcher.hasBeenDeleted())
+ return;
+ }
+ }
+ }
+ }
+}
+
+void Button::enablementChanged()
+{
+ updateState (0);
+ repaint();
+}
+
+Button::ButtonState Button::updateState (const MouseEvent* const e) throw()
+{
+ ButtonState state = buttonNormal;
+
+ if (isEnabled() && isVisible() && ! isCurrentlyBlockedByAnotherModalComponent())
+ {
+ int mx, my;
+
+ if (e == 0)
+ {
+ getMouseXYRelative (mx, my);
+ }
+ else
+ {
+ const MouseEvent e2 (e->getEventRelativeTo (this));
+ mx = e2.x;
+ my = e2.y;
+ }
+
+ const bool over = reallyContains (mx, my, true);
+ const bool down = isMouseButtonDown();
+
+ if ((down && (over || (triggerOnMouseDown && buttonState == buttonDown))) || isKeyDown)
+ state = buttonDown;
+ else if (over)
+ state = buttonOver;
+ }
+
+ setState (state);
+ return state;
+}
+
+void Button::setState (const ButtonState newState)
+{
+ if (buttonState != newState)
+ {
+ buttonState = newState;
+ repaint();
+
+ if (buttonState == buttonDown)
+ {
+ buttonPressTime = Time::getApproximateMillisecondCounter();
+ lastTimeCallbackTime = buttonPressTime;
+ }
+
+ sendStateMessage();
+ }
+}
+
+bool Button::isDown() const throw()
+{
+ return buttonState == buttonDown;
+}
+
+bool Button::isOver() const throw()
+{
+ return buttonState != buttonNormal;
+}
+
+void Button::buttonStateChanged()
+{
+}
+
+uint32 Button::getMillisecondsSinceButtonDown() const throw()
+{
+ const uint32 now = Time::getApproximateMillisecondCounter();
+ return now > buttonPressTime ? now - buttonPressTime : 0;
+}
+
+void Button::setTriggeredOnMouseDown (const bool isTriggeredOnMouseDown) throw()
+{
+ triggerOnMouseDown = isTriggeredOnMouseDown;
+}
+
+void Button::clicked()
+{
+}
+
+void Button::clicked (const ModifierKeys& /*modifiers*/)
+{
+ clicked();
+}
+
+static const int clickMessageId = 0x2f3f4f99;
+
+void Button::triggerClick()
+{
+ postCommandMessage (clickMessageId);
+}
+
+void Button::internalClickCallback (const ModifierKeys& modifiers)
+{
+ if (clickTogglesState)
+ setToggleState ((radioGroupId != 0) || ! isOn, false);
+
+ sendClickMessage (modifiers);
+}
+
+void Button::flashButtonState() throw()
+{
+ if (isEnabled())
+ {
+ needsToRelease = true;
+ setState (buttonDown);
+ getRepeatTimer().startTimer (100);
+ }
+}
+
+void Button::handleCommandMessage (int commandId)
+{
+ if (commandId == clickMessageId)
+ {
+ if (isEnabled())
+ {
+ flashButtonState();
+ internalClickCallback (ModifierKeys::getCurrentModifiers());
+ }
+ }
+ else
+ {
+ Component::handleCommandMessage (commandId);
+ }
+}
+
+void Button::addButtonListener (ButtonListener* const newListener) throw()
+{
+ jassert (newListener != 0);
+ jassert (! buttonListeners.contains (newListener)); // trying to add a listener to the list twice!
+
+ if (newListener != 0)
+ buttonListeners.add (newListener);
+}
+
+void Button::removeButtonListener (ButtonListener* const listener) throw()
+{
+ jassert (buttonListeners.contains (listener)); // trying to remove a listener that isn't on the list!
+
+ buttonListeners.removeValue (listener);
+}
+
+void Button::sendClickMessage (const ModifierKeys& modifiers)
+{
+ const ComponentDeletionWatcher cdw (this);
+
+ if (commandManagerToUse != 0 && commandID != 0)
+ {
+ ApplicationCommandTarget::InvocationInfo info (commandID);
+ info.invocationMethod = ApplicationCommandTarget::InvocationInfo::fromButton;
+ info.originatingComponent = this;
+
+ commandManagerToUse->invoke (info, true);
+ }
+
+ clicked (modifiers);
+
+ if (! cdw.hasBeenDeleted())
+ {
+ for (int i = buttonListeners.size(); --i >= 0;)
+ {
+ ButtonListener* const bl = (ButtonListener*) buttonListeners[i];
+
+ if (bl != 0)
+ {
+ bl->buttonClicked (this);
+
+ if (cdw.hasBeenDeleted())
+ return;
+ }
+ }
+ }
+}
+
+void Button::sendStateMessage()
+{
+ const ComponentDeletionWatcher cdw (this);
+
+ buttonStateChanged();
+
+ if (cdw.hasBeenDeleted())
+ return;
+
+ for (int i = buttonListeners.size(); --i >= 0;)
+ {
+ ButtonListener* const bl = (ButtonListener*) buttonListeners[i];
+
+ if (bl != 0)
+ {
+ bl->buttonStateChanged (this);
+
+ if (cdw.hasBeenDeleted())
+ return;
+ }
+ }
+}
+
+void Button::paint (Graphics& g)
+{
+ if (needsToRelease && isEnabled())
+ {
+ needsToRelease = false;
+ needsRepainting = true;
+ }
+
+ paintButton (g, isOver(), isDown());
+}
+
+void Button::mouseEnter (const MouseEvent& e)
+{
+ updateState (&e);
+}
+
+void Button::mouseExit (const MouseEvent& e)
+{
+ updateState (&e);
+}
+
+void Button::mouseDown (const MouseEvent& e)
+{
+ updateState (&e);
+
+ if (isDown())
+ {
+ if (autoRepeatDelay >= 0)
+ getRepeatTimer().startTimer (autoRepeatDelay);
+
+ if (triggerOnMouseDown)
+ internalClickCallback (e.mods);
+ }
+}
+
+void Button::mouseUp (const MouseEvent& e)
+{
+ const bool wasDown = isDown();
+ updateState (&e);
+
+ if (wasDown && isOver() && ! triggerOnMouseDown)
+ internalClickCallback (e.mods);
+}
+
+void Button::mouseDrag (const MouseEvent& e)
+{
+ const ButtonState oldState = buttonState;
+ updateState (&e);
+
+ if (autoRepeatDelay >= 0 && buttonState != oldState && isDown())
+ getRepeatTimer().startTimer (autoRepeatSpeed);
+}
+
+void Button::focusGained (FocusChangeType)
+{
+ updateState (0);
+ repaint();
+}
+
+void Button::focusLost (FocusChangeType)
+{
+ updateState (0);
+ repaint();
+}
+
+void Button::setVisible (bool shouldBeVisible)
+{
+ if (shouldBeVisible != isVisible())
+ {
+ Component::setVisible (shouldBeVisible);
+
+ if (! shouldBeVisible)
+ needsToRelease = false;
+
+ updateState (0);
+ }
+ else
+ {
+ Component::setVisible (shouldBeVisible);
+ }
+}
+
+void Button::parentHierarchyChanged()
+{
+ Component* const newKeySource = (shortcuts.size() == 0) ? 0 : getTopLevelComponent();
+
+ if (newKeySource != keySource)
+ {
+ if (keySource->isValidComponent())
+ keySource->removeKeyListener (this);
+
+ keySource = newKeySource;
+
+ if (keySource->isValidComponent())
+ keySource->addKeyListener (this);
+ }
+}
+
+void Button::setCommandToTrigger (ApplicationCommandManager* const commandManagerToUse_,
+ const int commandID_,
+ const bool generateTooltip_)
+{
+ commandID = commandID_;
+ generateTooltip = generateTooltip_;
+
+ if (commandManagerToUse != commandManagerToUse_)
+ {
+ if (commandManagerToUse != 0)
+ commandManagerToUse->removeListener (this);
+
+ commandManagerToUse = commandManagerToUse_;
+
+ if (commandManagerToUse != 0)
+ commandManagerToUse->addListener (this);
+
+ // if you've got clickTogglesState turned on, you shouldn't also connect the button
+ // up to be a command invoker. Instead, your command handler must flip the state of whatever
+ // it is that this button represents, and the button will update its state to reflect this
+ // in the applicationCommandListChanged() method.
+ jassert (commandManagerToUse == 0 || ! clickTogglesState);
+ }
+
+ if (commandManagerToUse != 0)
+ applicationCommandListChanged();
+ else
+ setEnabled (true);
+}
+
+void Button::applicationCommandInvoked (const ApplicationCommandTarget::InvocationInfo& info)
+{
+ if (info.commandID == commandID
+ && (info.commandFlags & ApplicationCommandInfo::dontTriggerVisualFeedback) == 0)
+ {
+ flashButtonState();
+ }
+}
+
+void Button::applicationCommandListChanged()
+{
+ if (commandManagerToUse != 0)
+ {
+ ApplicationCommandInfo info (0);
+
+ ApplicationCommandTarget* const target = commandManagerToUse->getTargetForCommand (commandID, info);
+
+ setEnabled (target != 0 && (info.flags & ApplicationCommandInfo::isDisabled) == 0);
+
+ if (target != 0)
+ setToggleState ((info.flags & ApplicationCommandInfo::isTicked) != 0, false);
+ }
+}
+
+void Button::addShortcut (const KeyPress& key)
+{
+ if (key.isValid())
+ {
+ jassert (! isRegisteredForShortcut (key)); // already registered!
+
+ shortcuts.add (key);
+ parentHierarchyChanged();
+ }
+}
+
+void Button::clearShortcuts()
+{
+ shortcuts.clear();
+
+ parentHierarchyChanged();
+}
+
+bool Button::isShortcutPressed() const throw()
+{
+ if (! isCurrentlyBlockedByAnotherModalComponent())
+ {
+ for (int i = shortcuts.size(); --i >= 0;)
+ if (shortcuts.getReference(i).isCurrentlyDown())
+ return true;
+ }
+
+ return false;
+}
+
+bool Button::isRegisteredForShortcut (const KeyPress& key) const throw()
+{
+ for (int i = shortcuts.size(); --i >= 0;)
+ if (key == shortcuts.getReference(i))
+ return true;
+
+ return false;
+}
+
+bool Button::keyStateChanged (Component*)
+{
+ if (! isEnabled())
+ return false;
+
+ const bool wasDown = isKeyDown;
+ isKeyDown = isShortcutPressed();
+
+ if (autoRepeatDelay >= 0 && (isKeyDown && ! wasDown))
+ getRepeatTimer().startTimer (autoRepeatDelay);
+
+ updateState (0);
+
+ if (isEnabled() && wasDown && ! isKeyDown)
+ internalClickCallback (ModifierKeys::getCurrentModifiers());
+
+ return isKeyDown || wasDown;
+}
+
+bool Button::keyPressed (const KeyPress&, Component*)
+{
+ // returning true will avoid forwarding events for keys that we're using as shortcuts
+ return isShortcutPressed();
+}
+
+bool Button::keyPressed (const KeyPress& key)
+{
+ if (isEnabled() && key.isKeyCode (KeyPress::returnKey))
+ {
+ triggerClick();
+ return true;
+ }
+
+ return false;
+}
+
+void Button::setRepeatSpeed (const int initialDelayMillisecs,
+ const int repeatMillisecs,
+ const int minimumDelayInMillisecs) throw()
+{
+ autoRepeatDelay = initialDelayMillisecs;
+ autoRepeatSpeed = repeatMillisecs;
+ autoRepeatMinimumDelay = jmin (autoRepeatSpeed, minimumDelayInMillisecs);
+}
+
+void Button::repeatTimerCallback() throw()
+{
+ if (needsRepainting)
+ {
+ getRepeatTimer().stopTimer();
+ updateState (0);
+ needsRepainting = false;
+ }
+ else if (autoRepeatSpeed > 0 && (isKeyDown || (updateState (0) == buttonDown)))
+ {
+ int repeatSpeed = autoRepeatSpeed;
+
+ if (autoRepeatMinimumDelay >= 0)
+ {
+ double timeHeldDown = jmin (1.0, getMillisecondsSinceButtonDown() / 4000.0);
+ timeHeldDown *= timeHeldDown;
+
+ repeatSpeed = repeatSpeed + (int) (timeHeldDown * (autoRepeatMinimumDelay - repeatSpeed));
+ }
+
+ repeatSpeed = jmax (1, repeatSpeed);
+
+ getRepeatTimer().startTimer (repeatSpeed);
+
+ const uint32 now = Time::getApproximateMillisecondCounter();
+ const int numTimesToCallback
+ = (now > lastTimeCallbackTime) ? jmax (1, (now - lastTimeCallbackTime) / repeatSpeed) : 1;
+
+ lastTimeCallbackTime = now;
+
+ const ComponentDeletionWatcher cdw (this);
+
+ for (int i = numTimesToCallback; --i >= 0;)
+ {
+ internalClickCallback (ModifierKeys::getCurrentModifiers());
+
+ if (cdw.hasBeenDeleted() || ! isDown())
+ return;
+ }
+ }
+ else if (! needsToRelease)
+ {
+ getRepeatTimer().stopTimer();
+ }
+}
+
+class InternalButtonRepeatTimer : public Timer
+{
+public:
+ InternalButtonRepeatTimer (Button& owner_) throw()
+ : owner (owner_)
+ {
+ }
+
+ ~InternalButtonRepeatTimer()
+ {
+ }
+
+ void timerCallback()
+ {
+ owner.repeatTimerCallback();
+ }
+
+private:
+ Button& owner;
+
+ InternalButtonRepeatTimer (const InternalButtonRepeatTimer&);
+ const InternalButtonRepeatTimer& operator= (const InternalButtonRepeatTimer&);
+};
+
+Timer& Button::getRepeatTimer() throw()
+{
+ if (repeatTimer == 0)
+ repeatTimer = new InternalButtonRepeatTimer (*this);
+
+ return *repeatTimer;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_Button.cpp *********/
+
+/********* Start of inlined file: juce_DrawableButton.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+DrawableButton::DrawableButton (const String& name,
+ const DrawableButton::ButtonStyle buttonStyle)
+ : Button (name),
+ style (buttonStyle),
+ normalImage (0),
+ overImage (0),
+ downImage (0),
+ disabledImage (0),
+ normalImageOn (0),
+ overImageOn (0),
+ downImageOn (0),
+ disabledImageOn (0),
+ edgeIndent (3)
+{
+ if (buttonStyle == ImageOnButtonBackground)
+ {
+ backgroundOff = Colour (0xffbbbbff);
+ backgroundOn = Colour (0xff3333ff);
+ }
+ else
+ {
+ backgroundOff = Colours::transparentBlack;
+ backgroundOn = Colour (0xaabbbbff);
+ }
+}
+
+DrawableButton::~DrawableButton()
+{
+ deleteImages();
+}
+
+void DrawableButton::deleteImages()
+{
+ deleteAndZero (normalImage);
+ deleteAndZero (overImage);
+ deleteAndZero (downImage);
+ deleteAndZero (disabledImage);
+ deleteAndZero (normalImageOn);
+ deleteAndZero (overImageOn);
+ deleteAndZero (downImageOn);
+ deleteAndZero (disabledImageOn);
+}
+
+void DrawableButton::setImages (const Drawable* normal,
+ const Drawable* over,
+ const Drawable* down,
+ const Drawable* disabled,
+ const Drawable* normalOn,
+ const Drawable* overOn,
+ const Drawable* downOn,
+ const Drawable* disabledOn)
+{
+ deleteImages();
+
+ jassert (normal != 0); // you really need to give it at least a normal image..
+
+ if (normal != 0)
+ normalImage = normal->createCopy();
+
+ if (over != 0)
+ overImage = over->createCopy();
+
+ if (down != 0)
+ downImage = down->createCopy();
+
+ if (disabled != 0)
+ disabledImage = disabled->createCopy();
+
+ if (normalOn != 0)
+ normalImageOn = normalOn->createCopy();
+
+ if (overOn != 0)
+ overImageOn = overOn->createCopy();
+
+ if (downOn != 0)
+ downImageOn = downOn->createCopy();
+
+ if (disabledOn != 0)
+ disabledImageOn = disabledOn->createCopy();
+
+ repaint();
+}
+
+void DrawableButton::setButtonStyle (const DrawableButton::ButtonStyle newStyle)
+{
+ if (style != newStyle)
+ {
+ style = newStyle;
+ repaint();
+ }
+}
+
+void DrawableButton::setBackgroundColours (const Colour& toggledOffColour,
+ const Colour& toggledOnColour)
+{
+ if (backgroundOff != toggledOffColour
+ || backgroundOn != toggledOnColour)
+ {
+ backgroundOff = toggledOffColour;
+ backgroundOn = toggledOnColour;
+
+ repaint();
+ }
+}
+
+const Colour& DrawableButton::getBackgroundColour() const throw()
+{
+ return getToggleState() ? backgroundOn
+ : backgroundOff;
+}
+
+void DrawableButton::setEdgeIndent (const int numPixelsIndent)
+{
+ edgeIndent = numPixelsIndent;
+ repaint();
+}
+
+void DrawableButton::paintButton (Graphics& g,
+ bool isMouseOverButton,
+ bool isButtonDown)
+{
+ Rectangle imageSpace;
+
+ if (style == ImageOnButtonBackground)
+ {
+ const int insetX = getWidth() / 4;
+ const int insetY = getHeight() / 4;
+
+ imageSpace.setBounds (insetX, insetY, getWidth() - insetX * 2, getHeight() - insetY * 2);
+
+ getLookAndFeel().drawButtonBackground (g, *this,
+ getBackgroundColour(),
+ isMouseOverButton,
+ isButtonDown);
+ }
+ else
+ {
+ g.fillAll (getBackgroundColour());
+
+ const int textH = (style == ImageAboveTextLabel)
+ ? jmin (16, proportionOfHeight (0.25f))
+ : 0;
+
+ const int indentX = jmin (edgeIndent, proportionOfWidth (0.3f));
+ const int indentY = jmin (edgeIndent, proportionOfHeight (0.3f));
+
+ imageSpace.setBounds (indentX, indentY,
+ getWidth() - indentX * 2,
+ getHeight() - indentY * 2 - textH);
+
+ if (textH > 0)
+ {
+ g.setFont ((float) textH);
+
+ g.setColour (Colours::black.withAlpha (isEnabled() ? 1.0f : 0.4f));
+ g.drawFittedText (getName(),
+ 2, getHeight() - textH - 1,
+ getWidth() - 4, textH,
+ Justification::centred, 1);
+ }
+ }
+
+ g.setImageResamplingQuality (Graphics::mediumResamplingQuality);
+ g.setOpacity (1.0f);
+
+ const Drawable* imageToDraw = 0;
+
+ if (isEnabled())
+ {
+ imageToDraw = getCurrentImage();
+ }
+ else
+ {
+ imageToDraw = getToggleState() ? disabledImageOn
+ : disabledImage;
+
+ if (imageToDraw == 0)
+ {
+ g.setOpacity (0.4f);
+ imageToDraw = getNormalImage();
+ }
+ }
+
+ if (imageToDraw != 0)
+ {
+ if (style == ImageRaw)
+ {
+ imageToDraw->draw (g);
+ }
+ else
+ {
+ imageToDraw->drawWithin (g,
+ imageSpace.getX(),
+ imageSpace.getY(),
+ imageSpace.getWidth(),
+ imageSpace.getHeight(),
+ RectanglePlacement::centred);
+ }
+ }
+}
+
+const Drawable* DrawableButton::getCurrentImage() const throw()
+{
+ if (isDown())
+ return getDownImage();
+
+ if (isOver())
+ return getOverImage();
+
+ return getNormalImage();
+}
+
+const Drawable* DrawableButton::getNormalImage() const throw()
+{
+ return (getToggleState() && normalImageOn != 0) ? normalImageOn
+ : normalImage;
+}
+
+const Drawable* DrawableButton::getOverImage() const throw()
+{
+ const Drawable* d = normalImage;
+
+ if (getToggleState())
+ {
+ if (overImageOn != 0)
+ d = overImageOn;
+ else if (normalImageOn != 0)
+ d = normalImageOn;
+ else if (overImage != 0)
+ d = overImage;
+ }
+ else
+ {
+ if (overImage != 0)
+ d = overImage;
+ }
+
+ return d;
+}
+
+const Drawable* DrawableButton::getDownImage() const throw()
+{
+ const Drawable* d = normalImage;
+
+ if (getToggleState())
+ {
+ if (downImageOn != 0)
+ d = downImageOn;
+ else if (overImageOn != 0)
+ d = overImageOn;
+ else if (normalImageOn != 0)
+ d = normalImageOn;
+ else if (downImage != 0)
+ d = downImage;
+ else
+ d = getOverImage();
+ }
+ else
+ {
+ if (downImage != 0)
+ d = downImage;
+ else
+ d = getOverImage();
+ }
+
+ return d;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_DrawableButton.cpp *********/
+
+/********* Start of inlined file: juce_HyperlinkButton.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+HyperlinkButton::HyperlinkButton (const String& linkText,
+ const URL& linkURL)
+ : Button (linkText),
+ url (linkURL),
+ font (14.0f, Font::underlined),
+ resizeFont (true),
+ justification (Justification::centred)
+{
+ setMouseCursor (MouseCursor::PointingHandCursor);
+ setTooltip (linkURL.toString (false));
+}
+
+HyperlinkButton::~HyperlinkButton()
+{
+}
+
+void HyperlinkButton::setFont (const Font& newFont,
+ const bool resizeToMatchComponentHeight,
+ const Justification& justificationType)
+{
+ font = newFont;
+ resizeFont = resizeToMatchComponentHeight;
+ justification = justificationType;
+ repaint();
+}
+
+void HyperlinkButton::setURL (const URL& newURL) throw()
+{
+ url = newURL;
+ setTooltip (newURL.toString (false));
+}
+
+const Font HyperlinkButton::getFontToUse() const
+{
+ Font f (font);
+
+ if (resizeFont)
+ f.setHeight (getHeight() * 0.7f);
+
+ return f;
+}
+
+void HyperlinkButton::changeWidthToFitText()
+{
+ setSize (getFontToUse().getStringWidth (getName()) + 6, getHeight());
+}
+
+void HyperlinkButton::colourChanged()
+{
+ repaint();
+}
+
+void HyperlinkButton::clicked()
+{
+ if (url.isWellFormed())
+ url.launchInDefaultBrowser();
+}
+
+void HyperlinkButton::paintButton (Graphics& g,
+ bool isMouseOverButton,
+ bool isButtonDown)
+{
+ const Colour textColour (findColour (textColourId));
+
+ if (isEnabled())
+ g.setColour ((isMouseOverButton) ? textColour.darker ((isButtonDown) ? 1.3f : 0.4f)
+ : textColour);
+ else
+ g.setColour (textColour.withMultipliedAlpha (0.4f));
+
+ g.setFont (getFontToUse());
+
+ g.drawText (getButtonText(),
+ 2, 0, getWidth() - 2, getHeight(),
+ justification.getOnlyHorizontalFlags() | Justification::verticallyCentred,
+ true);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_HyperlinkButton.cpp *********/
+
+/********* Start of inlined file: juce_ImageButton.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ImageButton::ImageButton (const String& text)
+ : Button (text),
+ scaleImageToFit (true),
+ preserveProportions (true),
+ alphaThreshold (0),
+ imageX (0),
+ imageY (0),
+ imageW (0),
+ imageH (0),
+ normalImage (0),
+ overImage (0),
+ downImage (0)
+{
+}
+
+ImageButton::~ImageButton()
+{
+ deleteImages();
+}
+
+void ImageButton::deleteImages()
+{
+ if (normalImage != 0)
+ {
+ if (ImageCache::isImageInCache (normalImage))
+ ImageCache::release (normalImage);
+ else
+ delete normalImage;
+ }
+
+ if (overImage != 0)
+ {
+ if (ImageCache::isImageInCache (overImage))
+ ImageCache::release (overImage);
+ else
+ delete overImage;
+ }
+
+ if (downImage != 0)
+ {
+ if (ImageCache::isImageInCache (downImage))
+ ImageCache::release (downImage);
+ else
+ delete downImage;
+ }
+}
+
+void ImageButton::setImages (const bool resizeButtonNowToFitThisImage,
+ const bool rescaleImagesWhenButtonSizeChanges,
+ const bool preserveImageProportions,
+ Image* const normalImage_,
+ const float imageOpacityWhenNormal,
+ const Colour& overlayColourWhenNormal,
+ Image* const overImage_,
+ const float imageOpacityWhenOver,
+ const Colour& overlayColourWhenOver,
+ Image* const downImage_,
+ const float imageOpacityWhenDown,
+ const Colour& overlayColourWhenDown,
+ const float hitTestAlphaThreshold)
+{
+ deleteImages();
+
+ normalImage = normalImage_;
+ overImage = overImage_;
+ downImage = downImage_;
+
+ if (resizeButtonNowToFitThisImage && normalImage != 0)
+ {
+ imageW = normalImage->getWidth();
+ imageH = normalImage->getHeight();
+
+ setSize (imageW, imageH);
+ }
+
+ scaleImageToFit = rescaleImagesWhenButtonSizeChanges;
+ preserveProportions = preserveImageProportions;
+
+ normalOpacity = imageOpacityWhenNormal;
+ normalOverlay = overlayColourWhenNormal;
+ overOpacity = imageOpacityWhenOver;
+ overOverlay = overlayColourWhenOver;
+ downOpacity = imageOpacityWhenDown;
+ downOverlay = overlayColourWhenDown;
+
+ alphaThreshold = (unsigned char) jlimit (0, 0xff, roundFloatToInt (255.0f * hitTestAlphaThreshold));
+
+ repaint();
+}
+
+Image* ImageButton::getCurrentImage() const
+{
+ if (isDown())
+ return getDownImage();
+
+ if (isOver())
+ return getOverImage();
+
+ return getNormalImage();
+}
+
+Image* ImageButton::getNormalImage() const throw()
+{
+ return normalImage;
+}
+
+Image* ImageButton::getOverImage() const throw()
+{
+ return (overImage != 0) ? overImage
+ : normalImage;
+}
+
+Image* ImageButton::getDownImage() const throw()
+{
+ return (downImage != 0) ? downImage
+ : getOverImage();
+}
+
+void ImageButton::paintButton (Graphics& g,
+ bool isMouseOverButton,
+ bool isButtonDown)
+{
+ if (! isEnabled())
+ {
+ isMouseOverButton = false;
+ isButtonDown = false;
+ }
+
+ Image* const im = getCurrentImage();
+
+ if (im != 0)
+ {
+ const int iw = im->getWidth();
+ const int ih = im->getHeight();
+ imageW = getWidth();
+ imageH = getHeight();
+ imageX = (imageW - iw) >> 1;
+ imageY = (imageH - ih) >> 1;
+
+ if (scaleImageToFit)
+ {
+ if (preserveProportions)
+ {
+ int newW, newH;
+ const float imRatio = ih / (float)iw;
+ const float destRatio = imageH / (float)imageW;
+
+ if (imRatio > destRatio)
+ {
+ newW = roundFloatToInt (imageH / imRatio);
+ newH = imageH;
+ }
+ else
+ {
+ newW = imageW;
+ newH = roundFloatToInt (imageW * imRatio);
+ }
+
+ imageX = (imageW - newW) / 2;
+ imageY = (imageH - newH) / 2;
+ imageW = newW;
+ imageH = newH;
+ }
+ else
+ {
+ imageX = 0;
+ imageY = 0;
+ }
+ }
+
+ const Colour& overlayColour = (isButtonDown) ? downOverlay
+ : ((isMouseOverButton) ? overOverlay
+ : normalOverlay);
+
+ if (! overlayColour.isOpaque())
+ {
+ g.setOpacity ((isButtonDown) ? downOpacity
+ : ((isMouseOverButton) ? overOpacity
+ : normalOpacity));
+
+ if (scaleImageToFit)
+ g.drawImage (im, imageX, imageY, imageW, imageH, 0, 0, iw, ih, false);
+ else
+ g.drawImageAt (im, imageX, imageY, false);
+ }
+
+ if (! overlayColour.isTransparent())
+ {
+ g.setColour (overlayColour);
+
+ if (scaleImageToFit)
+ g.drawImage (im, imageX, imageY, imageW, imageH, 0, 0, iw, ih, true);
+ else
+ g.drawImageAt (im, imageX, imageY, true);
+ }
+ }
+}
+
+bool ImageButton::hitTest (int x, int y)
+{
+ if (alphaThreshold == 0)
+ return true;
+
+ Image* const im = getCurrentImage();
+
+ return im == 0
+ || (imageW > 0 && imageH > 0
+ && alphaThreshold < im->getPixelAt (((x - imageX) * im->getWidth()) / imageW,
+ ((y - imageY) * im->getHeight()) / imageH).getAlpha());
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ImageButton.cpp *********/
+
+/********* Start of inlined file: juce_ShapeButton.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ShapeButton::ShapeButton (const String& text,
+ const Colour& normalColour_,
+ const Colour& overColour_,
+ const Colour& downColour_)
+ : Button (text),
+ normalColour (normalColour_),
+ overColour (overColour_),
+ downColour (downColour_),
+ maintainShapeProportions (false),
+ outlineWidth (0.0f)
+{
+}
+
+ShapeButton::~ShapeButton()
+{
+}
+
+void ShapeButton::setColours (const Colour& newNormalColour,
+ const Colour& newOverColour,
+ const Colour& newDownColour)
+{
+ normalColour = newNormalColour;
+ overColour = newOverColour;
+ downColour = newDownColour;
+}
+
+void ShapeButton::setOutline (const Colour& newOutlineColour,
+ const float newOutlineWidth)
+{
+ outlineColour = newOutlineColour;
+ outlineWidth = newOutlineWidth;
+}
+
+void ShapeButton::setShape (const Path& newShape,
+ const bool resizeNowToFitThisShape,
+ const bool maintainShapeProportions_,
+ const bool hasShadow)
+{
+ shape = newShape;
+ maintainShapeProportions = maintainShapeProportions_;
+
+ shadow.setShadowProperties (3.0f, 0.5f, 0, 0);
+ setComponentEffect ((hasShadow) ? &shadow : 0);
+
+ if (resizeNowToFitThisShape)
+ {
+ float x, y, w, h;
+ shape.getBounds (x, y, w, h);
+ shape.applyTransform (AffineTransform::translation (-x, -y));
+
+ if (hasShadow)
+ {
+ w += 4.0f;
+ h += 4.0f;
+ shape.applyTransform (AffineTransform::translation (2.0f, 2.0f));
+ }
+
+ setSize (1 + (int) (w + outlineWidth),
+ 1 + (int) (h + outlineWidth));
+ }
+}
+
+void ShapeButton::paintButton (Graphics& g, bool isMouseOverButton, bool isButtonDown)
+{
+ if (! isEnabled())
+ {
+ isMouseOverButton = false;
+ isButtonDown = false;
+ }
+
+ g.setColour ((isButtonDown) ? downColour
+ : (isMouseOverButton) ? overColour
+ : normalColour);
+
+ int w = getWidth();
+ int h = getHeight();
+
+ if (getComponentEffect() != 0)
+ {
+ w -= 4;
+ h -= 4;
+ }
+
+ const float offset = (outlineWidth * 0.5f) + (isButtonDown ? 1.5f : 0.0f);
+
+ const AffineTransform trans (shape.getTransformToScaleToFit (offset, offset,
+ w - offset - outlineWidth,
+ h - offset - outlineWidth,
+ maintainShapeProportions));
+ g.fillPath (shape, trans);
+
+ if (outlineWidth > 0.0f)
+ {
+ g.setColour (outlineColour);
+ g.strokePath (shape, PathStrokeType (outlineWidth), trans);
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ShapeButton.cpp *********/
+
+/********* Start of inlined file: juce_TextButton.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+TextButton::TextButton (const String& name,
+ const String& toolTip)
+ : Button (name)
+{
+ setTooltip (toolTip);
+}
+
+TextButton::~TextButton()
+{
+}
+
+void TextButton::paintButton (Graphics& g,
+ bool isMouseOverButton,
+ bool isButtonDown)
+{
+ getLookAndFeel().drawButtonBackground (g, *this,
+ findColour (getToggleState() ? buttonOnColourId
+ : buttonColourId),
+ isMouseOverButton,
+ isButtonDown);
+
+ getLookAndFeel().drawButtonText (g, *this,
+ isMouseOverButton,
+ isButtonDown);
+}
+
+void TextButton::colourChanged()
+{
+ repaint();
+}
+
+const Font TextButton::getFont()
+{
+ return Font (jmin (15.0f, getHeight() * 0.6f));
+}
+
+void TextButton::changeWidthToFitText (const int newHeight)
+{
+ if (newHeight >= 0)
+ setSize (jmax (1, getWidth()), newHeight);
+
+ setSize (getFont().getStringWidth (getButtonText()) + getHeight(),
+ getHeight());
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_TextButton.cpp *********/
+
+/********* Start of inlined file: juce_ToggleButton.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ToggleButton::ToggleButton (const String& buttonText)
+ : Button (buttonText)
+{
+ setClickingTogglesState (true);
+}
+
+ToggleButton::~ToggleButton()
+{
+}
+
+void ToggleButton::paintButton (Graphics& g,
+ bool isMouseOverButton,
+ bool isButtonDown)
+{
+ getLookAndFeel().drawToggleButton (g, *this,
+ isMouseOverButton,
+ isButtonDown);
+}
+
+void ToggleButton::changeWidthToFitText()
+{
+ getLookAndFeel().changeToggleButtonWidthToFitText (*this);
+}
+
+void ToggleButton::colourChanged()
+{
+ repaint();
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ToggleButton.cpp *********/
+
+/********* Start of inlined file: juce_ToolbarButton.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ToolbarButton::ToolbarButton (const int itemId,
+ const String& buttonText,
+ Drawable* const normalImage_,
+ Drawable* const toggledOnImage_)
+ : ToolbarItemComponent (itemId, buttonText, true),
+ normalImage (normalImage_),
+ toggledOnImage (toggledOnImage_)
+{
+}
+
+ToolbarButton::~ToolbarButton()
+{
+ delete normalImage;
+ delete toggledOnImage;
+}
+
+bool ToolbarButton::getToolbarItemSizes (int toolbarDepth,
+ bool /*isToolbarVertical*/,
+ int& preferredSize,
+ int& minSize, int& maxSize)
+{
+ preferredSize = minSize = maxSize = toolbarDepth;
+ return true;
+}
+
+void ToolbarButton::paintButtonArea (Graphics& g,
+ int width, int height,
+ bool /*isMouseOver*/,
+ bool /*isMouseDown*/)
+{
+ Drawable* d = normalImage;
+
+ if (getToggleState() && toggledOnImage != 0)
+ d = toggledOnImage;
+
+ if (! isEnabled())
+ {
+ Image im (Image::ARGB, width, height, true);
+ Graphics g2 (im);
+ d->drawWithin (g2, 0, 0, width, height, RectanglePlacement::centred);
+ im.desaturate();
+
+ g.drawImageAt (&im, 0, 0);
+ }
+ else
+ {
+ d->drawWithin (g, 0, 0, width, height, RectanglePlacement::centred);
+ }
+}
+
+void ToolbarButton::contentAreaChanged (const Rectangle&)
+{
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ToolbarButton.cpp *********/
+
+/********* Start of inlined file: juce_ComboBox.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ComboBox::ComboBox (const String& name)
+ : Component (name),
+ items (4),
+ currentIndex (-1),
+ isButtonDown (false),
+ separatorPending (false),
+ menuActive (false),
+ listeners (2),
+ label (0)
+{
+ noChoicesMessage = TRANS("(no choices)");
+ setRepaintsOnMouseActivity (true);
+
+ lookAndFeelChanged();
+}
+
+ComboBox::~ComboBox()
+{
+ if (menuActive)
+ PopupMenu::dismissAllActiveMenus();
+
+ deleteAllChildren();
+}
+
+void ComboBox::setEditableText (const bool isEditable)
+{
+ label->setEditable (isEditable, isEditable, false);
+
+ setWantsKeyboardFocus (! isEditable);
+ resized();
+}
+
+bool ComboBox::isTextEditable() const throw()
+{
+ return label->isEditable();
+}
+
+void ComboBox::setJustificationType (const Justification& justification) throw()
+{
+ label->setJustificationType (justification);
+}
+
+const Justification ComboBox::getJustificationType() const throw()
+{
+ return label->getJustificationType();
+}
+
+void ComboBox::setTooltip (const String& newTooltip)
+{
+ SettableTooltipClient::setTooltip (newTooltip);
+ label->setTooltip (newTooltip);
+}
+
+void ComboBox::addItem (const String& newItemText,
+ const int newItemId) throw()
+{
+ // you can't add empty strings to the list..
+ jassert (newItemText.isNotEmpty());
+
+ // IDs must be non-zero, as zero is used to indicate a lack of selecion.
+ jassert (newItemId != 0);
+
+ // you shouldn't use duplicate item IDs!
+ jassert (getItemForId (newItemId) == 0);
+
+ if (newItemText.isNotEmpty() && newItemId != 0)
+ {
+ if (separatorPending)
+ {
+ separatorPending = false;
+
+ ItemInfo* const item = new ItemInfo();
+ item->itemId = 0;
+ item->isEnabled = false;
+ item->isHeading = false;
+ items.add (item);
+ }
+
+ ItemInfo* const item = new ItemInfo();
+ item->name = newItemText;
+ item->itemId = newItemId;
+ item->isEnabled = true;
+ item->isHeading = false;
+ items.add (item);
+ }
+}
+
+void ComboBox::addSeparator() throw()
+{
+ separatorPending = (items.size() > 0);
+}
+
+void ComboBox::addSectionHeading (const String& headingName) throw()
+{
+ // you can't add empty strings to the list..
+ jassert (headingName.isNotEmpty());
+
+ if (headingName.isNotEmpty())
+ {
+ if (separatorPending)
+ {
+ separatorPending = false;
+
+ ItemInfo* const item = new ItemInfo();
+ item->itemId = 0;
+ item->isEnabled = false;
+ item->isHeading = false;
+ items.add (item);
+ }
+
+ ItemInfo* const item = new ItemInfo();
+ item->name = headingName;
+ item->itemId = 0;
+ item->isEnabled = true;
+ item->isHeading = true;
+ items.add (item);
+ }
+}
+
+void ComboBox::setItemEnabled (const int itemId,
+ const bool isEnabled) throw()
+{
+ ItemInfo* const item = getItemForId (itemId);
+
+ if (item != 0)
+ item->isEnabled = isEnabled;
+}
+
+void ComboBox::changeItemText (const int itemId,
+ const String& newText) throw()
+{
+ ItemInfo* const item = getItemForId (itemId);
+
+ jassert (item != 0);
+
+ if (item != 0)
+ item->name = newText;
+}
+
+void ComboBox::clear (const bool dontSendChangeMessage)
+{
+ items.clear();
+ separatorPending = false;
+
+ if (! label->isEditable())
+ setSelectedItemIndex (-1, dontSendChangeMessage);
+}
+
+ComboBox::ItemInfo* ComboBox::getItemForId (const int itemId) const throw()
+{
+ jassert (itemId != 0);
+
+ if (itemId != 0)
+ {
+ for (int i = items.size(); --i >= 0;)
+ if (items.getUnchecked(i)->itemId == itemId)
+ return items.getUnchecked(i);
+ }
+
+ return 0;
+}
+
+ComboBox::ItemInfo* ComboBox::getItemForIndex (const int index) const throw()
+{
+ int n = 0;
+
+ for (int i = 0; i < items.size(); ++i)
+ {
+ ItemInfo* const item = items.getUnchecked(i);
+
+ if (item->isRealItem())
+ {
+ if (n++ == index)
+ return item;
+ }
+ }
+
+ return 0;
+}
+
+int ComboBox::getNumItems() const throw()
+{
+ int n = 0;
+
+ for (int i = items.size(); --i >= 0;)
+ {
+ ItemInfo* const item = items.getUnchecked(i);
+
+ if (item->isRealItem())
+ ++n;
+ }
+
+ return n;
+}
+
+const String ComboBox::getItemText (const int index) const throw()
+{
+ ItemInfo* const item = getItemForIndex (index);
+
+ if (item != 0)
+ return item->name;
+
+ return String::empty;
+}
+
+int ComboBox::getItemId (const int index) const throw()
+{
+ ItemInfo* const item = getItemForIndex (index);
+
+ return (item != 0) ? item->itemId : 0;
+}
+
+bool ComboBox::ItemInfo::isSeparator() const throw()
+{
+ return name.isEmpty();
+}
+
+bool ComboBox::ItemInfo::isRealItem() const throw()
+{
+ return ! (isHeading || name.isEmpty());
+}
+
+int ComboBox::getSelectedItemIndex() const throw()
+{
+ return (currentIndex >= 0 && getText() == getItemText (currentIndex))
+ ? currentIndex
+ : -1;
+}
+
+void ComboBox::setSelectedItemIndex (const int index,
+ const bool dontSendChangeMessage) throw()
+{
+ if (currentIndex != index || label->getText() != getItemText (currentIndex))
+ {
+ if (((unsigned int) index) < (unsigned int) getNumItems())
+ currentIndex = index;
+ else
+ currentIndex = -1;
+
+ label->setText (getItemText (currentIndex), false);
+
+ if (! dontSendChangeMessage)
+ triggerAsyncUpdate();
+ }
+}
+
+void ComboBox::setSelectedId (const int newItemId,
+ const bool dontSendChangeMessage) throw()
+{
+ for (int i = getNumItems(); --i >= 0;)
+ {
+ if (getItemId(i) == newItemId)
+ {
+ setSelectedItemIndex (i, dontSendChangeMessage);
+ break;
+ }
+ }
+}
+
+int ComboBox::getSelectedId() const throw()
+{
+ const ItemInfo* const item = getItemForIndex (currentIndex);
+
+ return (item != 0 && getText() == item->name)
+ ? item->itemId
+ : 0;
+}
+
+void ComboBox::addListener (ComboBoxListener* const listener) throw()
+{
+ jassert (listener != 0);
+ if (listener != 0)
+ listeners.add (listener);
+}
+
+void ComboBox::removeListener (ComboBoxListener* const listener) throw()
+{
+ listeners.removeValue (listener);
+}
+
+void ComboBox::handleAsyncUpdate()
+{
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ ((ComboBoxListener*) listeners.getUnchecked (i))->comboBoxChanged (this);
+ i = jmin (i, listeners.size());
+ }
+}
+
+const String ComboBox::getText() const throw()
+{
+ return label->getText();
+}
+
+void ComboBox::setText (const String& newText,
+ const bool dontSendChangeMessage) throw()
+{
+ for (int i = items.size(); --i >= 0;)
+ {
+ ItemInfo* const item = items.getUnchecked(i);
+
+ if (item->isRealItem()
+ && item->name == newText)
+ {
+ setSelectedId (item->itemId, dontSendChangeMessage);
+ return;
+ }
+ }
+
+ currentIndex = -1;
+
+ if (label->getText() != newText)
+ {
+ label->setText (newText, false);
+
+ if (! dontSendChangeMessage)
+ triggerAsyncUpdate();
+ }
+
+ repaint();
+}
+
+void ComboBox::showEditor()
+{
+ jassert (isTextEditable()); // you probably shouldn't do this to a non-editable combo box?
+
+ label->showEditor();
+}
+
+void ComboBox::setTextWhenNothingSelected (const String& newMessage) throw()
+{
+ textWhenNothingSelected = newMessage;
+ repaint();
+}
+
+const String ComboBox::getTextWhenNothingSelected() const throw()
+{
+ return textWhenNothingSelected;
+}
+
+void ComboBox::setTextWhenNoChoicesAvailable (const String& newMessage) throw()
+{
+ noChoicesMessage = newMessage;
+}
+
+const String ComboBox::getTextWhenNoChoicesAvailable() const throw()
+{
+ return noChoicesMessage;
+}
+
+void ComboBox::paint (Graphics& g)
+{
+ getLookAndFeel().drawComboBox (g,
+ getWidth(),
+ getHeight(),
+ isButtonDown,
+ label->getRight(),
+ 0,
+ getWidth() - label->getRight(),
+ getHeight(),
+ *this);
+
+ if (textWhenNothingSelected.isNotEmpty()
+ && label->getText().isEmpty()
+ && ! label->isBeingEdited())
+ {
+ g.setColour (findColour (textColourId).withMultipliedAlpha (0.5f));
+ g.setFont (label->getFont());
+ g.drawFittedText (textWhenNothingSelected,
+ label->getX() + 2, label->getY() + 1,
+ label->getWidth() - 4, label->getHeight() - 2,
+ label->getJustificationType(),
+ jmax (1, (int) (label->getHeight() / label->getFont().getHeight())));
+ }
+}
+
+void ComboBox::resized()
+{
+ if (getHeight() > 0 && getWidth() > 0)
+ {
+ label->setBounds (1, 1,
+ getWidth() + 3 - getHeight(),
+ getHeight() - 2);
+
+ label->setFont (getLookAndFeel().getComboBoxFont (*this));
+ }
+}
+
+void ComboBox::enablementChanged()
+{
+ repaint();
+}
+
+void ComboBox::lookAndFeelChanged()
+{
+ repaint();
+
+ Label* const newLabel = getLookAndFeel().createComboBoxTextBox (*this);
+
+ if (label != 0)
+ {
+ newLabel->setEditable (label->isEditable());
+ newLabel->setJustificationType (label->getJustificationType());
+ newLabel->setTooltip (label->getTooltip());
+ newLabel->setText (label->getText(), false);
+ }
+
+ delete label;
+ label = newLabel;
+
+ addAndMakeVisible (newLabel);
+
+ newLabel->addListener (this);
+ newLabel->addMouseListener (this, false);
+
+ newLabel->setColour (Label::backgroundColourId, Colours::transparentBlack);
+ newLabel->setColour (Label::textColourId, findColour (ComboBox::textColourId));
+
+ newLabel->setColour (TextEditor::textColourId, findColour (ComboBox::textColourId));
+ newLabel->setColour (TextEditor::backgroundColourId, Colours::transparentBlack);
+ newLabel->setColour (TextEditor::highlightColourId, findColour (TextEditor::highlightColourId));
+ newLabel->setColour (TextEditor::outlineColourId, Colours::transparentBlack);
+
+ resized();
+}
+
+void ComboBox::colourChanged()
+{
+ lookAndFeelChanged();
+}
+
+bool ComboBox::keyPressed (const KeyPress& key)
+{
+ bool used = false;
+
+ if (key.isKeyCode (KeyPress::upKey)
+ || key.isKeyCode (KeyPress::leftKey))
+ {
+ setSelectedItemIndex (jmax (0, currentIndex - 1));
+ used = true;
+ }
+ else if (key.isKeyCode (KeyPress::downKey)
+ || key.isKeyCode (KeyPress::rightKey))
+ {
+ setSelectedItemIndex (jmin (currentIndex + 1, getNumItems() - 1));
+ used = true;
+ }
+ else if (key.isKeyCode (KeyPress::returnKey))
+ {
+ showPopup();
+ used = true;
+ }
+
+ return used;
+}
+
+bool ComboBox::keyStateChanged()
+{
+ // only forward key events that aren't used by this component
+ return KeyPress::isKeyCurrentlyDown (KeyPress::upKey)
+ || KeyPress::isKeyCurrentlyDown (KeyPress::leftKey)
+ || KeyPress::isKeyCurrentlyDown (KeyPress::downKey)
+ || KeyPress::isKeyCurrentlyDown (KeyPress::rightKey);
+}
+
+void ComboBox::focusGained (FocusChangeType)
+{
+ repaint();
+}
+
+void ComboBox::focusLost (FocusChangeType)
+{
+ repaint();
+}
+
+void ComboBox::labelTextChanged (Label*)
+{
+ triggerAsyncUpdate();
+}
+
+void ComboBox::showPopup()
+{
+ if (! menuActive)
+ {
+ const int currentId = getSelectedId();
+ ComponentDeletionWatcher deletionWatcher (this);
+
+ PopupMenu menu;
+
+ menu.setLookAndFeel (&getLookAndFeel());
+
+ for (int i = 0; i < items.size(); ++i)
+ {
+ const ItemInfo* const item = items.getUnchecked(i);
+
+ if (item->isSeparator())
+ menu.addSeparator();
+ else if (item->isHeading)
+ menu.addSectionHeader (item->name);
+ else
+ menu.addItem (item->itemId, item->name,
+ item->isEnabled, item->itemId == currentId);
+ }
+
+ if (items.size() == 0)
+ menu.addItem (1, noChoicesMessage, false);
+
+ const int itemHeight = jlimit (12, 24, getHeight());
+
+ menuActive = true;
+ const int resultId = menu.showAt (this, currentId,
+ getWidth(), 1, itemHeight);
+
+ if (deletionWatcher.hasBeenDeleted())
+ return;
+
+ menuActive = false;
+
+ if (resultId != 0)
+ setSelectedId (resultId);
+ }
+}
+
+void ComboBox::mouseDown (const MouseEvent& e)
+{
+ beginDragAutoRepeat (300);
+
+ isButtonDown = isEnabled();
+
+ if (isButtonDown
+ && (e.eventComponent == this || ! label->isEditable()))
+ {
+ showPopup();
+ }
+}
+
+void ComboBox::mouseDrag (const MouseEvent& e)
+{
+ beginDragAutoRepeat (50);
+
+ if (isButtonDown && ! e.mouseWasClicked())
+ showPopup();
+}
+
+void ComboBox::mouseUp (const MouseEvent& e2)
+{
+ if (isButtonDown)
+ {
+ isButtonDown = false;
+ repaint();
+
+ const MouseEvent e (e2.getEventRelativeTo (this));
+
+ if (reallyContains (e.x, e.y, true)
+ && (e2.eventComponent == this || ! label->isEditable()))
+ {
+ showPopup();
+ }
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ComboBox.cpp *********/
+
+/********* Start of inlined file: juce_Label.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+Label::Label (const String& componentName,
+ const String& labelText)
+ : Component (componentName),
+ text (labelText),
+ font (15.0f),
+ justification (Justification::centredLeft),
+ editor (0),
+ listeners (2),
+ ownerComponent (0),
+ deletionWatcher (0),
+ editSingleClick (false),
+ editDoubleClick (false),
+ lossOfFocusDiscardsChanges (false)
+{
+ setColour (TextEditor::textColourId, Colours::black);
+ setColour (TextEditor::backgroundColourId, Colours::transparentBlack);
+ setColour (TextEditor::outlineColourId, Colours::transparentBlack);
+}
+
+Label::~Label()
+{
+ if (ownerComponent != 0 && ! deletionWatcher->hasBeenDeleted())
+ ownerComponent->removeComponentListener (this);
+
+ deleteAndZero (deletionWatcher);
+
+ if (editor != 0)
+ delete editor;
+}
+
+void Label::setText (const String& newText,
+ const bool broadcastChangeMessage)
+{
+ hideEditor (true);
+
+ if (text != newText)
+ {
+ text = newText;
+
+ if (broadcastChangeMessage)
+ triggerAsyncUpdate();
+
+ repaint();
+
+ if (ownerComponent != 0 && ! deletionWatcher->hasBeenDeleted())
+ componentMovedOrResized (*ownerComponent, true, true);
+ }
+}
+
+const String Label::getText (const bool returnActiveEditorContents) const throw()
+{
+ return (returnActiveEditorContents && isBeingEdited())
+ ? editor->getText()
+ : text;
+}
+
+void Label::setFont (const Font& newFont) throw()
+{
+ font = newFont;
+ repaint();
+}
+
+const Font& Label::getFont() const throw()
+{
+ return font;
+}
+
+void Label::setEditable (const bool editOnSingleClick,
+ const bool editOnDoubleClick,
+ const bool lossOfFocusDiscardsChanges_) throw()
+{
+ editSingleClick = editOnSingleClick;
+ editDoubleClick = editOnDoubleClick;
+ lossOfFocusDiscardsChanges = lossOfFocusDiscardsChanges_;
+
+ setWantsKeyboardFocus (editOnSingleClick || editOnDoubleClick);
+ setFocusContainer (editOnSingleClick || editOnDoubleClick);
+}
+
+void Label::setJustificationType (const Justification& justification_) throw()
+{
+ justification = justification_;
+ repaint();
+}
+
+void Label::attachToComponent (Component* owner,
+ const bool onLeft)
+{
+ if (ownerComponent != 0 && ! deletionWatcher->hasBeenDeleted())
+ ownerComponent->removeComponentListener (this);
+
+ deleteAndZero (deletionWatcher);
+ ownerComponent = owner;
+
+ leftOfOwnerComp = onLeft;
+
+ if (ownerComponent != 0)
+ {
+ deletionWatcher = new ComponentDeletionWatcher (owner);
+
+ setVisible (owner->isVisible());
+ ownerComponent->addComponentListener (this);
+ componentParentHierarchyChanged (*ownerComponent);
+ componentMovedOrResized (*ownerComponent, true, true);
+ }
+}
+
+void Label::componentMovedOrResized (Component& component,
+ bool /*wasMoved*/,
+ bool /*wasResized*/)
+{
+ if (leftOfOwnerComp)
+ {
+ setSize (jmin (getFont().getStringWidth (text) + 8, component.getX()),
+ component.getHeight());
+
+ setTopRightPosition (component.getX(), component.getY());
+ }
+ else
+ {
+ setSize (component.getWidth(),
+ 8 + roundFloatToInt (getFont().getHeight()));
+
+ setTopLeftPosition (component.getX(), component.getY() - getHeight());
+ }
+}
+
+void Label::componentParentHierarchyChanged (Component& component)
+{
+ if (component.getParentComponent() != 0)
+ component.getParentComponent()->addChildComponent (this);
+}
+
+void Label::componentVisibilityChanged (Component& component)
+{
+ setVisible (component.isVisible());
+}
+
+void Label::textWasEdited()
+{
+}
+
+void Label::showEditor()
+{
+ if (editor == 0)
+ {
+ addAndMakeVisible (editor = createEditorComponent());
+ editor->setText (getText());
+ editor->addListener (this);
+ editor->grabKeyboardFocus();
+ editor->setHighlightedRegion (0, text.length());
+ editor->addListener (this);
+
+ resized();
+ repaint();
+
+ enterModalState();
+ editor->grabKeyboardFocus();
+ }
+}
+
+bool Label::updateFromTextEditorContents()
+{
+ jassert (editor != 0);
+ const String newText (editor->getText());
+
+ if (text != newText)
+ {
+ text = newText;
+
+ triggerAsyncUpdate();
+ repaint();
+
+ if (ownerComponent != 0 && ! deletionWatcher->hasBeenDeleted())
+ componentMovedOrResized (*ownerComponent, true, true);
+
+ return true;
+ }
+
+ return false;
+}
+
+void Label::hideEditor (const bool discardCurrentEditorContents)
+{
+ if (editor != 0)
+ {
+ const bool changed = (! discardCurrentEditorContents)
+ && updateFromTextEditorContents();
+
+ deleteAndZero (editor);
+ repaint();
+
+ if (changed)
+ textWasEdited();
+
+ exitModalState (0);
+ }
+}
+
+void Label::inputAttemptWhenModal()
+{
+ if (editor != 0)
+ {
+ if (lossOfFocusDiscardsChanges)
+ textEditorEscapeKeyPressed (*editor);
+ else
+ textEditorReturnKeyPressed (*editor);
+ }
+}
+
+bool Label::isBeingEdited() const throw()
+{
+ return editor != 0;
+}
+
+TextEditor* Label::createEditorComponent()
+{
+ TextEditor* const ed = new TextEditor (getName());
+ ed->setFont (font);
+
+ // copy these colours from our own settings..
+ const int cols[] = { TextEditor::backgroundColourId,
+ TextEditor::textColourId,
+ TextEditor::highlightColourId,
+ TextEditor::highlightedTextColourId,
+ TextEditor::caretColourId,
+ TextEditor::outlineColourId,
+ TextEditor::focusedOutlineColourId,
+ TextEditor::shadowColourId };
+
+ for (int i = 0; i < numElementsInArray (cols); ++i)
+ ed->setColour (cols[i], findColour (cols[i]));
+
+ return ed;
+}
+
+void Label::paint (Graphics& g)
+{
+ g.fillAll (findColour (backgroundColourId));
+
+ if (editor == 0)
+ {
+ const float alpha = isEnabled() ? 1.0f : 0.5f;
+
+ g.setColour (findColour (textColourId).withMultipliedAlpha (alpha));
+ g.setFont (font);
+ g.drawFittedText (text,
+ 3, 1, getWidth() - 6, getHeight() - 2,
+ justification,
+ jmax (1, (int) (getHeight() / font.getHeight())));
+
+ g.setColour (findColour (outlineColourId).withMultipliedAlpha (alpha));
+ g.drawRect (0, 0, getWidth(), getHeight());
+ }
+ else if (isEnabled())
+ {
+ g.setColour (editor->findColour (TextEditor::backgroundColourId)
+ .overlaidWith (findColour (outlineColourId)));
+
+ g.drawRect (0, 0, getWidth(), getHeight());
+ }
+}
+
+void Label::mouseUp (const MouseEvent& e)
+{
+ if (editSingleClick
+ && e.mouseWasClicked()
+ && contains (e.x, e.y)
+ && ! e.mods.isPopupMenu())
+ {
+ showEditor();
+ }
+}
+
+void Label::mouseDoubleClick (const MouseEvent& e)
+{
+ if (editDoubleClick && ! e.mods.isPopupMenu())
+ showEditor();
+}
+
+void Label::resized()
+{
+ if (editor != 0)
+ editor->setBoundsInset (BorderSize (0));
+}
+
+void Label::focusGained (FocusChangeType cause)
+{
+ if (editSingleClick && cause == focusChangedByTabKey)
+ showEditor();
+}
+
+void Label::enablementChanged()
+{
+ repaint();
+}
+
+void Label::colourChanged()
+{
+ repaint();
+}
+
+// We'll use a custom focus traverser here to make sure focus goes from the
+// text editor to another component rather than back to the label itself.
+class LabelKeyboardFocusTraverser : public KeyboardFocusTraverser
+{
+public:
+ LabelKeyboardFocusTraverser() {}
+
+ Component* getNextComponent (Component* current)
+ {
+ return KeyboardFocusTraverser::getNextComponent (dynamic_cast (current) != 0
+ ? current->getParentComponent() : current);
+ }
+
+ Component* getPreviousComponent (Component* current)
+ {
+ return KeyboardFocusTraverser::getPreviousComponent (dynamic_cast (current) != 0
+ ? current->getParentComponent() : current);
+ }
+};
+
+KeyboardFocusTraverser* Label::createFocusTraverser()
+{
+ return new LabelKeyboardFocusTraverser();
+}
+
+void Label::addListener (LabelListener* const listener) throw()
+{
+ jassert (listener != 0);
+ if (listener != 0)
+ listeners.add (listener);
+}
+
+void Label::removeListener (LabelListener* const listener) throw()
+{
+ listeners.removeValue (listener);
+}
+
+void Label::handleAsyncUpdate()
+{
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ ((LabelListener*) listeners.getUnchecked (i))->labelTextChanged (this);
+ i = jmin (i, listeners.size());
+ }
+}
+
+void Label::textEditorTextChanged (TextEditor& ed)
+{
+ if (editor != 0)
+ {
+ jassert (&ed == editor);
+
+ if (! (hasKeyboardFocus (true) || isCurrentlyBlockedByAnotherModalComponent()))
+ {
+ if (lossOfFocusDiscardsChanges)
+ textEditorEscapeKeyPressed (ed);
+ else
+ textEditorReturnKeyPressed (ed);
+ }
+ }
+}
+
+void Label::textEditorReturnKeyPressed (TextEditor& ed)
+{
+ if (editor != 0)
+ {
+ jassert (&ed == editor);
+ (void) ed;
+
+ const bool changed = updateFromTextEditorContents();
+ hideEditor (true);
+
+ if (changed)
+ textWasEdited();
+ }
+}
+
+void Label::textEditorEscapeKeyPressed (TextEditor& ed)
+{
+ if (editor != 0)
+ {
+ jassert (&ed == editor);
+ (void) ed;
+
+ editor->setText (text, false);
+ hideEditor (true);
+ }
+}
+
+void Label::textEditorFocusLost (TextEditor& ed)
+{
+ textEditorTextChanged (ed);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_Label.cpp *********/
+
+/********* Start of inlined file: juce_ListBox.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+class ListBoxRowComponent : public Component
+{
+public:
+ ListBoxRowComponent (ListBox& owner_)
+ : owner (owner_),
+ row (-1),
+ selected (false),
+ isDragging (false)
+ {
+ }
+
+ ~ListBoxRowComponent()
+ {
+ deleteAllChildren();
+ }
+
+ void paint (Graphics& g)
+ {
+ if (owner.getModel() != 0)
+ owner.getModel()->paintListBoxItem (row, g, getWidth(), getHeight(), selected);
+ }
+
+ void update (const int row_, const bool selected_)
+ {
+ if (row != row_ || selected != selected_)
+ {
+ repaint();
+ row = row_;
+ selected = selected_;
+ }
+
+ if (owner.getModel() != 0)
+ {
+ Component* const customComp = owner.getModel()->refreshComponentForRow (row_, selected_, getChildComponent (0));
+
+ if (customComp != 0)
+ {
+ addAndMakeVisible (customComp);
+ customComp->setBounds (0, 0, getWidth(), getHeight());
+
+ for (int i = getNumChildComponents(); --i >= 0;)
+ if (getChildComponent (i) != customComp)
+ delete getChildComponent (i);
+ }
+ else
+ {
+ deleteAllChildren();
+ }
+ }
+ }
+
+ void mouseDown (const MouseEvent& e)
+ {
+ isDragging = false;
+ selectRowOnMouseUp = false;
+
+ if (isEnabled())
+ {
+ if (! selected)
+ {
+ owner.selectRowsBasedOnModifierKeys (row, e.mods);
+
+ if (owner.getModel() != 0)
+ owner.getModel()->listBoxItemClicked (row, e);
+ }
+ else
+ {
+ selectRowOnMouseUp = true;
+ }
+ }
+ }
+
+ void mouseUp (const MouseEvent& e)
+ {
+ if (isEnabled() && selectRowOnMouseUp && ! isDragging)
+ {
+ owner.selectRowsBasedOnModifierKeys (row, e.mods);
+
+ if (owner.getModel() != 0)
+ owner.getModel()->listBoxItemClicked (row, e);
+ }
+ }
+
+ void mouseDoubleClick (const MouseEvent& e)
+ {
+ if (owner.getModel() != 0 && isEnabled())
+ owner.getModel()->listBoxItemDoubleClicked (row, e);
+ }
+
+ void mouseDrag (const MouseEvent& e)
+ {
+ if (isEnabled() && owner.getModel() != 0 && ! (e.mouseWasClicked() || isDragging))
+ {
+ const SparseSet selectedRows (owner.getSelectedRows());
+
+ if (selectedRows.size() > 0)
+ {
+ const String dragDescription (owner.getModel()->getDragSourceDescription (selectedRows));
+
+ if (dragDescription.isNotEmpty())
+ {
+ isDragging = true;
+
+ DragAndDropContainer* const dragContainer
+ = DragAndDropContainer::findParentDragContainerFor (this);
+
+ if (dragContainer != 0)
+ {
+ Image* dragImage = owner.createSnapshotOfSelectedRows();
+ dragImage->multiplyAllAlphas (0.6f);
+
+ dragContainer->startDragging (dragDescription, &owner, dragImage, true);
+ }
+ else
+ {
+ // to be able to do a drag-and-drop operation, the listbox needs to
+ // be inside a component which is also a DragAndDropContainer.
+ jassertfalse
+ }
+ }
+ }
+ }
+ }
+
+ void resized()
+ {
+ if (getNumChildComponents() > 0)
+ getChildComponent(0)->setBounds (0, 0, getWidth(), getHeight());
+ }
+
+ juce_UseDebuggingNewOperator
+
+ bool neededFlag;
+
+private:
+ ListBox& owner;
+ int row;
+ bool selected, isDragging, selectRowOnMouseUp;
+
+ ListBoxRowComponent (const ListBoxRowComponent&);
+ const ListBoxRowComponent& operator= (const ListBoxRowComponent&);
+};
+
+class ListViewport : public Viewport
+{
+public:
+ int firstIndex, firstWholeIndex, lastWholeIndex;
+ bool hasUpdated;
+
+ ListViewport (ListBox& owner_)
+ : owner (owner_)
+ {
+ setWantsKeyboardFocus (false);
+
+ setViewedComponent (new Component());
+ getViewedComponent()->addMouseListener (this, false);
+ getViewedComponent()->setWantsKeyboardFocus (false);
+ }
+
+ ~ListViewport()
+ {
+ getViewedComponent()->removeMouseListener (this);
+ getViewedComponent()->deleteAllChildren();
+ }
+
+ ListBoxRowComponent* getComponentForRow (const int row) const throw()
+ {
+ return (ListBoxRowComponent*) getViewedComponent()
+ ->getChildComponent (row % jmax (1, getViewedComponent()->getNumChildComponents()));
+ }
+
+ int getRowNumberOfComponent (Component* const rowComponent) const throw()
+ {
+ const int index = getIndexOfChildComponent (rowComponent);
+ const int num = getViewedComponent()->getNumChildComponents();
+
+ for (int i = num; --i >= 0;)
+ if (((firstIndex + i) % jmax (1, num)) == index)
+ return firstIndex + i;
+
+ return -1;
+ }
+
+ Component* getComponentForRowIfOnscreen (const int row) const throw()
+ {
+ return (row >= firstIndex && row < firstIndex + getViewedComponent()->getNumChildComponents())
+ ? getComponentForRow (row) : 0;
+ }
+
+ void visibleAreaChanged (int, int, int, int)
+ {
+ updateVisibleArea (true);
+
+ if (owner.getModel() != 0)
+ owner.getModel()->listWasScrolled();
+ }
+
+ void updateVisibleArea (const bool makeSureItUpdatesContent)
+ {
+ hasUpdated = false;
+
+ const int newX = getViewedComponent()->getX();
+ int newY = getViewedComponent()->getY();
+ const int newW = jmax (owner.minimumRowWidth, getMaximumVisibleWidth());
+ const int newH = owner.totalItems * owner.getRowHeight();
+
+ if (newY + newH < getMaximumVisibleHeight() && newH > getMaximumVisibleHeight())
+ newY = getMaximumVisibleHeight() - newH;
+
+ getViewedComponent()->setBounds (newX, newY, newW, newH);
+
+ if (makeSureItUpdatesContent && ! hasUpdated)
+ updateContents();
+ }
+
+ void updateContents()
+ {
+ hasUpdated = true;
+ const int rowHeight = owner.getRowHeight();
+
+ if (rowHeight > 0)
+ {
+ const int y = getViewPositionY();
+ const int w = getViewedComponent()->getWidth();
+
+ const int numNeeded = 2 + getMaximumVisibleHeight() / rowHeight;
+
+ while (numNeeded > getViewedComponent()->getNumChildComponents())
+ getViewedComponent()->addAndMakeVisible (new ListBoxRowComponent (owner));
+
+ jassert (numNeeded >= 0);
+
+ while (numNeeded < getViewedComponent()->getNumChildComponents())
+ {
+ Component* const rowToRemove
+ = getViewedComponent()->getChildComponent (getViewedComponent()->getNumChildComponents() - 1);
+
+ delete rowToRemove;
+ }
+
+ firstIndex = y / rowHeight;
+ firstWholeIndex = (y + rowHeight - 1) / rowHeight;
+ lastWholeIndex = (y + getMaximumVisibleHeight() - 1) / rowHeight;
+
+ for (int i = 0; i < numNeeded; ++i)
+ {
+ const int row = i + firstIndex;
+ ListBoxRowComponent* const rowComp = getComponentForRow (row);
+
+ if (rowComp != 0)
+ {
+ rowComp->setBounds (0, row * rowHeight, w, rowHeight);
+ rowComp->update (row, owner.isRowSelected (row));
+ }
+ }
+ }
+
+ if (owner.headerComponent != 0)
+ owner.headerComponent->setBounds (owner.outlineThickness + getViewedComponent()->getX(),
+ owner.outlineThickness,
+ jmax (owner.getWidth() - owner.outlineThickness * 2,
+ getViewedComponent()->getWidth()),
+ owner.headerComponent->getHeight());
+ }
+
+ void paint (Graphics& g)
+ {
+ if (isOpaque())
+ g.fillAll (owner.findColour (ListBox::backgroundColourId));
+ }
+
+ bool keyPressed (const KeyPress& key)
+ {
+ if (key.isKeyCode (KeyPress::upKey)
+ || key.isKeyCode (KeyPress::downKey)
+ || key.isKeyCode (KeyPress::pageUpKey)
+ || key.isKeyCode (KeyPress::pageDownKey)
+ || key.isKeyCode (KeyPress::homeKey)
+ || key.isKeyCode (KeyPress::endKey))
+ {
+ // we want to avoid these keypresses going to the viewport, and instead allow
+ // them to pass up to our listbox..
+ return false;
+ }
+
+ return Viewport::keyPressed (key);
+ }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ ListBox& owner;
+
+ ListViewport (const ListViewport&);
+ const ListViewport& operator= (const ListViewport&);
+};
+
+ListBox::ListBox (const String& name, ListBoxModel* const model_)
+ : Component (name),
+ model (model_),
+ headerComponent (0),
+ totalItems (0),
+ rowHeight (22),
+ minimumRowWidth (0),
+ outlineThickness (0),
+ lastRowSelected (-1),
+ mouseMoveSelects (false),
+ multipleSelection (false),
+ hasDoneInitialUpdate (false)
+{
+ addAndMakeVisible (viewport = new ListViewport (*this));
+
+ setWantsKeyboardFocus (true);
+}
+
+ListBox::~ListBox()
+{
+ deleteAllChildren();
+}
+
+void ListBox::setModel (ListBoxModel* const newModel)
+{
+ if (model != newModel)
+ {
+ model = newModel;
+ updateContent();
+ }
+}
+
+void ListBox::setMultipleSelectionEnabled (bool b)
+{
+ multipleSelection = b;
+}
+
+void ListBox::setMouseMoveSelectsRows (bool b)
+{
+ mouseMoveSelects = b;
+
+ if (b)
+ addMouseListener (this, true);
+}
+
+void ListBox::paint (Graphics& g)
+{
+ if (! hasDoneInitialUpdate)
+ updateContent();
+
+ g.fillAll (findColour (backgroundColourId));
+}
+
+void ListBox::paintOverChildren (Graphics& g)
+{
+ if (outlineThickness > 0)
+ {
+ g.setColour (findColour (outlineColourId));
+ g.drawRect (0, 0, getWidth(), getHeight(), outlineThickness);
+ }
+}
+
+void ListBox::resized()
+{
+ viewport->setBoundsInset (BorderSize (outlineThickness + ((headerComponent != 0) ? headerComponent->getHeight() : 0),
+ outlineThickness,
+ outlineThickness,
+ outlineThickness));
+
+ viewport->setSingleStepSizes (20, getRowHeight());
+
+ viewport->updateVisibleArea (false);
+}
+
+void ListBox::visibilityChanged()
+{
+ viewport->updateVisibleArea (true);
+}
+
+Viewport* ListBox::getViewport() const throw()
+{
+ return viewport;
+}
+
+void ListBox::updateContent()
+{
+ hasDoneInitialUpdate = true;
+ totalItems = (model != 0) ? model->getNumRows() : 0;
+
+ bool selectionChanged = false;
+
+ if (selected [selected.size() - 1] >= totalItems)
+ {
+ selected.removeRange (totalItems, INT_MAX - totalItems);
+ lastRowSelected = getSelectedRow (0);
+ selectionChanged = true;
+ }
+
+ viewport->updateVisibleArea (isVisible());
+ viewport->resized();
+
+ if (selectionChanged && model != 0)
+ model->selectedRowsChanged (lastRowSelected);
+}
+
+void ListBox::selectRow (const int row,
+ bool dontScroll,
+ bool deselectOthersFirst)
+{
+ selectRowInternal (row, dontScroll, deselectOthersFirst, false);
+}
+
+void ListBox::selectRowInternal (const int row,
+ bool dontScroll,
+ bool deselectOthersFirst,
+ bool isMouseClick)
+{
+ if (! multipleSelection)
+ deselectOthersFirst = true;
+
+ if ((! isRowSelected (row))
+ || (deselectOthersFirst && getNumSelectedRows() > 1))
+ {
+ if (((unsigned int) row) < (unsigned int) totalItems)
+ {
+ if (deselectOthersFirst)
+ selected.clear();
+
+ selected.addRange (row, 1);
+
+ if (getHeight() == 0 || getWidth() == 0)
+ dontScroll = true;
+
+ viewport->hasUpdated = false;
+
+ if (row < viewport->firstWholeIndex && ! dontScroll)
+ {
+ viewport->setViewPosition (viewport->getViewPositionX(),
+ row * getRowHeight());
+ }
+ else if (row >= viewport->lastWholeIndex && ! dontScroll)
+ {
+ const int rowsOnScreen = viewport->lastWholeIndex - viewport->firstWholeIndex;
+
+ if (row >= lastRowSelected + rowsOnScreen
+ && rowsOnScreen < totalItems - 1
+ && ! isMouseClick)
+ {
+ viewport->setViewPosition (viewport->getViewPositionX(),
+ jlimit (0, jmax (0, totalItems - rowsOnScreen), row)
+ * getRowHeight());
+ }
+ else
+ {
+ viewport->setViewPosition (viewport->getViewPositionX(),
+ jmax (0, (row + 1) * getRowHeight() - viewport->getMaximumVisibleHeight()));
+ }
+ }
+
+ if (! viewport->hasUpdated)
+ viewport->updateContents();
+
+ lastRowSelected = row;
+ model->selectedRowsChanged (row);
+ }
+ else
+ {
+ if (deselectOthersFirst)
+ deselectAllRows();
+ }
+ }
+}
+
+void ListBox::deselectRow (const int row)
+{
+ if (selected.contains (row))
+ {
+ selected.removeRange (row, 1);
+
+ if (row == lastRowSelected)
+ lastRowSelected = getSelectedRow (0);
+
+ viewport->updateContents();
+ model->selectedRowsChanged (lastRowSelected);
+ }
+}
+
+void ListBox::setSelectedRows (const SparseSet& setOfRowsToBeSelected,
+ const bool sendNotificationEventToModel)
+{
+ selected = setOfRowsToBeSelected;
+ selected.removeRange (totalItems, INT_MAX - totalItems);
+
+ if (! isRowSelected (lastRowSelected))
+ lastRowSelected = getSelectedRow (0);
+
+ viewport->updateContents();
+
+ if ((model != 0) && sendNotificationEventToModel)
+ model->selectedRowsChanged (lastRowSelected);
+}
+
+const SparseSet ListBox::getSelectedRows() const
+{
+ return selected;
+}
+
+void ListBox::selectRangeOfRows (int firstRow, int lastRow)
+{
+ if (multipleSelection && (firstRow != lastRow))
+ {
+ const int numRows = totalItems - 1;
+ firstRow = jlimit (0, jmax (0, numRows), firstRow);
+ lastRow = jlimit (0, jmax (0, numRows), lastRow);
+
+ selected.addRange (jmin (firstRow, lastRow),
+ abs (firstRow - lastRow) + 1);
+
+ selected.removeRange (lastRow, 1);
+ }
+
+ selectRowInternal (lastRow, false, false, true);
+}
+
+void ListBox::flipRowSelection (const int row)
+{
+ if (isRowSelected (row))
+ deselectRow (row);
+ else
+ selectRowInternal (row, false, false, true);
+}
+
+void ListBox::deselectAllRows()
+{
+ if (! selected.isEmpty())
+ {
+ selected.clear();
+ lastRowSelected = -1;
+
+ viewport->updateContents();
+
+ if (model != 0)
+ model->selectedRowsChanged (lastRowSelected);
+ }
+}
+
+void ListBox::selectRowsBasedOnModifierKeys (const int row,
+ const ModifierKeys& mods)
+{
+ if (multipleSelection && mods.isCommandDown())
+ {
+ flipRowSelection (row);
+ }
+ else if (multipleSelection && mods.isShiftDown() && lastRowSelected >= 0)
+ {
+ selectRangeOfRows (lastRowSelected, row);
+ }
+ else if ((! mods.isPopupMenu()) || ! isRowSelected (row))
+ {
+ selectRowInternal (row, false, true, true);
+ }
+}
+
+int ListBox::getNumSelectedRows() const
+{
+ return selected.size();
+}
+
+int ListBox::getSelectedRow (const int index) const
+{
+ return (((unsigned int) index) < (unsigned int) selected.size())
+ ? selected [index] : -1;
+}
+
+bool ListBox::isRowSelected (const int row) const
+{
+ return selected.contains (row);
+}
+
+int ListBox::getLastRowSelected() const
+{
+ return (isRowSelected (lastRowSelected)) ? lastRowSelected : -1;
+}
+
+int ListBox::getRowContainingPosition (const int x, const int y) const throw()
+{
+ if (((unsigned int) x) < (unsigned int) getWidth())
+ {
+ const int row = (viewport->getViewPositionY() + y - viewport->getY()) / rowHeight;
+
+ if (((unsigned int) row) < (unsigned int) totalItems)
+ return row;
+ }
+
+ return -1;
+}
+
+int ListBox::getInsertionIndexForPosition (const int x, const int y) const throw()
+{
+ if (((unsigned int) x) < (unsigned int) getWidth())
+ {
+ const int row = (viewport->getViewPositionY() + y + rowHeight / 2 - viewport->getY()) / rowHeight;
+ return jlimit (0, totalItems, row);
+ }
+
+ return -1;
+}
+
+Component* ListBox::getComponentForRowNumber (const int row) const throw()
+{
+ Component* const listRowComp = viewport->getComponentForRowIfOnscreen (row);
+ return listRowComp != 0 ? listRowComp->getChildComponent (0) : 0;
+}
+
+int ListBox::getRowNumberOfComponent (Component* const rowComponent) const throw()
+{
+ return viewport->getRowNumberOfComponent (rowComponent);
+}
+
+const Rectangle ListBox::getRowPosition (const int rowNumber,
+ const bool relativeToComponentTopLeft) const throw()
+{
+ const int rowHeight = getRowHeight();
+ int y = viewport->getY() + rowHeight * rowNumber;
+
+ if (relativeToComponentTopLeft)
+ y -= viewport->getViewPositionY();
+
+ return Rectangle (viewport->getX(), y,
+ viewport->getViewedComponent()->getWidth(), rowHeight);
+}
+
+void ListBox::setVerticalPosition (const double proportion)
+{
+ const int offscreen = viewport->getViewedComponent()->getHeight() - viewport->getHeight();
+
+ viewport->setViewPosition (viewport->getViewPositionX(),
+ jmax (0, roundDoubleToInt (proportion * offscreen)));
+}
+
+double ListBox::getVerticalPosition() const
+{
+ const int offscreen = viewport->getViewedComponent()->getHeight() - viewport->getHeight();
+
+ return (offscreen > 0) ? viewport->getViewPositionY() / (double) offscreen
+ : 0;
+}
+
+int ListBox::getVisibleRowWidth() const throw()
+{
+ return viewport->getViewWidth();
+}
+
+void ListBox::scrollToEnsureRowIsOnscreen (const int row)
+{
+ if (row < viewport->firstWholeIndex)
+ {
+ viewport->setViewPosition (viewport->getViewPositionX(),
+ row * getRowHeight());
+ }
+ else if (row >= viewport->lastWholeIndex)
+ {
+ viewport->setViewPosition (viewport->getViewPositionX(),
+ jmax (0, (row + 1) * getRowHeight() - viewport->getMaximumVisibleHeight()));
+ }
+}
+
+bool ListBox::keyPressed (const KeyPress& key)
+{
+ const int numVisibleRows = viewport->getHeight() / getRowHeight();
+
+ const bool multiple = multipleSelection
+ && (lastRowSelected >= 0)
+ && (key.getModifiers().isShiftDown()
+ || key.getModifiers().isCtrlDown()
+ || key.getModifiers().isCommandDown());
+
+ if (key.isKeyCode (KeyPress::upKey))
+ {
+ if (multiple)
+ selectRangeOfRows (lastRowSelected, lastRowSelected - 1);
+ else
+ selectRow (jmax (0, lastRowSelected - 1));
+ }
+ else if (key.isKeyCode (KeyPress::returnKey)
+ && isRowSelected (lastRowSelected))
+ {
+ if (model != 0)
+ model->returnKeyPressed (lastRowSelected);
+ }
+ else if (key.isKeyCode (KeyPress::pageUpKey))
+ {
+ if (multiple)
+ selectRangeOfRows (lastRowSelected, lastRowSelected - numVisibleRows);
+ else
+ selectRow (jmax (0, jmax (0, lastRowSelected) - numVisibleRows));
+ }
+ else if (key.isKeyCode (KeyPress::pageDownKey))
+ {
+ if (multiple)
+ selectRangeOfRows (lastRowSelected, lastRowSelected + numVisibleRows);
+ else
+ selectRow (jmin (totalItems - 1, jmax (0, lastRowSelected) + numVisibleRows));
+ }
+ else if (key.isKeyCode (KeyPress::homeKey))
+ {
+ if (multiple && key.getModifiers().isShiftDown())
+ selectRangeOfRows (lastRowSelected, 0);
+ else
+ selectRow (0);
+ }
+ else if (key.isKeyCode (KeyPress::endKey))
+ {
+ if (multiple && key.getModifiers().isShiftDown())
+ selectRangeOfRows (lastRowSelected, totalItems - 1);
+ else
+ selectRow (totalItems - 1);
+ }
+ else if (key.isKeyCode (KeyPress::downKey))
+ {
+ if (multiple)
+ selectRangeOfRows (lastRowSelected, lastRowSelected + 1);
+ else
+ selectRow (jmin (totalItems - 1, jmax (0, lastRowSelected) + 1));
+ }
+ else if ((key.isKeyCode (KeyPress::deleteKey) || key.isKeyCode (KeyPress::backspaceKey))
+ && isRowSelected (lastRowSelected))
+ {
+ if (model != 0)
+ model->deleteKeyPressed (lastRowSelected);
+ }
+ else if (multiple && key == KeyPress (T('a'), ModifierKeys::commandModifier, 0))
+ {
+ selectRangeOfRows (0, INT_MAX);
+ }
+ else
+ {
+ return false;
+ }
+
+ return true;
+}
+
+bool ListBox::keyStateChanged()
+{
+ return KeyPress::isKeyCurrentlyDown (KeyPress::upKey)
+ || KeyPress::isKeyCurrentlyDown (KeyPress::pageUpKey)
+ || KeyPress::isKeyCurrentlyDown (KeyPress::downKey)
+ || KeyPress::isKeyCurrentlyDown (KeyPress::pageDownKey)
+ || KeyPress::isKeyCurrentlyDown (KeyPress::homeKey)
+ || KeyPress::isKeyCurrentlyDown (KeyPress::endKey)
+ || KeyPress::isKeyCurrentlyDown (KeyPress::returnKey);
+}
+
+void ListBox::mouseWheelMove (const MouseEvent& e, float wheelIncrementX, float wheelIncrementY)
+{
+ getHorizontalScrollBar()->mouseWheelMove (e, wheelIncrementX, 0);
+ getVerticalScrollBar()->mouseWheelMove (e, 0, wheelIncrementY);
+}
+
+void ListBox::mouseMove (const MouseEvent& e)
+{
+ if (mouseMoveSelects)
+ {
+ const MouseEvent e2 (e.getEventRelativeTo (this));
+
+ selectRow (getRowContainingPosition (e2.x, e2.y), true);
+
+ lastMouseX = e2.x;
+ lastMouseY = e2.y;
+ }
+}
+
+void ListBox::mouseExit (const MouseEvent& e)
+{
+ mouseMove (e);
+}
+
+void ListBox::mouseUp (const MouseEvent& e)
+{
+ if (e.mouseWasClicked() && model != 0)
+ model->backgroundClicked();
+}
+
+void ListBox::setRowHeight (const int newHeight)
+{
+ rowHeight = jmax (1, newHeight);
+ viewport->setSingleStepSizes (20, rowHeight);
+ updateContent();
+}
+
+int ListBox::getNumRowsOnScreen() const throw()
+{
+ return viewport->getMaximumVisibleHeight() / rowHeight;
+}
+
+void ListBox::setMinimumContentWidth (const int newMinimumWidth)
+{
+ minimumRowWidth = newMinimumWidth;
+ updateContent();
+}
+
+int ListBox::getVisibleContentWidth() const throw()
+{
+ return viewport->getMaximumVisibleWidth();
+}
+
+ScrollBar* ListBox::getVerticalScrollBar() const throw()
+{
+ return viewport->getVerticalScrollBar();
+}
+
+ScrollBar* ListBox::getHorizontalScrollBar() const throw()
+{
+ return viewport->getHorizontalScrollBar();
+}
+
+void ListBox::colourChanged()
+{
+ setOpaque (findColour (backgroundColourId).isOpaque());
+ viewport->setOpaque (isOpaque());
+ repaint();
+}
+
+void ListBox::setOutlineThickness (const int outlineThickness_)
+{
+ outlineThickness = outlineThickness_;
+ resized();
+}
+
+void ListBox::setHeaderComponent (Component* const newHeaderComponent)
+{
+ if (headerComponent != newHeaderComponent)
+ {
+ if (headerComponent != 0)
+ delete headerComponent;
+
+ headerComponent = newHeaderComponent;
+
+ addAndMakeVisible (newHeaderComponent);
+ ListBox::resized();
+ }
+}
+
+void ListBox::repaintRow (const int rowNumber) throw()
+{
+ const Rectangle r (getRowPosition (rowNumber, true));
+ repaint (r.getX(), r.getY(), r.getWidth(), r.getHeight());
+}
+
+Image* ListBox::createSnapshotOfSelectedRows()
+{
+ Image* snapshot = new Image (Image::ARGB, getWidth(), getHeight(), true);
+ Graphics g (*snapshot);
+
+ const int firstRow = getRowContainingPosition (0, 0);
+
+ for (int i = getNumRowsOnScreen() + 2; --i >= 0;)
+ {
+ Component* rowComp = viewport->getComponentForRowIfOnscreen (firstRow + i);
+
+ if (rowComp != 0 && isRowSelected (firstRow + i))
+ {
+ g.saveState();
+
+ int x = 0, y = 0;
+ rowComp->relativePositionToOtherComponent (this, x, y);
+
+ g.setOrigin (x, y);
+ g.reduceClipRegion (0, 0, rowComp->getWidth(), rowComp->getHeight());
+
+ rowComp->paintEntireComponent (g);
+
+ g.restoreState();
+ }
+ }
+
+ return snapshot;
+}
+
+Component* ListBoxModel::refreshComponentForRow (int, bool, Component* existingComponentToUpdate)
+{
+ (void) existingComponentToUpdate;
+ jassert (existingComponentToUpdate == 0); // indicates a failure in the code the recycles the components
+ return 0;
+}
+
+void ListBoxModel::listBoxItemClicked (int, const MouseEvent&)
+{
+}
+
+void ListBoxModel::listBoxItemDoubleClicked (int, const MouseEvent&)
+{
+}
+
+void ListBoxModel::backgroundClicked()
+{
+}
+
+void ListBoxModel::selectedRowsChanged (int)
+{
+}
+
+void ListBoxModel::deleteKeyPressed (int)
+{
+}
+
+void ListBoxModel::returnKeyPressed (int)
+{
+}
+
+void ListBoxModel::listWasScrolled()
+{
+}
+
+const String ListBoxModel::getDragSourceDescription (const SparseSet&)
+{
+ return String::empty;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ListBox.cpp *********/
+
+/********* Start of inlined file: juce_ProgressBar.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ProgressBar::ProgressBar (double& progress_)
+ : progress (progress_),
+ displayPercentage (true)
+{
+ currentValue = jlimit (0.0, 1.0, progress);
+}
+
+ProgressBar::~ProgressBar()
+{
+}
+
+void ProgressBar::setPercentageDisplay (const bool shouldDisplayPercentage)
+{
+ displayPercentage = shouldDisplayPercentage;
+ repaint();
+}
+
+void ProgressBar::setTextToDisplay (const String& text)
+{
+ displayPercentage = false;
+ displayedMessage = text;
+}
+
+void ProgressBar::lookAndFeelChanged()
+{
+ setOpaque (findColour (backgroundColourId).isOpaque());
+}
+
+void ProgressBar::colourChanged()
+{
+ lookAndFeelChanged();
+}
+
+void ProgressBar::paint (Graphics& g)
+{
+ String text;
+
+ if (displayPercentage)
+ {
+ if (currentValue >= 0 && currentValue <= 1.0)
+ text << roundDoubleToInt (currentValue * 100.0) << T("%");
+ }
+ else
+ {
+ text = displayedMessage;
+ }
+
+ getLookAndFeel().drawProgressBar (g, *this,
+ getWidth(), getHeight(),
+ currentValue, text);
+}
+
+void ProgressBar::visibilityChanged()
+{
+ if (isVisible())
+ startTimer (30);
+ else
+ stopTimer();
+}
+
+void ProgressBar::timerCallback()
+{
+ double newProgress = progress;
+
+ if (currentValue != newProgress
+ || newProgress < 0 || newProgress >= 1.0
+ || currentMessage != displayedMessage)
+ {
+ if (currentValue < newProgress
+ && newProgress >= 0 && newProgress < 1.0
+ && currentValue >= 0 && newProgress < 1.0)
+ {
+ newProgress = jmin (currentValue + 0.02, newProgress);
+ }
+
+ currentValue = newProgress;
+ currentMessage = displayedMessage;
+ repaint();
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ProgressBar.cpp *********/
+
+/********* Start of inlined file: juce_Slider.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+class SliderPopupDisplayComponent : public BubbleComponent
+{
+public:
+
+ SliderPopupDisplayComponent (Slider* const owner_)
+ : owner (owner_),
+ font (15.0f, Font::bold)
+ {
+ setAlwaysOnTop (true);
+ }
+
+ ~SliderPopupDisplayComponent()
+ {
+ }
+
+ void paintContent (Graphics& g, int w, int h)
+ {
+ g.setFont (font);
+ g.setColour (Colours::black);
+
+ g.drawFittedText (text, 0, 0, w, h, Justification::centred, 1);
+ }
+
+ void getContentSize (int& w, int& h)
+ {
+ w = font.getStringWidth (text) + 18;
+ h = (int) (font.getHeight() * 1.6f);
+ }
+
+ void updatePosition (const String& newText)
+ {
+ if (text != newText)
+ {
+ text = newText;
+ repaint();
+ }
+
+ BubbleComponent::setPosition (owner);
+ }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ Slider* owner;
+ Font font;
+ String text;
+
+ SliderPopupDisplayComponent (const SliderPopupDisplayComponent&);
+ const SliderPopupDisplayComponent& operator= (const SliderPopupDisplayComponent&);
+};
+
+Slider::Slider (const String& name)
+ : Component (name),
+ listeners (2),
+ currentValue (0.0),
+ valueMin (0.0),
+ valueMax (0.0),
+ minimum (0),
+ maximum (10),
+ interval (0),
+ skewFactor (1.0),
+ velocityModeSensitivity (1.0),
+ velocityModeOffset (0.0),
+ velocityModeThreshold (1),
+ rotaryStart (float_Pi * 1.2f),
+ rotaryEnd (float_Pi * 2.8f),
+ numDecimalPlaces (7),
+ sliderRegionStart (0),
+ sliderRegionSize (1),
+ pixelsForFullDragExtent (250),
+ style (LinearHorizontal),
+ textBoxPos (TextBoxLeft),
+ textBoxWidth (80),
+ textBoxHeight (20),
+ incDecButtonMode (incDecButtonsNotDraggable),
+ editableText (true),
+ doubleClickToValue (false),
+ isVelocityBased (false),
+ userKeyOverridesVelocity (true),
+ rotaryStop (true),
+ incDecButtonsSideBySide (false),
+ sendChangeOnlyOnRelease (false),
+ popupDisplayEnabled (false),
+ menuEnabled (false),
+ menuShown (false),
+ scrollWheelEnabled (true),
+ snapsToMousePos (true),
+ valueBox (0),
+ incButton (0),
+ decButton (0),
+ popupDisplay (0),
+ parentForPopupDisplay (0)
+{
+ setWantsKeyboardFocus (false);
+ setRepaintsOnMouseActivity (true);
+
+ lookAndFeelChanged();
+ updateText();
+}
+
+Slider::~Slider()
+{
+ deleteAndZero (popupDisplay);
+ deleteAllChildren();
+}
+
+void Slider::handleAsyncUpdate()
+{
+ cancelPendingUpdate();
+
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ ((SliderListener*) listeners.getUnchecked (i))->sliderValueChanged (this);
+ i = jmin (i, listeners.size());
+ }
+}
+
+void Slider::sendDragStart()
+{
+ startedDragging();
+
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ ((SliderListener*) listeners.getUnchecked (i))->sliderDragStarted (this);
+ i = jmin (i, listeners.size());
+ }
+}
+
+void Slider::sendDragEnd()
+{
+ stoppedDragging();
+
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ ((SliderListener*) listeners.getUnchecked (i))->sliderDragEnded (this);
+ i = jmin (i, listeners.size());
+ }
+}
+
+void Slider::addListener (SliderListener* const listener) throw()
+{
+ jassert (listener != 0);
+ if (listener != 0)
+ listeners.add (listener);
+}
+
+void Slider::removeListener (SliderListener* const listener) throw()
+{
+ listeners.removeValue (listener);
+}
+
+void Slider::setSliderStyle (const SliderStyle newStyle)
+{
+ if (style != newStyle)
+ {
+ style = newStyle;
+ repaint();
+ lookAndFeelChanged();
+ }
+}
+
+void Slider::setRotaryParameters (const float startAngleRadians,
+ const float endAngleRadians,
+ const bool stopAtEnd)
+{
+ // make sure the values are sensible..
+ jassert (rotaryStart >= 0 && rotaryEnd >= 0);
+ jassert (rotaryStart < float_Pi * 4.0f && rotaryEnd < float_Pi * 4.0f);
+ jassert (rotaryStart < rotaryEnd);
+
+ rotaryStart = startAngleRadians;
+ rotaryEnd = endAngleRadians;
+ rotaryStop = stopAtEnd;
+}
+
+void Slider::setVelocityBasedMode (const bool velBased) throw()
+{
+ isVelocityBased = velBased;
+}
+
+void Slider::setVelocityModeParameters (const double sensitivity,
+ const int threshold,
+ const double offset,
+ const bool userCanPressKeyToSwapMode) throw()
+{
+ jassert (threshold >= 0);
+ jassert (sensitivity > 0);
+ jassert (offset >= 0);
+
+ velocityModeSensitivity = sensitivity;
+ velocityModeOffset = offset;
+ velocityModeThreshold = threshold;
+ userKeyOverridesVelocity = userCanPressKeyToSwapMode;
+}
+
+void Slider::setSkewFactor (const double factor) throw()
+{
+ skewFactor = factor;
+}
+
+void Slider::setSkewFactorFromMidPoint (const double sliderValueToShowAtMidPoint) throw()
+{
+ if (maximum > minimum)
+ skewFactor = log (0.5) / log ((sliderValueToShowAtMidPoint - minimum)
+ / (maximum - minimum));
+}
+
+void Slider::setMouseDragSensitivity (const int distanceForFullScaleDrag)
+{
+ jassert (distanceForFullScaleDrag > 0);
+
+ pixelsForFullDragExtent = distanceForFullScaleDrag;
+}
+
+void Slider::setIncDecButtonsMode (const IncDecButtonMode mode)
+{
+ if (incDecButtonMode != mode)
+ {
+ incDecButtonMode = mode;
+ lookAndFeelChanged();
+ }
+}
+
+void Slider::setTextBoxStyle (const TextEntryBoxPosition newPosition,
+ const bool isReadOnly,
+ const int textEntryBoxWidth,
+ const int textEntryBoxHeight)
+{
+ textBoxPos = newPosition;
+ editableText = ! isReadOnly;
+ textBoxWidth = textEntryBoxWidth;
+ textBoxHeight = textEntryBoxHeight;
+
+ repaint();
+ lookAndFeelChanged();
+}
+
+void Slider::setTextBoxIsEditable (const bool shouldBeEditable) throw()
+{
+ editableText = shouldBeEditable;
+
+ if (valueBox != 0)
+ valueBox->setEditable (shouldBeEditable && isEnabled());
+}
+
+void Slider::showTextBox()
+{
+ jassert (editableText); // this should probably be avoided in read-only sliders.
+
+ if (valueBox != 0)
+ valueBox->showEditor();
+}
+
+void Slider::hideTextBox (const bool discardCurrentEditorContents)
+{
+ if (valueBox != 0)
+ {
+ valueBox->hideEditor (discardCurrentEditorContents);
+
+ if (discardCurrentEditorContents)
+ updateText();
+ }
+}
+
+void Slider::setChangeNotificationOnlyOnRelease (const bool onlyNotifyOnRelease) throw()
+{
+ sendChangeOnlyOnRelease = onlyNotifyOnRelease;
+}
+
+void Slider::setSliderSnapsToMousePosition (const bool shouldSnapToMouse) throw()
+{
+ snapsToMousePos = shouldSnapToMouse;
+}
+
+void Slider::setPopupDisplayEnabled (const bool enabled,
+ Component* const parentComponentToUse) throw()
+{
+ popupDisplayEnabled = enabled;
+ parentForPopupDisplay = parentComponentToUse;
+}
+
+void Slider::colourChanged()
+{
+ lookAndFeelChanged();
+}
+
+void Slider::lookAndFeelChanged()
+{
+ const String previousTextBoxContent (valueBox != 0 ? valueBox->getText()
+ : getTextFromValue (currentValue));
+
+ deleteAllChildren();
+ valueBox = 0;
+
+ LookAndFeel& lf = getLookAndFeel();
+
+ if (textBoxPos != NoTextBox)
+ {
+ addAndMakeVisible (valueBox = getLookAndFeel().createSliderTextBox (*this));
+
+ valueBox->setWantsKeyboardFocus (false);
+ valueBox->setText (previousTextBoxContent, false);
+
+ valueBox->setEditable (editableText && isEnabled());
+ valueBox->addListener (this);
+
+ if (style == LinearBar)
+ valueBox->addMouseListener (this, false);
+ }
+
+ if (style == IncDecButtons)
+ {
+ addAndMakeVisible (incButton = lf.createSliderButton (true));
+ incButton->addButtonListener (this);
+
+ addAndMakeVisible (decButton = lf.createSliderButton (false));
+ decButton->addButtonListener (this);
+
+ if (incDecButtonMode != incDecButtonsNotDraggable)
+ {
+ incButton->addMouseListener (this, false);
+ decButton->addMouseListener (this, false);
+ }
+ else
+ {
+ incButton->setRepeatSpeed (300, 100, 20);
+ incButton->addMouseListener (decButton, false);
+
+ decButton->setRepeatSpeed (300, 100, 20);
+ decButton->addMouseListener (incButton, false);
+ }
+ }
+
+ setComponentEffect (lf.getSliderEffect());
+
+ resized();
+ repaint();
+}
+
+void Slider::setRange (const double newMin,
+ const double newMax,
+ const double newInt)
+{
+ if (minimum != newMin
+ || maximum != newMax
+ || interval != newInt)
+ {
+ minimum = newMin;
+ maximum = newMax;
+ interval = newInt;
+
+ // figure out the number of DPs needed to display all values at this
+ // interval setting.
+ numDecimalPlaces = 7;
+
+ if (newInt != 0)
+ {
+ int v = abs ((int) (newInt * 10000000));
+
+ while ((v % 10) == 0)
+ {
+ --numDecimalPlaces;
+ v /= 10;
+ }
+ }
+
+ // keep the current values inside the new range..
+ if (style != TwoValueHorizontal && style != TwoValueVertical)
+ {
+ setValue (currentValue, false, false);
+ }
+ else
+ {
+ setMinValue (getMinValue(), false, false);
+ setMaxValue (getMaxValue(), false, false);
+ }
+
+ updateText();
+ }
+}
+
+void Slider::triggerChangeMessage (const bool synchronous)
+{
+ if (synchronous)
+ handleAsyncUpdate();
+ else
+ triggerAsyncUpdate();
+
+ valueChanged();
+}
+
+double Slider::getValue() const throw()
+{
+ // for a two-value style slider, you should use the getMinValue() and getMaxValue()
+ // methods to get the two values.
+ jassert (style != TwoValueHorizontal && style != TwoValueVertical);
+
+ return currentValue;
+}
+
+void Slider::setValue (double newValue,
+ const bool sendUpdateMessage,
+ const bool sendMessageSynchronously)
+{
+ // for a two-value style slider, you should use the setMinValue() and setMaxValue()
+ // methods to set the two values.
+ jassert (style != TwoValueHorizontal && style != TwoValueVertical);
+
+ newValue = constrainedValue (newValue);
+
+ if (style == ThreeValueHorizontal || style == ThreeValueVertical)
+ {
+ jassert (valueMin <= valueMax);
+ newValue = jlimit (valueMin, valueMax, newValue);
+ }
+
+ if (currentValue != newValue)
+ {
+ if (valueBox != 0)
+ valueBox->hideEditor (true);
+
+ currentValue = newValue;
+ updateText();
+ repaint();
+
+ if (popupDisplay != 0)
+ {
+ ((SliderPopupDisplayComponent*) popupDisplay)->updatePosition (getTextFromValue (currentValue));
+ popupDisplay->repaint();
+ }
+
+ if (sendUpdateMessage)
+ triggerChangeMessage (sendMessageSynchronously);
+ }
+}
+
+double Slider::getMinValue() const throw()
+{
+ // The minimum value only applies to sliders that are in two- or three-value mode.
+ jassert (style == TwoValueHorizontal || style == TwoValueVertical
+ || style == ThreeValueHorizontal || style == ThreeValueVertical);
+
+ return valueMin;
+}
+
+double Slider::getMaxValue() const throw()
+{
+ // The maximum value only applies to sliders that are in two- or three-value mode.
+ jassert (style == TwoValueHorizontal || style == TwoValueVertical
+ || style == ThreeValueHorizontal || style == ThreeValueVertical);
+
+ return valueMax;
+}
+
+void Slider::setMinValue (double newValue, const bool sendUpdateMessage, const bool sendMessageSynchronously)
+{
+ // The minimum value only applies to sliders that are in two- or three-value mode.
+ jassert (style == TwoValueHorizontal || style == TwoValueVertical
+ || style == ThreeValueHorizontal || style == ThreeValueVertical);
+
+ newValue = constrainedValue (newValue);
+
+ if (style == TwoValueHorizontal || style == TwoValueVertical)
+ newValue = jmin (valueMax, newValue);
+ else
+ newValue = jmin (currentValue, newValue);
+
+ if (valueMin != newValue)
+ {
+ valueMin = newValue;
+ repaint();
+
+ if (popupDisplay != 0)
+ {
+ ((SliderPopupDisplayComponent*) popupDisplay)->updatePosition (getTextFromValue (valueMin));
+ popupDisplay->repaint();
+ }
+
+ if (sendUpdateMessage)
+ triggerChangeMessage (sendMessageSynchronously);
+ }
+}
+
+void Slider::setMaxValue (double newValue, const bool sendUpdateMessage, const bool sendMessageSynchronously)
+{
+ // The maximum value only applies to sliders that are in two- or three-value mode.
+ jassert (style == TwoValueHorizontal || style == TwoValueVertical
+ || style == ThreeValueHorizontal || style == ThreeValueVertical);
+
+ newValue = constrainedValue (newValue);
+
+ if (style == TwoValueHorizontal || style == TwoValueVertical)
+ newValue = jmax (valueMin, newValue);
+ else
+ newValue = jmax (currentValue, newValue);
+
+ if (valueMax != newValue)
+ {
+ valueMax = newValue;
+ repaint();
+
+ if (popupDisplay != 0)
+ {
+ ((SliderPopupDisplayComponent*) popupDisplay)->updatePosition (getTextFromValue (valueMax));
+ popupDisplay->repaint();
+ }
+
+ if (sendUpdateMessage)
+ triggerChangeMessage (sendMessageSynchronously);
+ }
+}
+
+void Slider::setDoubleClickReturnValue (const bool isDoubleClickEnabled,
+ const double valueToSetOnDoubleClick) throw()
+{
+ doubleClickToValue = isDoubleClickEnabled;
+ doubleClickReturnValue = valueToSetOnDoubleClick;
+}
+
+double Slider::getDoubleClickReturnValue (bool& isEnabled_) const throw()
+{
+ isEnabled_ = doubleClickToValue;
+ return doubleClickReturnValue;
+}
+
+void Slider::updateText()
+{
+ if (valueBox != 0)
+ valueBox->setText (getTextFromValue (currentValue), false);
+}
+
+void Slider::setTextValueSuffix (const String& suffix)
+{
+ if (textSuffix != suffix)
+ {
+ textSuffix = suffix;
+ updateText();
+ }
+}
+
+const String Slider::getTextFromValue (double v)
+{
+ if (numDecimalPlaces > 0)
+ return String (v, numDecimalPlaces) + textSuffix;
+ else
+ return String (roundDoubleToInt (v)) + textSuffix;
+}
+
+double Slider::getValueFromText (const String& text)
+{
+ String t (text.trimStart());
+
+ if (t.endsWith (textSuffix))
+ t = t.substring (0, t.length() - textSuffix.length());
+
+ while (t.startsWithChar (T('+')))
+ t = t.substring (1).trimStart();
+
+ return t.initialSectionContainingOnly (T("0123456789.,-"))
+ .getDoubleValue();
+}
+
+double Slider::proportionOfLengthToValue (double proportion)
+{
+ if (skewFactor != 1.0 && proportion > 0.0)
+ proportion = exp (log (proportion) / skewFactor);
+
+ return minimum + (maximum - minimum) * proportion;
+}
+
+double Slider::valueToProportionOfLength (double value)
+{
+ const double n = (value - minimum) / (maximum - minimum);
+
+ return skewFactor == 1.0 ? n : pow (n, skewFactor);
+}
+
+double Slider::snapValue (double attemptedValue, const bool)
+{
+ return attemptedValue;
+}
+
+void Slider::startedDragging()
+{
+}
+
+void Slider::stoppedDragging()
+{
+}
+
+void Slider::valueChanged()
+{
+}
+
+void Slider::enablementChanged()
+{
+ repaint();
+}
+
+void Slider::setPopupMenuEnabled (const bool menuEnabled_) throw()
+{
+ menuEnabled = menuEnabled_;
+}
+
+void Slider::setScrollWheelEnabled (const bool enabled) throw()
+{
+ scrollWheelEnabled = enabled;
+}
+
+void Slider::labelTextChanged (Label* label)
+{
+ const double newValue = snapValue (getValueFromText (label->getText()), false);
+
+ if (getValue() != newValue)
+ {
+ sendDragStart();
+ setValue (newValue, true, true);
+ sendDragEnd();
+ }
+
+ updateText(); // force a clean-up of the text, needed in case setValue() hasn't done this.
+}
+
+void Slider::buttonClicked (Button* button)
+{
+ if (style == IncDecButtons)
+ {
+ sendDragStart();
+
+ if (button == incButton)
+ setValue (snapValue (getValue() + interval, false), true, true);
+ else if (button == decButton)
+ setValue (snapValue (getValue() - interval, false), true, true);
+
+ sendDragEnd();
+ }
+}
+
+double Slider::constrainedValue (double value) const throw()
+{
+ if (interval > 0)
+ value = minimum + interval * floor ((value - minimum) / interval + 0.5);
+
+ if (value <= minimum || maximum <= minimum)
+ value = minimum;
+ else if (value >= maximum)
+ value = maximum;
+
+ return value;
+}
+
+float Slider::getLinearSliderPos (const double value)
+{
+ double sliderPosProportional;
+
+ if (maximum > minimum)
+ {
+ if (value < minimum)
+ {
+ sliderPosProportional = 0.0;
+ }
+ else if (value > maximum)
+ {
+ sliderPosProportional = 1.0;
+ }
+ else
+ {
+ sliderPosProportional = valueToProportionOfLength (value);
+ jassert (sliderPosProportional >= 0 && sliderPosProportional <= 1.0);
+ }
+ }
+ else
+ {
+ sliderPosProportional = 0.5;
+ }
+
+ if (style == LinearVertical || style == IncDecButtons)
+ sliderPosProportional = 1.0 - sliderPosProportional;
+
+ return (float) (sliderRegionStart + sliderPosProportional * sliderRegionSize);
+}
+
+bool Slider::isHorizontal() const throw()
+{
+ return style == LinearHorizontal
+ || style == LinearBar
+ || style == TwoValueHorizontal
+ || style == ThreeValueHorizontal;
+}
+
+bool Slider::isVertical() const throw()
+{
+ return style == LinearVertical
+ || style == TwoValueVertical
+ || style == ThreeValueVertical;
+}
+
+bool Slider::incDecDragDirectionIsHorizontal() const throw()
+{
+ return incDecButtonMode == incDecButtonsDraggable_Horizontal
+ || (incDecButtonMode == incDecButtonsDraggable_AutoDirection && incDecButtonsSideBySide);
+}
+
+float Slider::getPositionOfValue (const double value)
+{
+ if (isHorizontal() || isVertical())
+ {
+ return getLinearSliderPos (value);
+ }
+ else
+ {
+ jassertfalse // not a valid call on a slider that doesn't work linearly!
+ return 0.0f;
+ }
+}
+
+void Slider::paint (Graphics& g)
+{
+ if (style != IncDecButtons)
+ {
+ if (style == Rotary || style == RotaryHorizontalDrag || style == RotaryVerticalDrag)
+ {
+ const float sliderPos = (float) valueToProportionOfLength (currentValue);
+ jassert (sliderPos >= 0 && sliderPos <= 1.0f);
+
+ getLookAndFeel().drawRotarySlider (g,
+ sliderRect.getX(),
+ sliderRect.getY(),
+ sliderRect.getWidth(),
+ sliderRect.getHeight(),
+ sliderPos,
+ rotaryStart, rotaryEnd,
+ *this);
+ }
+ else
+ {
+ getLookAndFeel().drawLinearSlider (g,
+ sliderRect.getX(),
+ sliderRect.getY(),
+ sliderRect.getWidth(),
+ sliderRect.getHeight(),
+ getLinearSliderPos (currentValue),
+ getLinearSliderPos (valueMin),
+ getLinearSliderPos (valueMax),
+ style,
+ *this);
+ }
+
+ if (style == LinearBar && valueBox == 0)
+ {
+ g.setColour (findColour (Slider::textBoxOutlineColourId));
+ g.drawRect (0, 0, getWidth(), getHeight(), 1);
+ }
+ }
+}
+
+void Slider::resized()
+{
+ int minXSpace = 0;
+ int minYSpace = 0;
+
+ if (textBoxPos == TextBoxLeft || textBoxPos == TextBoxRight)
+ minXSpace = 30;
+ else
+ minYSpace = 15;
+
+ const int tbw = jmax (0, jmin (textBoxWidth, getWidth() - minXSpace));
+ const int tbh = jmax (0, jmin (textBoxHeight, getHeight() - minYSpace));
+
+ if (style == LinearBar)
+ {
+ if (valueBox != 0)
+ valueBox->setBounds (0, 0, getWidth(), getHeight());
+ }
+ else
+ {
+ if (textBoxPos == NoTextBox)
+ {
+ sliderRect.setBounds (0, 0, getWidth(), getHeight());
+ }
+ else if (textBoxPos == TextBoxLeft)
+ {
+ valueBox->setBounds (0, (getHeight() - tbh) / 2, tbw, tbh);
+ sliderRect.setBounds (tbw, 0, getWidth() - tbw, getHeight());
+ }
+ else if (textBoxPos == TextBoxRight)
+ {
+ valueBox->setBounds (getWidth() - tbw, (getHeight() - tbh) / 2, tbw, tbh);
+ sliderRect.setBounds (0, 0, getWidth() - tbw, getHeight());
+ }
+ else if (textBoxPos == TextBoxAbove)
+ {
+ valueBox->setBounds ((getWidth() - tbw) / 2, 0, tbw, tbh);
+ sliderRect.setBounds (0, tbh, getWidth(), getHeight() - tbh);
+ }
+ else if (textBoxPos == TextBoxBelow)
+ {
+ valueBox->setBounds ((getWidth() - tbw) / 2, getHeight() - tbh, tbw, tbh);
+ sliderRect.setBounds (0, 0, getWidth(), getHeight() - tbh);
+ }
+ }
+
+ const int indent = getLookAndFeel().getSliderThumbRadius (*this);
+
+ if (style == LinearBar)
+ {
+ const int barIndent = 1;
+ sliderRegionStart = barIndent;
+ sliderRegionSize = getWidth() - barIndent * 2;
+
+ sliderRect.setBounds (sliderRegionStart, barIndent,
+ sliderRegionSize, getHeight() - barIndent * 2);
+ }
+ else if (isHorizontal())
+ {
+ sliderRegionStart = sliderRect.getX() + indent;
+ sliderRegionSize = jmax (1, sliderRect.getWidth() - indent * 2);
+
+ sliderRect.setBounds (sliderRegionStart, sliderRect.getY(),
+ sliderRegionSize, sliderRect.getHeight());
+ }
+ else if (isVertical())
+ {
+ sliderRegionStart = sliderRect.getY() + indent;
+ sliderRegionSize = jmax (1, sliderRect.getHeight() - indent * 2);
+
+ sliderRect.setBounds (sliderRect.getX(), sliderRegionStart,
+ sliderRect.getWidth(), sliderRegionSize);
+ }
+ else
+ {
+ sliderRegionStart = 0;
+ sliderRegionSize = 100;
+ }
+
+ if (style == IncDecButtons)
+ {
+ Rectangle buttonRect (sliderRect);
+
+ if (textBoxPos == TextBoxLeft || textBoxPos == TextBoxRight)
+ buttonRect.expand (-2, 0);
+ else
+ buttonRect.expand (0, -2);
+
+ incDecButtonsSideBySide = buttonRect.getWidth() > buttonRect.getHeight();
+
+ if (incDecButtonsSideBySide)
+ {
+ decButton->setBounds (buttonRect.getX(),
+ buttonRect.getY(),
+ buttonRect.getWidth() / 2,
+ buttonRect.getHeight());
+
+ decButton->setConnectedEdges (Button::ConnectedOnRight);
+
+ incButton->setBounds (buttonRect.getCentreX(),
+ buttonRect.getY(),
+ buttonRect.getWidth() / 2,
+ buttonRect.getHeight());
+
+ incButton->setConnectedEdges (Button::ConnectedOnLeft);
+ }
+ else
+ {
+ incButton->setBounds (buttonRect.getX(),
+ buttonRect.getY(),
+ buttonRect.getWidth(),
+ buttonRect.getHeight() / 2);
+
+ incButton->setConnectedEdges (Button::ConnectedOnBottom);
+
+ decButton->setBounds (buttonRect.getX(),
+ buttonRect.getCentreY(),
+ buttonRect.getWidth(),
+ buttonRect.getHeight() / 2);
+
+ decButton->setConnectedEdges (Button::ConnectedOnTop);
+ }
+ }
+}
+
+void Slider::focusOfChildComponentChanged (FocusChangeType)
+{
+ repaint();
+}
+
+void Slider::mouseDown (const MouseEvent& e)
+{
+ mouseWasHidden = false;
+ incDecDragged = false;
+
+ if (isEnabled())
+ {
+ if (e.mods.isPopupMenu() && menuEnabled)
+ {
+ menuShown = true;
+
+ PopupMenu m;
+ m.addItem (1, TRANS ("velocity-sensitive mode"), true, isVelocityBased);
+ m.addSeparator();
+
+ if (style == Rotary || style == RotaryHorizontalDrag || style == RotaryVerticalDrag)
+ {
+ PopupMenu rotaryMenu;
+ rotaryMenu.addItem (2, TRANS ("use circular dragging"), true, style == Rotary);
+ rotaryMenu.addItem (3, TRANS ("use left-right dragging"), true, style == RotaryHorizontalDrag);
+ rotaryMenu.addItem (4, TRANS ("use up-down dragging"), true, style == RotaryVerticalDrag);
+
+ m.addSubMenu (TRANS ("rotary mode"), rotaryMenu);
+ }
+
+ const int r = m.show();
+
+ if (r == 1)
+ {
+ setVelocityBasedMode (! isVelocityBased);
+ }
+ else if (r == 2)
+ {
+ setSliderStyle (Rotary);
+ }
+ else if (r == 3)
+ {
+ setSliderStyle (RotaryHorizontalDrag);
+ }
+ else if (r == 4)
+ {
+ setSliderStyle (RotaryVerticalDrag);
+ }
+ }
+ else if (maximum > minimum)
+ {
+ menuShown = false;
+
+ if (valueBox != 0)
+ valueBox->hideEditor (true);
+
+ sliderBeingDragged = 0;
+
+ if (style == TwoValueHorizontal
+ || style == TwoValueVertical
+ || style == ThreeValueHorizontal
+ || style == ThreeValueVertical)
+ {
+ const float mousePos = (float) (isVertical() ? e.y : e.x);
+
+ const float normalPosDistance = fabsf (getLinearSliderPos (currentValue) - mousePos);
+ const float minPosDistance = fabsf (getLinearSliderPos (valueMin) - 0.1f - mousePos);
+ const float maxPosDistance = fabsf (getLinearSliderPos (valueMax) + 0.1f - mousePos);
+
+ if (style == TwoValueHorizontal || style == TwoValueVertical)
+ {
+ if (maxPosDistance <= minPosDistance)
+ sliderBeingDragged = 2;
+ else
+ sliderBeingDragged = 1;
+ }
+ else if (style == ThreeValueHorizontal || style == ThreeValueVertical)
+ {
+ if (normalPosDistance >= minPosDistance && maxPosDistance >= minPosDistance)
+ sliderBeingDragged = 1;
+ else if (normalPosDistance >= maxPosDistance)
+ sliderBeingDragged = 2;
+ }
+ }
+
+ minMaxDiff = valueMax - valueMin;
+
+ mouseXWhenLastDragged = e.x;
+ mouseYWhenLastDragged = e.y;
+ lastAngle = rotaryStart + (rotaryEnd - rotaryStart)
+ * valueToProportionOfLength (currentValue);
+
+ if (sliderBeingDragged == 2)
+ valueWhenLastDragged = valueMax;
+ else if (sliderBeingDragged == 1)
+ valueWhenLastDragged = valueMin;
+ else
+ valueWhenLastDragged = currentValue;
+
+ valueOnMouseDown = valueWhenLastDragged;
+
+ if (popupDisplayEnabled)
+ {
+ SliderPopupDisplayComponent* const popup = new SliderPopupDisplayComponent (this);
+ popupDisplay = popup;
+
+ if (parentForPopupDisplay != 0)
+ {
+ parentForPopupDisplay->addChildComponent (popup);
+ }
+ else
+ {
+ popup->addToDesktop (0);
+ }
+
+ popup->setVisible (true);
+ }
+
+ sendDragStart();
+
+ mouseDrag (e);
+ }
+ }
+}
+
+void Slider::mouseUp (const MouseEvent&)
+{
+ if (isEnabled()
+ && (! menuShown)
+ && (maximum > minimum)
+ && (style != IncDecButtons || incDecDragged))
+ {
+ restoreMouseIfHidden();
+
+ if (sendChangeOnlyOnRelease && valueOnMouseDown != currentValue)
+ triggerChangeMessage (false);
+
+ sendDragEnd();
+
+ deleteAndZero (popupDisplay);
+
+ if (style == IncDecButtons)
+ {
+ incButton->setState (Button::buttonNormal);
+ decButton->setState (Button::buttonNormal);
+ }
+ }
+}
+
+void Slider::restoreMouseIfHidden()
+{
+ if (mouseWasHidden)
+ {
+ mouseWasHidden = false;
+
+ Component* c = Component::getComponentUnderMouse();
+
+ if (c == 0)
+ c = this;
+
+ c->enableUnboundedMouseMovement (false);
+
+ const double pos = (sliderBeingDragged == 2) ? getMaxValue()
+ : ((sliderBeingDragged == 1) ? getMinValue()
+ : currentValue);
+
+ const int pixelPos = (int) getLinearSliderPos (pos);
+
+ int x = isHorizontal() ? pixelPos : (getWidth() / 2);
+ int y = isVertical() ? pixelPos : (getHeight() / 2);
+
+ relativePositionToGlobal (x, y);
+ Desktop::setMousePosition (x, y);
+ }
+}
+
+void Slider::modifierKeysChanged (const ModifierKeys& modifiers)
+{
+ if (isEnabled()
+ && style != IncDecButtons
+ && style != Rotary
+ && isVelocityBased == modifiers.isAnyModifierKeyDown())
+ {
+ restoreMouseIfHidden();
+ }
+}
+
+static double smallestAngleBetween (double a1, double a2)
+{
+ return jmin (fabs (a1 - a2),
+ fabs (a1 + double_Pi * 2.0 - a2),
+ fabs (a2 + double_Pi * 2.0 - a1));
+}
+
+void Slider::mouseDrag (const MouseEvent& e)
+{
+ if (isEnabled()
+ && (! menuShown)
+ && (maximum > minimum))
+ {
+ if (style == Rotary)
+ {
+ int dx = e.x - sliderRect.getCentreX();
+ int dy = e.y - sliderRect.getCentreY();
+
+ if (dx * dx + dy * dy > 25)
+ {
+ double angle = atan2 ((double) dx, (double) -dy);
+ while (angle < 0.0)
+ angle += double_Pi * 2.0;
+
+ if (rotaryStop && ! e.mouseWasClicked())
+ {
+ if (fabs (angle - lastAngle) > double_Pi)
+ {
+ if (angle >= lastAngle)
+ angle -= double_Pi * 2.0;
+ else
+ angle += double_Pi * 2.0;
+ }
+
+ if (angle >= lastAngle)
+ angle = jmin (angle, (double) jmax (rotaryStart, rotaryEnd));
+ else
+ angle = jmax (angle, (double) jmin (rotaryStart, rotaryEnd));
+ }
+ else
+ {
+ while (angle < rotaryStart)
+ angle += double_Pi * 2.0;
+
+ if (angle > rotaryEnd)
+ {
+ if (smallestAngleBetween (angle, rotaryStart) <= smallestAngleBetween (angle, rotaryEnd))
+ angle = rotaryStart;
+ else
+ angle = rotaryEnd;
+ }
+ }
+
+ const double proportion = (angle - rotaryStart) / (rotaryEnd - rotaryStart);
+
+ valueWhenLastDragged = proportionOfLengthToValue (jlimit (0.0, 1.0, proportion));
+
+ lastAngle = angle;
+ }
+ }
+ else
+ {
+ if (style == LinearBar && e.mouseWasClicked()
+ && valueBox != 0 && valueBox->isEditable())
+ return;
+
+ if (style == IncDecButtons)
+ {
+ if (! incDecDragged)
+ incDecDragged = e.getDistanceFromDragStart() > 10 && ! e.mouseWasClicked();
+
+ if (! incDecDragged)
+ return;
+ }
+
+ if ((isVelocityBased == (userKeyOverridesVelocity ? e.mods.testFlags (ModifierKeys::ctrlModifier | ModifierKeys::commandModifier | ModifierKeys::altModifier)
+ : false))
+ || ((maximum - minimum) / sliderRegionSize < interval))
+ {
+ const int mousePos = (isHorizontal() || style == RotaryHorizontalDrag) ? e.x : e.y;
+
+ double scaledMousePos = (mousePos - sliderRegionStart) / (double) sliderRegionSize;
+
+ if (style == RotaryHorizontalDrag
+ || style == RotaryVerticalDrag
+ || style == IncDecButtons
+ || ((style == LinearHorizontal || style == LinearVertical || style == LinearBar)
+ && ! snapsToMousePos))
+ {
+ const int mouseDiff = (style == RotaryHorizontalDrag
+ || style == LinearHorizontal
+ || style == LinearBar
+ || (style == IncDecButtons && incDecDragDirectionIsHorizontal()))
+ ? e.getDistanceFromDragStartX()
+ : -e.getDistanceFromDragStartY();
+
+ double newPos = valueToProportionOfLength (valueOnMouseDown)
+ + mouseDiff * (1.0 / pixelsForFullDragExtent);
+
+ valueWhenLastDragged = proportionOfLengthToValue (jlimit (0.0, 1.0, newPos));
+
+ if (style == IncDecButtons)
+ {
+ incButton->setState (mouseDiff < 0 ? Button::buttonNormal : Button::buttonDown);
+ decButton->setState (mouseDiff > 0 ? Button::buttonNormal : Button::buttonDown);
+ }
+ }
+ else
+ {
+ if (style == LinearVertical)
+ scaledMousePos = 1.0 - scaledMousePos;
+
+ valueWhenLastDragged = proportionOfLengthToValue (jlimit (0.0, 1.0, scaledMousePos));
+ }
+ }
+ else
+ {
+ const int mouseDiff = (isHorizontal() || style == RotaryHorizontalDrag
+ || (style == IncDecButtons && incDecDragDirectionIsHorizontal()))
+ ? e.x - mouseXWhenLastDragged
+ : e.y - mouseYWhenLastDragged;
+
+ const double maxSpeed = jmax (200, sliderRegionSize);
+ double speed = jlimit (0.0, maxSpeed, (double) abs (mouseDiff));
+
+ if (speed != 0)
+ {
+ speed = 0.2 * velocityModeSensitivity
+ * (1.0 + sin (double_Pi * (1.5 + jmin (0.5, velocityModeOffset
+ + jmax (0.0, (double) (speed - velocityModeThreshold))
+ / maxSpeed))));
+
+ if (mouseDiff < 0)
+ speed = -speed;
+
+ if (style == LinearVertical || style == RotaryVerticalDrag
+ || (style == IncDecButtons && ! incDecDragDirectionIsHorizontal()))
+ speed = -speed;
+
+ const double currentPos = valueToProportionOfLength (valueWhenLastDragged);
+
+ valueWhenLastDragged = proportionOfLengthToValue (jlimit (0.0, 1.0, currentPos + speed));
+
+ e.originalComponent->enableUnboundedMouseMovement (true, false);
+ mouseWasHidden = true;
+ }
+ }
+ }
+
+ valueWhenLastDragged = jlimit (minimum, maximum, valueWhenLastDragged);
+
+ if (sliderBeingDragged == 0)
+ {
+ setValue (snapValue (valueWhenLastDragged, true),
+ ! sendChangeOnlyOnRelease, true);
+ }
+ else if (sliderBeingDragged == 1)
+ {
+ setMinValue (snapValue (valueWhenLastDragged, true),
+ ! sendChangeOnlyOnRelease, false);
+
+ if (e.mods.isShiftDown())
+ setMaxValue (getMinValue() + minMaxDiff, false);
+ else
+ minMaxDiff = valueMax - valueMin;
+ }
+ else
+ {
+ jassert (sliderBeingDragged == 2);
+
+ setMaxValue (snapValue (valueWhenLastDragged, true),
+ ! sendChangeOnlyOnRelease, false);
+
+ if (e.mods.isShiftDown())
+ setMinValue (getMaxValue() - minMaxDiff, false);
+ else
+ minMaxDiff = valueMax - valueMin;
+ }
+
+ mouseXWhenLastDragged = e.x;
+ mouseYWhenLastDragged = e.y;
+
+ // (repainting synchronously makes the sliders feel a bit snappier..)
+ ComponentPeer* const peer = getPeer();
+
+ if (peer != 0)
+ peer->performAnyPendingRepaintsNow();
+ }
+}
+
+void Slider::mouseDoubleClick (const MouseEvent&)
+{
+ if (doubleClickToValue
+ && isEnabled()
+ && style != IncDecButtons
+ && minimum <= doubleClickReturnValue
+ && maximum >= doubleClickReturnValue)
+ {
+ sendDragStart();
+ setValue (doubleClickReturnValue, true, true);
+ sendDragEnd();
+ }
+}
+
+void Slider::mouseWheelMove (const MouseEvent& e, float wheelIncrementX, float wheelIncrementY)
+{
+ if (scrollWheelEnabled && isEnabled())
+ {
+ if (maximum > minimum && ! isMouseButtonDownAnywhere())
+ {
+ if (valueBox != 0)
+ valueBox->hideEditor (false);
+
+ const double proportionDelta = (wheelIncrementX != 0 ? -wheelIncrementX : wheelIncrementY) * 0.15f;
+ const double currentPos = valueToProportionOfLength (currentValue);
+ const double newValue = proportionOfLengthToValue (jlimit (0.0, 1.0, currentPos + proportionDelta));
+
+ double delta = (newValue != currentValue)
+ ? jmax (fabs (newValue - currentValue), interval) : 0;
+
+ if (currentValue > newValue)
+ delta = -delta;
+
+ sendDragStart();
+ setValue (snapValue (currentValue + delta, false), true, true);
+ sendDragEnd();
+ }
+ }
+ else
+ {
+ Component::mouseWheelMove (e, wheelIncrementX, wheelIncrementY);
+ }
+}
+
+void SliderListener::sliderDragStarted (Slider*)
+{
+}
+
+void SliderListener::sliderDragEnded (Slider*)
+{
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_Slider.cpp *********/
+
+/********* Start of inlined file: juce_TableHeaderComponent.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+class DragOverlayComp : public Component
+{
+public:
+ DragOverlayComp (Image* const image_)
+ : image (image_)
+ {
+ image->multiplyAllAlphas (0.8f);
+ setAlwaysOnTop (true);
+ }
+
+ ~DragOverlayComp()
+ {
+ delete image;
+ }
+
+ void paint (Graphics& g)
+ {
+ g.drawImageAt (image, 0, 0);
+ }
+
+private:
+ Image* image;
+
+ DragOverlayComp (const DragOverlayComp&);
+ const DragOverlayComp& operator= (const DragOverlayComp&);
+};
+
+TableHeaderComponent::TableHeaderComponent()
+ : listeners (2),
+ dragOverlayComp (0),
+ columnsChanged (false),
+ columnsResized (false),
+ sortChanged (false),
+ menuActive (true),
+ stretchToFit (false),
+ columnIdBeingResized (0),
+ columnIdBeingDragged (0),
+ columnIdUnderMouse (0),
+ lastDeliberateWidth (0)
+{
+}
+
+TableHeaderComponent::~TableHeaderComponent()
+{
+ delete dragOverlayComp;
+}
+
+void TableHeaderComponent::setPopupMenuActive (const bool hasMenu)
+{
+ menuActive = hasMenu;
+}
+
+bool TableHeaderComponent::isPopupMenuActive() const throw() { return menuActive; }
+
+int TableHeaderComponent::getNumColumns (const bool onlyCountVisibleColumns) const throw()
+{
+ if (onlyCountVisibleColumns)
+ {
+ int num = 0;
+
+ for (int i = columns.size(); --i >= 0;)
+ if (columns.getUnchecked(i)->isVisible())
+ ++num;
+
+ return num;
+ }
+ else
+ {
+ return columns.size();
+ }
+}
+
+const String TableHeaderComponent::getColumnName (const int columnId) const throw()
+{
+ const ColumnInfo* const ci = getInfoForId (columnId);
+ return ci != 0 ? ci->name : String::empty;
+}
+
+void TableHeaderComponent::setColumnName (const int columnId, const String& newName)
+{
+ ColumnInfo* const ci = getInfoForId (columnId);
+
+ if (ci != 0 && ci->name != newName)
+ {
+ ci->name = newName;
+ sendColumnsChanged();
+ }
+}
+
+void TableHeaderComponent::addColumn (const String& columnName,
+ const int columnId,
+ const int width,
+ const int minimumWidth,
+ const int maximumWidth,
+ const int propertyFlags,
+ const int insertIndex)
+{
+ // can't have a duplicate or null ID!
+ jassert (columnId != 0 && getIndexOfColumnId (columnId, false) < 0);
+ jassert (width > 0);
+
+ ColumnInfo* const ci = new ColumnInfo();
+ ci->name = columnName;
+ ci->id = columnId;
+ ci->width = width;
+ ci->lastDeliberateWidth = width;
+ ci->minimumWidth = minimumWidth;
+ ci->maximumWidth = maximumWidth;
+ if (ci->maximumWidth < 0)
+ ci->maximumWidth = INT_MAX;
+ jassert (ci->maximumWidth >= ci->minimumWidth);
+ ci->propertyFlags = propertyFlags;
+
+ columns.insert (insertIndex, ci);
+ sendColumnsChanged();
+}
+
+void TableHeaderComponent::removeColumn (const int columnIdToRemove)
+{
+ const int index = getIndexOfColumnId (columnIdToRemove, false);
+
+ if (index >= 0)
+ {
+ columns.remove (index);
+ sortChanged = true;
+ sendColumnsChanged();
+ }
+}
+
+void TableHeaderComponent::removeAllColumns()
+{
+ if (columns.size() > 0)
+ {
+ columns.clear();
+ sendColumnsChanged();
+ }
+}
+
+void TableHeaderComponent::moveColumn (const int columnId, int newIndex)
+{
+ const int currentIndex = getIndexOfColumnId (columnId, false);
+ newIndex = visibleIndexToTotalIndex (newIndex);
+
+ if (columns [currentIndex] != 0 && currentIndex != newIndex)
+ {
+ columns.move (currentIndex, newIndex);
+ sendColumnsChanged();
+ }
+}
+
+void TableHeaderComponent::setColumnWidth (const int columnId, const int newWidth)
+{
+ ColumnInfo* const ci = getInfoForId (columnId);
+
+ if (ci != 0 && ci->width != newWidth)
+ {
+ const int numColumns = getNumColumns (true);
+
+ ci->lastDeliberateWidth = ci->width
+ = jlimit (ci->minimumWidth, ci->maximumWidth, newWidth);
+
+ if (stretchToFit)
+ {
+ const int index = getIndexOfColumnId (columnId, true) + 1;
+
+ if (((unsigned int) index) < (unsigned int) numColumns)
+ {
+ const int x = getColumnPosition (index).getX();
+
+ if (lastDeliberateWidth == 0)
+ lastDeliberateWidth = getTotalWidth();
+
+ resizeColumnsToFit (visibleIndexToTotalIndex (index), lastDeliberateWidth - x);
+ }
+ }
+
+ repaint();
+ columnsResized = true;
+ triggerAsyncUpdate();
+ }
+}
+
+int TableHeaderComponent::getIndexOfColumnId (const int columnId, const bool onlyCountVisibleColumns) const throw()
+{
+ int n = 0;
+
+ for (int i = 0; i < columns.size(); ++i)
+ {
+ if ((! onlyCountVisibleColumns) || columns.getUnchecked(i)->isVisible())
+ {
+ if (columns.getUnchecked(i)->id == columnId)
+ return n;
+
+ ++n;
+ }
+ }
+
+ return -1;
+}
+
+int TableHeaderComponent::getColumnIdOfIndex (int index, const bool onlyCountVisibleColumns) const throw()
+{
+ if (onlyCountVisibleColumns)
+ index = visibleIndexToTotalIndex (index);
+
+ const ColumnInfo* const ci = columns [index];
+ return (ci != 0) ? ci->id : 0;
+}
+
+const Rectangle TableHeaderComponent::getColumnPosition (const int index) const throw()
+{
+ int x = 0, width = 0, n = 0;
+
+ for (int i = 0; i < columns.size(); ++i)
+ {
+ x += width;
+
+ if (columns.getUnchecked(i)->isVisible())
+ {
+ width = columns.getUnchecked(i)->width;
+
+ if (n++ == index)
+ break;
+ }
+ else
+ {
+ width = 0;
+ }
+ }
+
+ return Rectangle (x, 0, width, getHeight());
+}
+
+int TableHeaderComponent::getColumnIdAtX (const int xToFind) const throw()
+{
+ if (xToFind >= 0)
+ {
+ int x = 0;
+
+ for (int i = 0; i < columns.size(); ++i)
+ {
+ const ColumnInfo* const ci = columns.getUnchecked(i);
+
+ if (ci->isVisible())
+ {
+ x += ci->width;
+
+ if (xToFind < x)
+ return ci->id;
+ }
+ }
+ }
+
+ return 0;
+}
+
+int TableHeaderComponent::getTotalWidth() const throw()
+{
+ int w = 0;
+
+ for (int i = columns.size(); --i >= 0;)
+ if (columns.getUnchecked(i)->isVisible())
+ w += columns.getUnchecked(i)->width;
+
+ return w;
+}
+
+void TableHeaderComponent::setStretchToFitActive (const bool shouldStretchToFit)
+{
+ stretchToFit = shouldStretchToFit;
+ lastDeliberateWidth = getTotalWidth();
+ resized();
+}
+
+bool TableHeaderComponent::isStretchToFitActive() const throw()
+{
+ return stretchToFit;
+}
+
+void TableHeaderComponent::resizeAllColumnsToFit (int targetTotalWidth)
+{
+ if (stretchToFit && getWidth() > 0
+ && columnIdBeingResized == 0 && columnIdBeingDragged == 0)
+ {
+ lastDeliberateWidth = targetTotalWidth;
+ resizeColumnsToFit (0, targetTotalWidth);
+ }
+}
+
+void TableHeaderComponent::resizeColumnsToFit (int firstColumnIndex, int targetTotalWidth)
+{
+ targetTotalWidth = jmax (targetTotalWidth, 0);
+
+ StretchableObjectResizer sor;
+ int i;
+ for (i = firstColumnIndex; i < columns.size(); ++i)
+ {
+ ColumnInfo* const ci = columns.getUnchecked(i);
+
+ if (ci->isVisible())
+ sor.addItem (ci->lastDeliberateWidth, ci->minimumWidth, ci->maximumWidth);
+ }
+
+ sor.resizeToFit (targetTotalWidth);
+
+ int visIndex = 0;
+ for (i = firstColumnIndex; i < columns.size(); ++i)
+ {
+ ColumnInfo* const ci = columns.getUnchecked(i);
+
+ if (ci->isVisible())
+ {
+ const int newWidth = jlimit (ci->minimumWidth, ci->maximumWidth,
+ (int) floor (sor.getItemSize (visIndex++)));
+
+ if (newWidth != ci->width)
+ {
+ ci->width = newWidth;
+ repaint();
+ columnsResized = true;
+ triggerAsyncUpdate();
+ }
+ }
+ }
+}
+
+void TableHeaderComponent::setColumnVisible (const int columnId, const bool shouldBeVisible)
+{
+ ColumnInfo* const ci = getInfoForId (columnId);
+
+ if (ci != 0 && shouldBeVisible != ci->isVisible())
+ {
+ if (shouldBeVisible)
+ ci->propertyFlags |= visible;
+ else
+ ci->propertyFlags &= ~visible;
+
+ sendColumnsChanged();
+ resized();
+ }
+}
+
+bool TableHeaderComponent::isColumnVisible (const int columnId) const
+{
+ const ColumnInfo* const ci = getInfoForId (columnId);
+ return ci != 0 && ci->isVisible();
+}
+
+void TableHeaderComponent::setSortColumnId (const int columnId, const bool sortForwards)
+{
+ if (getSortColumnId() != columnId || isSortedForwards() != sortForwards)
+ {
+ for (int i = columns.size(); --i >= 0;)
+ columns.getUnchecked(i)->propertyFlags &= ~(sortedForwards | sortedBackwards);
+
+ ColumnInfo* const ci = getInfoForId (columnId);
+
+ if (ci != 0)
+ ci->propertyFlags |= (sortForwards ? sortedForwards : sortedBackwards);
+
+ reSortTable();
+ }
+}
+
+int TableHeaderComponent::getSortColumnId() const throw()
+{
+ for (int i = columns.size(); --i >= 0;)
+ if ((columns.getUnchecked(i)->propertyFlags & (sortedForwards | sortedBackwards)) != 0)
+ return columns.getUnchecked(i)->id;
+
+ return 0;
+}
+
+bool TableHeaderComponent::isSortedForwards() const throw()
+{
+ for (int i = columns.size(); --i >= 0;)
+ if ((columns.getUnchecked(i)->propertyFlags & (sortedForwards | sortedBackwards)) != 0)
+ return (columns.getUnchecked(i)->propertyFlags & sortedForwards) != 0;
+
+ return true;
+}
+
+void TableHeaderComponent::reSortTable()
+{
+ sortChanged = true;
+ repaint();
+ triggerAsyncUpdate();
+}
+
+const String TableHeaderComponent::toString() const
+{
+ String s;
+
+ XmlElement doc (T("TABLELAYOUT"));
+
+ doc.setAttribute (T("sortedCol"), getSortColumnId());
+ doc.setAttribute (T("sortForwards"), isSortedForwards());
+
+ for (int i = 0; i < columns.size(); ++i)
+ {
+ const ColumnInfo* const ci = columns.getUnchecked (i);
+
+ XmlElement* const e = new XmlElement (T("COLUMN"));
+ doc.addChildElement (e);
+
+ e->setAttribute (T("id"), ci->id);
+ e->setAttribute (T("visible"), ci->isVisible());
+ e->setAttribute (T("width"), ci->width);
+ }
+
+ return doc.createDocument (String::empty, true, false);
+}
+
+void TableHeaderComponent::restoreFromString (const String& storedVersion)
+{
+ XmlDocument doc (storedVersion);
+ XmlElement* const storedXml = doc.getDocumentElement();
+
+ int index = 0;
+
+ if (storedXml != 0 && storedXml->hasTagName (T("TABLELAYOUT")))
+ {
+ forEachXmlChildElement (*storedXml, col)
+ {
+ const int tabId = col->getIntAttribute (T("id"));
+
+ ColumnInfo* const ci = getInfoForId (tabId);
+
+ if (ci != 0)
+ {
+ columns.move (columns.indexOf (ci), index);
+ ci->width = col->getIntAttribute (T("width"));
+ setColumnVisible (tabId, col->getBoolAttribute (T("visible")));
+ }
+
+ ++index;
+ }
+
+ columnsResized = true;
+ sendColumnsChanged();
+
+ setSortColumnId (storedXml->getIntAttribute (T("sortedCol")),
+ storedXml->getBoolAttribute (T("sortForwards"), true));
+ }
+
+ delete storedXml;
+}
+
+void TableHeaderComponent::addListener (TableHeaderListener* const newListener) throw()
+{
+ listeners.addIfNotAlreadyThere (newListener);
+}
+
+void TableHeaderComponent::removeListener (TableHeaderListener* const listenerToRemove) throw()
+{
+ listeners.removeValue (listenerToRemove);
+}
+
+void TableHeaderComponent::columnClicked (int columnId, const ModifierKeys& mods)
+{
+ const ColumnInfo* const ci = getInfoForId (columnId);
+
+ if (ci != 0 && (ci->propertyFlags & sortable) != 0 && ! mods.isPopupMenu())
+ setSortColumnId (columnId, (ci->propertyFlags & sortedForwards) == 0);
+}
+
+void TableHeaderComponent::addMenuItems (PopupMenu& menu, const int /*columnIdClicked*/)
+{
+ for (int i = 0; i < columns.size(); ++i)
+ {
+ const ColumnInfo* const ci = columns.getUnchecked(i);
+
+ if ((ci->propertyFlags & appearsOnColumnMenu) != 0)
+ menu.addItem (ci->id, ci->name,
+ (ci->propertyFlags & (sortedForwards | sortedBackwards)) == 0,
+ isColumnVisible (ci->id));
+ }
+}
+
+void TableHeaderComponent::reactToMenuItem (const int menuReturnId, const int /*columnIdClicked*/)
+{
+ if (getIndexOfColumnId (menuReturnId, false) >= 0)
+ setColumnVisible (menuReturnId, ! isColumnVisible (menuReturnId));
+}
+
+void TableHeaderComponent::paint (Graphics& g)
+{
+ LookAndFeel& lf = getLookAndFeel();
+
+ lf.drawTableHeaderBackground (g, *this);
+
+ const Rectangle clip (g.getClipBounds());
+
+ int x = 0;
+ for (int i = 0; i < columns.size(); ++i)
+ {
+ const ColumnInfo* const ci = columns.getUnchecked(i);
+
+ if (ci->isVisible())
+ {
+ if (x + ci->width > clip.getX()
+ && (ci->id != columnIdBeingDragged
+ || dragOverlayComp == 0
+ || ! dragOverlayComp->isVisible()))
+ {
+ g.saveState();
+ g.setOrigin (x, 0);
+ g.reduceClipRegion (0, 0, ci->width, getHeight());
+
+ lf.drawTableHeaderColumn (g, ci->name, ci->id, ci->width, getHeight(),
+ ci->id == columnIdUnderMouse,
+ ci->id == columnIdUnderMouse && isMouseButtonDown(),
+ ci->propertyFlags);
+
+ g.restoreState();
+ }
+
+ x += ci->width;
+
+ if (x >= clip.getRight())
+ break;
+ }
+ }
+}
+
+void TableHeaderComponent::resized()
+{
+}
+
+void TableHeaderComponent::mouseMove (const MouseEvent& e)
+{
+ updateColumnUnderMouse (e.x, e.y);
+}
+
+void TableHeaderComponent::mouseEnter (const MouseEvent& e)
+{
+ updateColumnUnderMouse (e.x, e.y);
+}
+
+void TableHeaderComponent::mouseExit (const MouseEvent& e)
+{
+ updateColumnUnderMouse (e.x, e.y);
+}
+
+void TableHeaderComponent::mouseDown (const MouseEvent& e)
+{
+ repaint();
+ columnIdBeingResized = 0;
+ columnIdBeingDragged = 0;
+
+ if (columnIdUnderMouse != 0)
+ {
+ draggingColumnOffset = e.x - getColumnPosition (getIndexOfColumnId (columnIdUnderMouse, true)).getX();
+
+ if (e.mods.isPopupMenu())
+ columnClicked (columnIdUnderMouse, e.mods);
+ }
+
+ if (menuActive && e.mods.isPopupMenu())
+ showColumnChooserMenu (columnIdUnderMouse);
+}
+
+void TableHeaderComponent::mouseDrag (const MouseEvent& e)
+{
+ if (columnIdBeingResized == 0
+ && columnIdBeingDragged == 0
+ && ! (e.mouseWasClicked() || e.mods.isPopupMenu()))
+ {
+ deleteAndZero (dragOverlayComp);
+
+ columnIdBeingResized = getResizeDraggerAt (e.getMouseDownX());
+
+ if (columnIdBeingResized != 0)
+ {
+ const ColumnInfo* const ci = getInfoForId (columnIdBeingResized);
+ initialColumnWidth = ci->width;
+ }
+ else
+ {
+ beginDrag (e);
+ }
+ }
+
+ if (columnIdBeingResized != 0)
+ {
+ const ColumnInfo* const ci = getInfoForId (columnIdBeingResized);
+
+ if (ci != 0)
+ {
+ int w = jlimit (ci->minimumWidth, ci->maximumWidth,
+ initialColumnWidth + e.getDistanceFromDragStartX());
+
+ if (stretchToFit)
+ {
+ // prevent us dragging a column too far right if we're in stretch-to-fit mode
+ int minWidthOnRight = 0;
+ for (int i = getIndexOfColumnId (columnIdBeingResized, false) + 1; i < columns.size(); ++i)
+ if (columns.getUnchecked (i)->isVisible())
+ minWidthOnRight += columns.getUnchecked (i)->minimumWidth;
+
+ const Rectangle currentPos (getColumnPosition (getIndexOfColumnId (columnIdBeingResized, true)));
+ w = jmax (ci->minimumWidth, jmin (w, getWidth() - minWidthOnRight - currentPos.getX()));
+ }
+
+ setColumnWidth (columnIdBeingResized, w);
+ }
+ }
+ else if (columnIdBeingDragged != 0)
+ {
+ if (e.y >= -50 && e.y < getHeight() + 50)
+ {
+ beginDrag (e);
+
+ if (dragOverlayComp != 0)
+ {
+ dragOverlayComp->setVisible (true);
+ dragOverlayComp->setBounds (jlimit (0,
+ jmax (0, getTotalWidth() - dragOverlayComp->getWidth()),
+ e.x - draggingColumnOffset),
+ 0,
+ dragOverlayComp->getWidth(),
+ getHeight());
+
+ for (int i = columns.size(); --i >= 0;)
+ {
+ const int currentIndex = getIndexOfColumnId (columnIdBeingDragged, true);
+ int newIndex = currentIndex;
+
+ if (newIndex > 0)
+ {
+ // if the previous column isn't draggable, we can't move our column
+ // past it, because that'd change the undraggable column's position..
+ const ColumnInfo* const previous = columns.getUnchecked (newIndex - 1);
+
+ if ((previous->propertyFlags & draggable) != 0)
+ {
+ const int leftOfPrevious = getColumnPosition (newIndex - 1).getX();
+ const int rightOfCurrent = getColumnPosition (newIndex).getRight();
+
+ if (abs (dragOverlayComp->getX() - leftOfPrevious)
+ < abs (dragOverlayComp->getRight() - rightOfCurrent))
+ {
+ --newIndex;
+ }
+ }
+ }
+
+ if (newIndex < columns.size() - 1)
+ {
+ // if the next column isn't draggable, we can't move our column
+ // past it, because that'd change the undraggable column's position..
+ const ColumnInfo* const nextCol = columns.getUnchecked (newIndex + 1);
+
+ if ((nextCol->propertyFlags & draggable) != 0)
+ {
+ const int leftOfCurrent = getColumnPosition (newIndex).getX();
+ const int rightOfNext = getColumnPosition (newIndex + 1).getRight();
+
+ if (abs (dragOverlayComp->getX() - leftOfCurrent)
+ > abs (dragOverlayComp->getRight() - rightOfNext))
+ {
+ ++newIndex;
+ }
+ }
+ }
+
+ if (newIndex != currentIndex)
+ moveColumn (columnIdBeingDragged, newIndex);
+ else
+ break;
+ }
+ }
+ }
+ else
+ {
+ endDrag (draggingColumnOriginalIndex);
+ }
+ }
+}
+
+void TableHeaderComponent::beginDrag (const MouseEvent& e)
+{
+ if (columnIdBeingDragged == 0)
+ {
+ columnIdBeingDragged = getColumnIdAtX (e.getMouseDownX());
+
+ const ColumnInfo* const ci = getInfoForId (columnIdBeingDragged);
+
+ if (ci == 0 || (ci->propertyFlags & draggable) == 0)
+ {
+ columnIdBeingDragged = 0;
+ }
+ else
+ {
+ draggingColumnOriginalIndex = getIndexOfColumnId (columnIdBeingDragged, true);
+
+ const Rectangle columnRect (getColumnPosition (draggingColumnOriginalIndex));
+
+ const int temp = columnIdBeingDragged;
+ columnIdBeingDragged = 0;
+
+ addAndMakeVisible (dragOverlayComp = new DragOverlayComp (createComponentSnapshot (columnRect, false)));
+ columnIdBeingDragged = temp;
+
+ dragOverlayComp->setBounds (columnRect);
+
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ listeners.getUnchecked(i)->tableColumnDraggingChanged (this, columnIdBeingDragged);
+ i = jmin (i, listeners.size() - 1);
+ }
+ }
+ }
+}
+
+void TableHeaderComponent::endDrag (const int finalIndex)
+{
+ if (columnIdBeingDragged != 0)
+ {
+ moveColumn (columnIdBeingDragged, finalIndex);
+
+ columnIdBeingDragged = 0;
+ repaint();
+
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ listeners.getUnchecked(i)->tableColumnDraggingChanged (this, 0);
+ i = jmin (i, listeners.size() - 1);
+ }
+ }
+}
+
+void TableHeaderComponent::mouseUp (const MouseEvent& e)
+{
+ mouseDrag (e);
+
+ for (int i = columns.size(); --i >= 0;)
+ if (columns.getUnchecked (i)->isVisible())
+ columns.getUnchecked (i)->lastDeliberateWidth = columns.getUnchecked (i)->width;
+
+ columnIdBeingResized = 0;
+ repaint();
+
+ endDrag (getIndexOfColumnId (columnIdBeingDragged, true));
+
+ updateColumnUnderMouse (e.x, e.y);
+
+ if (columnIdUnderMouse != 0 && e.mouseWasClicked() && ! e.mods.isPopupMenu())
+ columnClicked (columnIdUnderMouse, e.mods);
+
+ deleteAndZero (dragOverlayComp);
+}
+
+const MouseCursor TableHeaderComponent::getMouseCursor()
+{
+ int x, y;
+ getMouseXYRelative (x, y);
+
+ if (columnIdBeingResized != 0 || (getResizeDraggerAt (x) != 0 && ! isMouseButtonDown()))
+ return MouseCursor (MouseCursor::LeftRightResizeCursor);
+
+ return Component::getMouseCursor();
+}
+
+bool TableHeaderComponent::ColumnInfo::isVisible() const throw()
+{
+ return (propertyFlags & TableHeaderComponent::visible) != 0;
+}
+
+TableHeaderComponent::ColumnInfo* TableHeaderComponent::getInfoForId (const int id) const throw()
+{
+ for (int i = columns.size(); --i >= 0;)
+ if (columns.getUnchecked(i)->id == id)
+ return columns.getUnchecked(i);
+
+ return 0;
+}
+
+int TableHeaderComponent::visibleIndexToTotalIndex (const int visibleIndex) const throw()
+{
+ int n = 0;
+
+ for (int i = 0; i < columns.size(); ++i)
+ {
+ if (columns.getUnchecked(i)->isVisible())
+ {
+ if (n == visibleIndex)
+ return i;
+
+ ++n;
+ }
+ }
+
+ return -1;
+}
+
+void TableHeaderComponent::sendColumnsChanged()
+{
+ if (stretchToFit && lastDeliberateWidth > 0)
+ resizeAllColumnsToFit (lastDeliberateWidth);
+
+ repaint();
+ columnsChanged = true;
+ triggerAsyncUpdate();
+}
+
+void TableHeaderComponent::handleAsyncUpdate()
+{
+ const bool changed = columnsChanged || sortChanged;
+ const bool sized = columnsResized || changed;
+ const bool sorted = sortChanged;
+ columnsChanged = false;
+ columnsResized = false;
+ sortChanged = false;
+
+ if (sorted)
+ {
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ listeners.getUnchecked(i)->tableSortOrderChanged (this);
+ i = jmin (i, listeners.size() - 1);
+ }
+ }
+
+ if (changed)
+ {
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ listeners.getUnchecked(i)->tableColumnsChanged (this);
+ i = jmin (i, listeners.size() - 1);
+ }
+ }
+
+ if (sized)
+ {
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ listeners.getUnchecked(i)->tableColumnsResized (this);
+ i = jmin (i, listeners.size() - 1);
+ }
+ }
+}
+
+int TableHeaderComponent::getResizeDraggerAt (const int mouseX) const throw()
+{
+ if (((unsigned int) mouseX) < (unsigned int) getWidth())
+ {
+ const int draggableDistance = 3;
+ int x = 0;
+
+ for (int i = 0; i < columns.size(); ++i)
+ {
+ const ColumnInfo* const ci = columns.getUnchecked(i);
+
+ if (ci->isVisible())
+ {
+ if (abs (mouseX - (x + ci->width)) <= draggableDistance
+ && (ci->propertyFlags & resizable) != 0)
+ return ci->id;
+
+ x += ci->width;
+ }
+ }
+ }
+
+ return 0;
+}
+
+void TableHeaderComponent::updateColumnUnderMouse (int x, int y)
+{
+ const int newCol = (reallyContains (x, y, true) && getResizeDraggerAt (x) == 0)
+ ? getColumnIdAtX (x) : 0;
+
+ if (newCol != columnIdUnderMouse)
+ {
+ columnIdUnderMouse = newCol;
+ repaint();
+ }
+}
+
+void TableHeaderComponent::showColumnChooserMenu (const int columnIdClicked)
+{
+ PopupMenu m;
+ addMenuItems (m, columnIdClicked);
+
+ if (m.getNumItems() > 0)
+ {
+ const int result = m.show();
+
+ if (result != 0)
+ reactToMenuItem (result, columnIdClicked);
+ }
+}
+
+void TableHeaderListener::tableColumnDraggingChanged (TableHeaderComponent*, int)
+{
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_TableHeaderComponent.cpp *********/
+
+/********* Start of inlined file: juce_TableListBox.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+static const tchar* const tableColumnPropertyTag = T("_tableColumnID");
+
+class TableListRowComp : public Component
+{
+public:
+ TableListRowComp (TableListBox& owner_)
+ : owner (owner_),
+ row (-1),
+ isSelected (false)
+ {
+ }
+
+ ~TableListRowComp()
+ {
+ deleteAllChildren();
+ }
+
+ void paint (Graphics& g)
+ {
+ TableListBoxModel* const model = owner.getModel();
+
+ if (model != 0)
+ {
+ const TableHeaderComponent* const header = owner.getHeader();
+
+ model->paintRowBackground (g, row, getWidth(), getHeight(), isSelected);
+
+ const int numColumns = header->getNumColumns (true);
+
+ for (int i = 0; i < numColumns; ++i)
+ {
+ if (! columnsWithComponents [i])
+ {
+ const int columnId = header->getColumnIdOfIndex (i, true);
+ Rectangle columnRect (header->getColumnPosition (i));
+ columnRect.setSize (columnRect.getWidth(), getHeight());
+
+ g.saveState();
+
+ g.reduceClipRegion (columnRect);
+ g.setOrigin (columnRect.getX(), 0);
+
+ model->paintCell (g, row, columnId, columnRect.getWidth(), columnRect.getHeight(), isSelected);
+
+ g.restoreState();
+ }
+ }
+ }
+ }
+
+ void update (const int newRow, const bool isNowSelected)
+ {
+ if (newRow != row || isNowSelected != isSelected)
+ {
+ row = newRow;
+ isSelected = isNowSelected;
+ repaint();
+ }
+
+ if (row < owner.getNumRows())
+ {
+ jassert (row >= 0);
+
+ const tchar* const tagPropertyName = T("_tableLastUseNum");
+ const int newTag = Random::getSystemRandom().nextInt();
+
+ const TableHeaderComponent* const header = owner.getHeader();
+ const int numColumns = header->getNumColumns (true);
+ int i;
+
+ columnsWithComponents.clear();
+
+ if (owner.getModel() != 0)
+ {
+ for (i = 0; i < numColumns; ++i)
+ {
+ const int columnId = header->getColumnIdOfIndex (i, true);
+
+ Component* const newComp
+ = owner.getModel()->refreshComponentForCell (row, columnId, isSelected,
+ findChildComponentForColumn (columnId));
+
+ if (newComp != 0)
+ {
+ addAndMakeVisible (newComp);
+ newComp->setComponentProperty (tagPropertyName, newTag);
+ newComp->setComponentProperty (tableColumnPropertyTag, columnId);
+
+ const Rectangle columnRect (header->getColumnPosition (i));
+ newComp->setBounds (columnRect.getX(), 0, columnRect.getWidth(), getHeight());
+
+ columnsWithComponents.setBit (i);
+ }
+ }
+ }
+
+ for (i = getNumChildComponents(); --i >= 0;)
+ {
+ Component* const c = getChildComponent (i);
+
+ if (c->getComponentPropertyInt (tagPropertyName, false, 0) != newTag)
+ delete c;
+ }
+ }
+ else
+ {
+ columnsWithComponents.clear();
+ deleteAllChildren();
+ }
+ }
+
+ void resized()
+ {
+ for (int i = getNumChildComponents(); --i >= 0;)
+ {
+ Component* const c = getChildComponent (i);
+
+ const int columnId = c->getComponentPropertyInt (tableColumnPropertyTag, false, 0);
+
+ if (columnId != 0)
+ {
+ const Rectangle columnRect (owner.getHeader()->getColumnPosition (owner.getHeader()->getIndexOfColumnId (columnId, true)));
+ c->setBounds (columnRect.getX(), 0, columnRect.getWidth(), getHeight());
+ }
+ }
+ }
+
+ void mouseDown (const MouseEvent& e)
+ {
+ isDragging = false;
+ selectRowOnMouseUp = false;
+
+ if (isEnabled())
+ {
+ if (! isSelected)
+ {
+ owner.selectRowsBasedOnModifierKeys (row, e.mods);
+
+ const int columnId = owner.getHeader()->getColumnIdAtX (e.x);
+
+ if (columnId != 0 && owner.getModel() != 0)
+ owner.getModel()->cellClicked (row, columnId, e);
+ }
+ else
+ {
+ selectRowOnMouseUp = true;
+ }
+ }
+ }
+
+ void mouseDrag (const MouseEvent& e)
+ {
+ if (isEnabled() && owner.getModel() != 0 && ! (e.mouseWasClicked() || isDragging))
+ {
+ const SparseSet selectedRows (owner.getSelectedRows());
+
+ if (selectedRows.size() > 0)
+ {
+ const String dragDescription (owner.getModel()->getDragSourceDescription (selectedRows));
+
+ if (dragDescription.isNotEmpty())
+ {
+ isDragging = true;
+
+ DragAndDropContainer* const dragContainer
+ = DragAndDropContainer::findParentDragContainerFor (this);
+
+ if (dragContainer != 0)
+ {
+ Image* dragImage = owner.createSnapshotOfSelectedRows();
+ dragImage->multiplyAllAlphas (0.6f);
+
+ dragContainer->startDragging (dragDescription, &owner, dragImage, true);
+ }
+ else
+ {
+ // to be able to do a drag-and-drop operation, the listbox needs to
+ // be inside a component which is also a DragAndDropContainer.
+ jassertfalse
+ }
+ }
+ }
+ }
+ }
+
+ void mouseUp (const MouseEvent& e)
+ {
+ if (selectRowOnMouseUp && e.mouseWasClicked() && isEnabled())
+ {
+ owner.selectRowsBasedOnModifierKeys (row, e.mods);
+
+ const int columnId = owner.getHeader()->getColumnIdAtX (e.x);
+
+ if (columnId != 0 && owner.getModel() != 0)
+ owner.getModel()->cellClicked (row, columnId, e);
+ }
+ }
+
+ void mouseDoubleClick (const MouseEvent& e)
+ {
+ const int columnId = owner.getHeader()->getColumnIdAtX (e.x);
+
+ if (columnId != 0 && owner.getModel() != 0)
+ owner.getModel()->cellDoubleClicked (row, columnId, e);
+ }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ TableListBox& owner;
+ int row;
+ bool isSelected, isDragging, selectRowOnMouseUp;
+ BitArray columnsWithComponents;
+
+ Component* findChildComponentForColumn (const int columnId) const
+ {
+ for (int i = getNumChildComponents(); --i >= 0;)
+ {
+ Component* const c = getChildComponent (i);
+
+ if (c->getComponentPropertyInt (tableColumnPropertyTag, false, 0) == columnId)
+ return c;
+ }
+
+ return 0;
+ }
+
+ TableListRowComp (const TableListRowComp&);
+ const TableListRowComp& operator= (const TableListRowComp&);
+};
+
+class TableListBoxHeader : public TableHeaderComponent
+{
+public:
+ TableListBoxHeader (TableListBox& owner_)
+ : owner (owner_)
+ {
+ }
+
+ ~TableListBoxHeader()
+ {
+ }
+
+ void addMenuItems (PopupMenu& menu, const int columnIdClicked)
+ {
+ if (owner.isAutoSizeMenuOptionShown())
+ {
+ menu.addItem (0xf836743, TRANS("Auto-size this column"), columnIdClicked != 0);
+ menu.addItem (0xf836744, TRANS("Auto-size all columns"), owner.getHeader()->getNumColumns (true) > 0);
+ menu.addSeparator();
+ }
+
+ TableHeaderComponent::addMenuItems (menu, columnIdClicked);
+ }
+
+ void reactToMenuItem (const int menuReturnId, const int columnIdClicked)
+ {
+ if (menuReturnId == 0xf836743)
+ {
+ owner.autoSizeColumn (columnIdClicked);
+ }
+ else if (menuReturnId == 0xf836744)
+ {
+ owner.autoSizeAllColumns();
+ }
+ else
+ {
+ TableHeaderComponent::reactToMenuItem (menuReturnId, columnIdClicked);
+ }
+ }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ TableListBox& owner;
+
+ TableListBoxHeader (const TableListBoxHeader&);
+ const TableListBoxHeader& operator= (const TableListBoxHeader&);
+};
+
+TableListBox::TableListBox (const String& name, TableListBoxModel* const model_)
+ : ListBox (name, 0),
+ model (model_),
+ autoSizeOptionsShown (true)
+{
+ ListBox::model = this;
+
+ header = new TableListBoxHeader (*this);
+ header->setSize (100, 28);
+ header->addListener (this);
+
+ setHeaderComponent (header);
+}
+
+TableListBox::~TableListBox()
+{
+ deleteAllChildren();
+}
+
+void TableListBox::setModel (TableListBoxModel* const newModel)
+{
+ if (model != newModel)
+ {
+ model = newModel;
+ updateContent();
+ }
+}
+
+int TableListBox::getHeaderHeight() const throw()
+{
+ return header->getHeight();
+}
+
+void TableListBox::setHeaderHeight (const int newHeight)
+{
+ header->setSize (header->getWidth(), newHeight);
+ resized();
+}
+
+void TableListBox::autoSizeColumn (const int columnId)
+{
+ const int width = model != 0 ? model->getColumnAutoSizeWidth (columnId) : 0;
+
+ if (width > 0)
+ header->setColumnWidth (columnId, width);
+}
+
+void TableListBox::autoSizeAllColumns()
+{
+ for (int i = 0; i < header->getNumColumns (true); ++i)
+ autoSizeColumn (header->getColumnIdOfIndex (i, true));
+}
+
+void TableListBox::setAutoSizeMenuOptionShown (const bool shouldBeShown)
+{
+ autoSizeOptionsShown = shouldBeShown;
+}
+
+bool TableListBox::isAutoSizeMenuOptionShown() const throw()
+{
+ return autoSizeOptionsShown;
+}
+
+const Rectangle TableListBox::getCellPosition (const int columnId,
+ const int rowNumber,
+ const bool relativeToComponentTopLeft) const
+{
+ Rectangle headerCell (header->getColumnPosition (header->getIndexOfColumnId (columnId, true)));
+
+ if (relativeToComponentTopLeft)
+ headerCell.translate (header->getX(), 0);
+
+ const Rectangle row (getRowPosition (rowNumber, relativeToComponentTopLeft));
+
+ return Rectangle (headerCell.getX(), row.getY(),
+ headerCell.getWidth(), row.getHeight());
+}
+
+void TableListBox::scrollToEnsureColumnIsOnscreen (const int columnId)
+{
+ ScrollBar* const scrollbar = getHorizontalScrollBar();
+
+ if (scrollbar != 0)
+ {
+ const Rectangle pos (header->getColumnPosition (header->getIndexOfColumnId (columnId, true)));
+
+ double x = scrollbar->getCurrentRangeStart();
+ const double w = scrollbar->getCurrentRangeSize();
+
+ if (pos.getX() < x)
+ x = pos.getX();
+ else if (pos.getRight() > x + w)
+ x += jmax (0.0, pos.getRight() - (x + w));
+
+ scrollbar->setCurrentRangeStart (x);
+ }
+}
+
+int TableListBox::getNumRows()
+{
+ return model != 0 ? model->getNumRows() : 0;
+}
+
+void TableListBox::paintListBoxItem (int, Graphics&, int, int, bool)
+{
+}
+
+Component* TableListBox::refreshComponentForRow (int rowNumber, bool isRowSelected, Component* existingComponentToUpdate)
+{
+ if (existingComponentToUpdate == 0)
+ existingComponentToUpdate = new TableListRowComp (*this);
+
+ ((TableListRowComp*) existingComponentToUpdate)->update (rowNumber, isRowSelected);
+
+ return existingComponentToUpdate;
+}
+
+void TableListBox::selectedRowsChanged (int row)
+{
+ if (model != 0)
+ model->selectedRowsChanged (row);
+}
+
+void TableListBox::deleteKeyPressed (int row)
+{
+ if (model != 0)
+ model->deleteKeyPressed (row);
+}
+
+void TableListBox::returnKeyPressed (int row)
+{
+ if (model != 0)
+ model->returnKeyPressed (row);
+}
+
+void TableListBox::backgroundClicked()
+{
+ if (model != 0)
+ model->backgroundClicked();
+}
+
+void TableListBox::listWasScrolled()
+{
+ if (model != 0)
+ model->listWasScrolled();
+}
+
+void TableListBox::tableColumnsChanged (TableHeaderComponent*)
+{
+ setMinimumContentWidth (header->getTotalWidth());
+ repaint();
+ updateColumnComponents();
+}
+
+void TableListBox::tableColumnsResized (TableHeaderComponent*)
+{
+ setMinimumContentWidth (header->getTotalWidth());
+ repaint();
+ updateColumnComponents();
+}
+
+void TableListBox::tableSortOrderChanged (TableHeaderComponent*)
+{
+ if (model != 0)
+ model->sortOrderChanged (header->getSortColumnId(),
+ header->isSortedForwards());
+}
+
+void TableListBox::tableColumnDraggingChanged (TableHeaderComponent*, int columnIdNowBeingDragged_)
+{
+ columnIdNowBeingDragged = columnIdNowBeingDragged_;
+ repaint();
+}
+
+void TableListBox::resized()
+{
+ ListBox::resized();
+
+ header->resizeAllColumnsToFit (getVisibleContentWidth());
+ setMinimumContentWidth (header->getTotalWidth());
+}
+
+void TableListBox::updateColumnComponents() const
+{
+ const int firstRow = getRowContainingPosition (0, 0);
+
+ for (int i = firstRow + getNumRowsOnScreen() + 2; --i >= firstRow;)
+ {
+ TableListRowComp* const rowComp = dynamic_cast (getComponentForRowNumber (i));
+
+ if (rowComp != 0)
+ rowComp->resized();
+ }
+}
+
+void TableListBoxModel::cellClicked (int, int, const MouseEvent&)
+{
+}
+
+void TableListBoxModel::cellDoubleClicked (int, int, const MouseEvent&)
+{
+}
+
+void TableListBoxModel::backgroundClicked()
+{
+}
+
+void TableListBoxModel::sortOrderChanged (int, const bool)
+{
+}
+
+int TableListBoxModel::getColumnAutoSizeWidth (int)
+{
+ return 0;
+}
+
+void TableListBoxModel::selectedRowsChanged (int)
+{
+}
+
+void TableListBoxModel::deleteKeyPressed (int)
+{
+}
+
+void TableListBoxModel::returnKeyPressed (int)
+{
+}
+
+void TableListBoxModel::listWasScrolled()
+{
+}
+
+const String TableListBoxModel::getDragSourceDescription (const SparseSet&)
+{
+ return String::empty;
+}
+
+Component* TableListBoxModel::refreshComponentForCell (int, int, bool, Component* existingComponentToUpdate)
+{
+ (void) existingComponentToUpdate;
+ jassert (existingComponentToUpdate == 0); // indicates a failure in the code the recycles the components
+ return 0;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_TableListBox.cpp *********/
+
+/********* Start of inlined file: juce_TextEditor.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+#define SHOULD_WRAP(x, wrapwidth) (((x) - 0.0001f) >= (wrapwidth))
+
+// a word or space that can't be broken down any further
+struct TextAtom
+{
+
+ String atomText;
+ float width;
+ uint16 numChars;
+
+ bool isWhitespace() const throw() { return CharacterFunctions::isWhitespace (atomText[0]); }
+ bool isNewLine() const throw() { return atomText[0] == T('\r') || atomText[0] == T('\n'); }
+
+ const String getText (const tchar passwordCharacter) const throw()
+ {
+ if (passwordCharacter == 0)
+ return atomText;
+ else
+ return String::repeatedString (String::charToString (passwordCharacter),
+ atomText.length());
+ }
+
+ const String getTrimmedText (const tchar passwordCharacter) const throw()
+ {
+ if (passwordCharacter == 0)
+ return atomText.substring (0, numChars);
+ else if (isNewLine())
+ return String::empty;
+ else
+ return String::repeatedString (String::charToString (passwordCharacter), numChars);
+ }
+};
+
+// a run of text with a single font and colour
+class UniformTextSection
+{
+public:
+
+ UniformTextSection (const String& text,
+ const Font& font_,
+ const Colour& colour_,
+ const tchar passwordCharacter) throw()
+ : font (font_),
+ colour (colour_),
+ atoms (64)
+ {
+ initialiseAtoms (text, passwordCharacter);
+ }
+
+ UniformTextSection (const UniformTextSection& other) throw()
+ : font (other.font),
+ colour (other.colour),
+ atoms (64)
+ {
+ for (int i = 0; i < other.atoms.size(); ++i)
+ atoms.add (new TextAtom (*(const TextAtom*) other.atoms.getUnchecked(i)));
+ }
+
+ ~UniformTextSection() throw()
+ {
+ // (no need to delete the atoms, as they're explicitly deleted by the caller)
+ }
+
+ void clear() throw()
+ {
+ for (int i = atoms.size(); --i >= 0;)
+ {
+ TextAtom* const atom = getAtom(i);
+ delete atom;
+ }
+
+ atoms.clear();
+ }
+
+ int getNumAtoms() const throw()
+ {
+ return atoms.size();
+ }
+
+ TextAtom* getAtom (const int index) const throw()
+ {
+ return (TextAtom*) atoms.getUnchecked (index);
+ }
+
+ void append (const UniformTextSection& other, const tchar passwordCharacter) throw()
+ {
+ if (other.atoms.size() > 0)
+ {
+ TextAtom* const lastAtom = (TextAtom*) atoms.getLast();
+ int i = 0;
+
+ if (lastAtom != 0)
+ {
+ if (! CharacterFunctions::isWhitespace (lastAtom->atomText.getLastCharacter()))
+ {
+ TextAtom* const first = other.getAtom(0);
+
+ if (! CharacterFunctions::isWhitespace (first->atomText[0]))
+ {
+ lastAtom->atomText += first->atomText;
+ lastAtom->numChars = (uint16) (lastAtom->numChars + first->numChars);
+ lastAtom->width = font.getStringWidthFloat (lastAtom->getText (passwordCharacter));
+ delete first;
+ ++i;
+ }
+ }
+ }
+
+ while (i < other.atoms.size())
+ {
+ atoms.add (other.getAtom(i));
+ ++i;
+ }
+ }
+ }
+
+ UniformTextSection* split (const int indexToBreakAt,
+ const tchar passwordCharacter) throw()
+ {
+ UniformTextSection* const section2 = new UniformTextSection (String::empty,
+ font, colour,
+ passwordCharacter);
+ int index = 0;
+
+ for (int i = 0; i < atoms.size(); ++i)
+ {
+ TextAtom* const atom = getAtom(i);
+
+ const int nextIndex = index + atom->numChars;
+
+ if (index == indexToBreakAt)
+ {
+ int j;
+ for (j = i; j < atoms.size(); ++j)
+ section2->atoms.add (getAtom (j));
+
+ for (j = atoms.size(); --j >= i;)
+ atoms.remove (j);
+
+ break;
+ }
+ else if (indexToBreakAt >= index && indexToBreakAt < nextIndex)
+ {
+ TextAtom* const secondAtom = new TextAtom();
+
+ secondAtom->atomText = atom->atomText.substring (indexToBreakAt - index);
+ secondAtom->width = font.getStringWidthFloat (secondAtom->getText (passwordCharacter));
+ secondAtom->numChars = (uint16) secondAtom->atomText.length();
+
+ section2->atoms.add (secondAtom);
+
+ atom->atomText = atom->atomText.substring (0, indexToBreakAt - index);
+ atom->width = font.getStringWidthFloat (atom->getText (passwordCharacter));
+ atom->numChars = (uint16) (indexToBreakAt - index);
+
+ int j;
+ for (j = i + 1; j < atoms.size(); ++j)
+ section2->atoms.add (getAtom (j));
+
+ for (j = atoms.size(); --j > i;)
+ atoms.remove (j);
+
+ break;
+ }
+
+ index = nextIndex;
+ }
+
+ return section2;
+ }
+
+ const String getAllText() const throw()
+ {
+ String s;
+ s.preallocateStorage (getTotalLength());
+
+ tchar* endOfString = (tchar*) &(s[0]);
+
+ for (int i = 0; i < atoms.size(); ++i)
+ {
+ const TextAtom* const atom = getAtom(i);
+
+ memcpy (endOfString, &(atom->atomText[0]), atom->numChars * sizeof (tchar));
+ endOfString += atom->numChars;
+ }
+
+ *endOfString = 0;
+
+ jassert ((endOfString - (tchar*) &(s[0])) <= getTotalLength());
+ return s;
+ }
+
+ const String getTextSubstring (const int startCharacter,
+ const int endCharacter) const throw()
+ {
+ int index = 0;
+ int totalLen = 0;
+ int i;
+
+ for (i = 0; i < atoms.size(); ++i)
+ {
+ const TextAtom* const atom = getAtom (i);
+ const int nextIndex = index + atom->numChars;
+
+ if (startCharacter < nextIndex)
+ {
+ if (endCharacter <= index)
+ break;
+
+ const int start = jmax (0, startCharacter - index);
+ const int end = jmin (endCharacter - index, atom->numChars);
+ jassert (end >= start);
+
+ totalLen += end - start;
+ }
+
+ index = nextIndex;
+ }
+
+ String s;
+ s.preallocateStorage (totalLen + 1);
+ tchar* psz = (tchar*) (const tchar*) s;
+
+ index = 0;
+
+ for (i = 0; i < atoms.size(); ++i)
+ {
+ const TextAtom* const atom = getAtom (i);
+ const int nextIndex = index + atom->numChars;
+
+ if (startCharacter < nextIndex)
+ {
+ if (endCharacter <= index)
+ break;
+
+ const int start = jmax (0, startCharacter - index);
+ const int len = jmin (endCharacter - index, atom->numChars) - start;
+
+ memcpy (psz, ((const tchar*) atom->atomText) + start, len * sizeof (tchar));
+ psz += len;
+ *psz = 0;
+ }
+
+ index = nextIndex;
+ }
+
+ return s;
+ }
+
+ int getTotalLength() const throw()
+ {
+ int c = 0;
+
+ for (int i = atoms.size(); --i >= 0;)
+ c += getAtom(i)->numChars;
+
+ return c;
+ }
+
+ void setFont (const Font& newFont,
+ const tchar passwordCharacter) throw()
+ {
+ if (font != newFont)
+ {
+ font = newFont;
+
+ for (int i = atoms.size(); --i >= 0;)
+ {
+ TextAtom* const atom = (TextAtom*) atoms.getUnchecked(i);
+ atom->width = newFont.getStringWidthFloat (atom->getText (passwordCharacter));
+ }
+ }
+ }
+
+ juce_UseDebuggingNewOperator
+
+ Font font;
+ Colour colour;
+
+private:
+ VoidArray atoms;
+
+ void initialiseAtoms (const String& textToParse,
+ const tchar passwordCharacter) throw()
+ {
+ int i = 0;
+ const int len = textToParse.length();
+ const tchar* const text = (const tchar*) textToParse;
+
+ while (i < len)
+ {
+ int start = i;
+
+ // create a whitespace atom unless it starts with non-ws
+ if (CharacterFunctions::isWhitespace (text[i])
+ && text[i] != T('\r')
+ && text[i] != T('\n'))
+ {
+ while (i < len
+ && CharacterFunctions::isWhitespace (text[i])
+ && text[i] != T('\r')
+ && text[i] != T('\n'))
+ {
+ ++i;
+ }
+ }
+ else
+ {
+ if (text[i] == T('\r'))
+ {
+ ++i;
+
+ if ((i < len) && (text[i] == T('\n')))
+ {
+ ++start;
+ ++i;
+ }
+ }
+ else if (text[i] == T('\n'))
+ {
+ ++i;
+ }
+ else
+ {
+ while ((i < len) && ! CharacterFunctions::isWhitespace (text[i]))
+ ++i;
+ }
+ }
+
+ TextAtom* const atom = new TextAtom();
+ atom->atomText = String (text + start, i - start);
+
+ atom->width = font.getStringWidthFloat (atom->getText (passwordCharacter));
+ atom->numChars = (uint16) (i - start);
+
+ atoms.add (atom);
+ }
+ }
+
+ const UniformTextSection& operator= (const UniformTextSection& other);
+};
+
+class TextEditorIterator
+{
+public:
+
+ TextEditorIterator (const VoidArray& sections_,
+ const float wordWrapWidth_,
+ const tchar passwordCharacter_) throw()
+ : indexInText (0),
+ lineY (0),
+ lineHeight (0),
+ maxDescent (0),
+ atomX (0),
+ atomRight (0),
+ atom (0),
+ currentSection (0),
+ sections (sections_),
+ sectionIndex (0),
+ atomIndex (0),
+ wordWrapWidth (wordWrapWidth_),
+ passwordCharacter (passwordCharacter_)
+ {
+ jassert (wordWrapWidth_ > 0);
+
+ if (sections.size() > 0)
+ currentSection = (const UniformTextSection*) sections.getUnchecked (sectionIndex);
+
+ if (currentSection != 0)
+ {
+ lineHeight = currentSection->font.getHeight();
+ maxDescent = currentSection->font.getDescent();
+ }
+ }
+
+ TextEditorIterator (const TextEditorIterator& other) throw()
+ : indexInText (other.indexInText),
+ lineY (other.lineY),
+ lineHeight (other.lineHeight),
+ maxDescent (other.maxDescent),
+ atomX (other.atomX),
+ atomRight (other.atomRight),
+ atom (other.atom),
+ currentSection (other.currentSection),
+ sections (other.sections),
+ sectionIndex (other.sectionIndex),
+ atomIndex (other.atomIndex),
+ wordWrapWidth (other.wordWrapWidth),
+ passwordCharacter (other.passwordCharacter),
+ tempAtom (other.tempAtom)
+ {
+ }
+
+ ~TextEditorIterator() throw()
+ {
+ }
+
+ bool next() throw()
+ {
+ if (atom == &tempAtom)
+ {
+ const int numRemaining = tempAtom.atomText.length() - tempAtom.numChars;
+
+ if (numRemaining > 0)
+ {
+ tempAtom.atomText = tempAtom.atomText.substring (tempAtom.numChars);
+
+ atomX = 0;
+
+ if (tempAtom.numChars > 0)
+ lineY += lineHeight;
+
+ indexInText += tempAtom.numChars;
+
+ GlyphArrangement g;
+ g.addLineOfText (currentSection->font, atom->getText (passwordCharacter), 0.0f, 0.0f);
+
+ int split;
+ for (split = 0; split < g.getNumGlyphs(); ++split)
+ if (SHOULD_WRAP (g.getGlyph (split).getRight(), wordWrapWidth))
+ break;
+
+ if (split > 0 && split <= numRemaining)
+ {
+ tempAtom.numChars = (uint16) split;
+ tempAtom.width = g.getGlyph (split - 1).getRight();
+ atomRight = atomX + tempAtom.width;
+ return true;
+ }
+ }
+ }
+
+ bool forceNewLine = false;
+
+ if (sectionIndex >= sections.size())
+ {
+ moveToEndOfLastAtom();
+ return false;
+ }
+ else if (atomIndex >= currentSection->getNumAtoms() - 1)
+ {
+ if (atomIndex >= currentSection->getNumAtoms())
+ {
+ if (++sectionIndex >= sections.size())
+ {
+ moveToEndOfLastAtom();
+ return false;
+ }
+
+ atomIndex = 0;
+ currentSection = (const UniformTextSection*) sections.getUnchecked (sectionIndex);
+
+ lineHeight = jmax (lineHeight, currentSection->font.getHeight());
+ maxDescent = jmax (maxDescent, currentSection->font.getDescent());
+ }
+ else
+ {
+ const TextAtom* const lastAtom = currentSection->getAtom (atomIndex);
+
+ if (! lastAtom->isWhitespace())
+ {
+ // handle the case where the last atom in a section is actually part of the same
+ // word as the first atom of the next section...
+ float right = atomRight + lastAtom->width;
+ float lineHeight2 = lineHeight;
+ float maxDescent2 = maxDescent;
+
+ for (int section = sectionIndex + 1; section < sections.size(); ++section)
+ {
+ const UniformTextSection* const s = (const UniformTextSection*) sections.getUnchecked (section);
+
+ if (s->getNumAtoms() == 0)
+ break;
+
+ const TextAtom* const nextAtom = s->getAtom (0);
+
+ if (nextAtom->isWhitespace())
+ break;
+
+ right += nextAtom->width;
+
+ lineHeight2 = jmax (lineHeight2, s->font.getHeight());
+ maxDescent2 = jmax (maxDescent2, s->font.getDescent());
+
+ if (SHOULD_WRAP (right, wordWrapWidth))
+ {
+ lineHeight = lineHeight2;
+ maxDescent = maxDescent2;
+
+ forceNewLine = true;
+ break;
+ }
+
+ if (s->getNumAtoms() > 1)
+ break;
+ }
+ }
+ }
+ }
+
+ if (atom != 0)
+ {
+ atomX = atomRight;
+ indexInText += atom->numChars;
+
+ if (atom->isNewLine())
+ {
+ atomX = 0;
+ lineY += lineHeight;
+ }
+ }
+
+ atom = currentSection->getAtom (atomIndex);
+ atomRight = atomX + atom->width;
+ ++atomIndex;
+
+ if (SHOULD_WRAP (atomRight, wordWrapWidth) || forceNewLine)
+ {
+ if (atom->isWhitespace())
+ {
+ // leave whitespace at the end of a line, but truncate it to avoid scrolling
+ atomRight = jmin (atomRight, wordWrapWidth);
+ }
+ else
+ {
+ return wrapCurrentAtom();
+ }
+ }
+
+ return true;
+ }
+
+ bool wrapCurrentAtom() throw()
+ {
+ atomRight = atom->width;
+
+ if (SHOULD_WRAP (atomRight, wordWrapWidth)) // atom too big to fit on a line, so break it up..
+ {
+ tempAtom = *atom;
+ tempAtom.width = 0;
+ tempAtom.numChars = 0;
+ atom = &tempAtom;
+
+ if (atomX > 0)
+ {
+ atomX = 0;
+ lineY += lineHeight;
+ }
+
+ return next();
+ }
+
+ atomX = 0;
+ lineY += lineHeight;
+ return true;
+ }
+
+ void draw (Graphics& g, const UniformTextSection*& lastSection) const throw()
+ {
+ if (passwordCharacter != 0 || ! atom->isWhitespace())
+ {
+ if (lastSection != currentSection)
+ {
+ lastSection = currentSection;
+ g.setColour (currentSection->colour);
+ g.setFont (currentSection->font);
+ }
+
+ jassert (atom->getTrimmedText (passwordCharacter).isNotEmpty());
+
+ GlyphArrangement ga;
+ ga.addLineOfText (currentSection->font,
+ atom->getTrimmedText (passwordCharacter),
+ atomX,
+ (float) roundFloatToInt (lineY + lineHeight - maxDescent));
+ ga.draw (g);
+ }
+ }
+
+ void drawSelection (Graphics& g,
+ const int selectionStart,
+ const int selectionEnd) const throw()
+ {
+ const int startX = roundFloatToInt (indexToX (selectionStart));
+ const int endX = roundFloatToInt (indexToX (selectionEnd));
+
+ const int y = roundFloatToInt (lineY);
+ const int nextY = roundFloatToInt (lineY + lineHeight);
+
+ g.fillRect (startX, y, endX - startX, nextY - y);
+ }
+
+ void drawSelectedText (Graphics& g,
+ const int selectionStart,
+ const int selectionEnd,
+ const Colour& selectedTextColour) const throw()
+ {
+ if (passwordCharacter != 0 || ! atom->isWhitespace())
+ {
+ GlyphArrangement ga;
+ ga.addLineOfText (currentSection->font,
+ atom->getTrimmedText (passwordCharacter),
+ atomX,
+ (float) roundFloatToInt (lineY + lineHeight - maxDescent));
+
+ if (selectionEnd < indexInText + atom->numChars)
+ {
+ GlyphArrangement ga2 (ga);
+ ga2.removeRangeOfGlyphs (0, selectionEnd - indexInText);
+ ga.removeRangeOfGlyphs (selectionEnd - indexInText, -1);
+
+ g.setColour (currentSection->colour);
+ ga2.draw (g);
+ }
+
+ if (selectionStart > indexInText)
+ {
+ GlyphArrangement ga2 (ga);
+ ga2.removeRangeOfGlyphs (selectionStart - indexInText, -1);
+ ga.removeRangeOfGlyphs (0, selectionStart - indexInText);
+
+ g.setColour (currentSection->colour);
+ ga2.draw (g);
+ }
+
+ g.setColour (selectedTextColour);
+ ga.draw (g);
+ }
+ }
+
+ float indexToX (const int indexToFind) const throw()
+ {
+ if (indexToFind <= indexInText)
+ return atomX;
+
+ if (indexToFind >= indexInText + atom->numChars)
+ return atomRight;
+
+ GlyphArrangement g;
+ g.addLineOfText (currentSection->font,
+ atom->getText (passwordCharacter),
+ atomX, 0.0f);
+
+ return jmin (atomRight, g.getGlyph (indexToFind - indexInText).getLeft());
+ }
+
+ int xToIndex (const float xToFind) const throw()
+ {
+ if (xToFind <= atomX || atom->isNewLine())
+ return indexInText;
+
+ if (xToFind >= atomRight)
+ return indexInText + atom->numChars;
+
+ GlyphArrangement g;
+ g.addLineOfText (currentSection->font,
+ atom->getText (passwordCharacter),
+ atomX, 0.0f);
+
+ int j;
+ for (j = 0; j < atom->numChars; ++j)
+ if ((g.getGlyph(j).getLeft() + g.getGlyph(j).getRight()) / 2 > xToFind)
+ break;
+
+ return indexInText + j;
+ }
+
+ void updateLineHeight() throw()
+ {
+ float x = atomRight;
+
+ int tempSectionIndex = sectionIndex;
+ int tempAtomIndex = atomIndex;
+ const UniformTextSection* currentSection = (const UniformTextSection*) sections.getUnchecked (tempSectionIndex);
+
+ while (! SHOULD_WRAP (x, wordWrapWidth))
+ {
+ if (tempSectionIndex >= sections.size())
+ break;
+
+ bool checkSize = false;
+
+ if (tempAtomIndex >= currentSection->getNumAtoms())
+ {
+ if (++tempSectionIndex >= sections.size())
+ break;
+
+ tempAtomIndex = 0;
+ currentSection = (const UniformTextSection*) sections.getUnchecked (tempSectionIndex);
+ checkSize = true;
+ }
+
+ const TextAtom* const atom = currentSection->getAtom (tempAtomIndex);
+
+ if (atom == 0)
+ break;
+
+ x += atom->width;
+
+ if (SHOULD_WRAP (x, wordWrapWidth) || atom->isNewLine())
+ break;
+
+ if (checkSize)
+ {
+ lineHeight = jmax (lineHeight, currentSection->font.getHeight());
+ maxDescent = jmax (maxDescent, currentSection->font.getDescent());
+ }
+
+ ++tempAtomIndex;
+ }
+ }
+
+ bool getCharPosition (const int index, float& cx, float& cy, float& lineHeight_) throw()
+ {
+ while (next())
+ {
+ if (indexInText + atom->numChars >= index)
+ {
+ updateLineHeight();
+
+ if (indexInText + atom->numChars > index)
+ {
+ cx = indexToX (index);
+ cy = lineY;
+ lineHeight_ = lineHeight;
+ return true;
+ }
+ }
+ }
+
+ cx = atomX;
+ cy = lineY;
+ lineHeight_ = lineHeight;
+ return false;
+ }
+
+ juce_UseDebuggingNewOperator
+
+ int indexInText;
+ float lineY, lineHeight, maxDescent;
+ float atomX, atomRight;
+ const TextAtom* atom;
+ const UniformTextSection* currentSection;
+
+private:
+ const VoidArray& sections;
+ int sectionIndex, atomIndex;
+ const float wordWrapWidth;
+ const tchar passwordCharacter;
+ TextAtom tempAtom;
+
+ const TextEditorIterator& operator= (const TextEditorIterator&);
+
+ void moveToEndOfLastAtom() throw()
+ {
+ if (atom != 0)
+ {
+ atomX = atomRight;
+
+ if (atom->isNewLine())
+ {
+ atomX = 0.0f;
+ lineY += lineHeight;
+ }
+ }
+ }
+};
+
+class TextEditorInsertAction : public UndoableAction
+{
+ TextEditor& owner;
+ const String text;
+ const int insertIndex, oldCaretPos, newCaretPos;
+ const Font font;
+ const Colour colour;
+
+ TextEditorInsertAction (const TextEditorInsertAction&);
+ const TextEditorInsertAction& operator= (const TextEditorInsertAction&);
+
+public:
+ TextEditorInsertAction (TextEditor& owner_,
+ const String& text_,
+ const int insertIndex_,
+ const Font& font_,
+ const Colour& colour_,
+ const int oldCaretPos_,
+ const int newCaretPos_) throw()
+ : owner (owner_),
+ text (text_),
+ insertIndex (insertIndex_),
+ oldCaretPos (oldCaretPos_),
+ newCaretPos (newCaretPos_),
+ font (font_),
+ colour (colour_)
+ {
+ }
+
+ ~TextEditorInsertAction()
+ {
+ }
+
+ bool perform()
+ {
+ owner.insert (text, insertIndex, font, colour, 0, newCaretPos);
+ return true;
+ }
+
+ bool undo()
+ {
+ owner.remove (insertIndex, insertIndex + text.length(), 0, oldCaretPos);
+ return true;
+ }
+
+ int getSizeInUnits()
+ {
+ return text.length() + 16;
+ }
+};
+
+class TextEditorRemoveAction : public UndoableAction
+{
+ TextEditor& owner;
+ const int startIndex, endIndex, oldCaretPos, newCaretPos;
+ VoidArray removedSections;
+
+ TextEditorRemoveAction (const TextEditorRemoveAction&);
+ const TextEditorRemoveAction& operator= (const TextEditorRemoveAction&);
+
+public:
+ TextEditorRemoveAction (TextEditor& owner_,
+ const int startIndex_,
+ const int endIndex_,
+ const int oldCaretPos_,
+ const int newCaretPos_,
+ const VoidArray& removedSections_) throw()
+ : owner (owner_),
+ startIndex (startIndex_),
+ endIndex (endIndex_),
+ oldCaretPos (oldCaretPos_),
+ newCaretPos (newCaretPos_),
+ removedSections (removedSections_)
+ {
+ }
+
+ ~TextEditorRemoveAction()
+ {
+ for (int i = removedSections.size(); --i >= 0;)
+ {
+ UniformTextSection* const section = (UniformTextSection*) removedSections.getUnchecked (i);
+ section->clear();
+ delete section;
+ }
+ }
+
+ bool perform()
+ {
+ owner.remove (startIndex, endIndex, 0, newCaretPos);
+ return true;
+ }
+
+ bool undo()
+ {
+ owner.reinsert (startIndex, removedSections);
+ owner.moveCursorTo (oldCaretPos, false);
+ return true;
+ }
+
+ int getSizeInUnits()
+ {
+ int n = 0;
+
+ for (int i = removedSections.size(); --i >= 0;)
+ {
+ UniformTextSection* const section = (UniformTextSection*) removedSections.getUnchecked (i);
+ n += section->getTotalLength();
+ }
+
+ return n + 16;
+ }
+};
+
+class TextHolderComponent : public Component,
+ public Timer
+{
+ TextEditor* const owner;
+
+ TextHolderComponent (const TextHolderComponent&);
+ const TextHolderComponent& operator= (const TextHolderComponent&);
+
+public:
+ TextHolderComponent (TextEditor* const owner_)
+ : owner (owner_)
+ {
+ setWantsKeyboardFocus (false);
+ setInterceptsMouseClicks (false, true);
+ }
+
+ ~TextHolderComponent()
+ {
+ }
+
+ void paint (Graphics& g)
+ {
+ owner->drawContent (g);
+ }
+
+ void timerCallback()
+ {
+ owner->timerCallbackInt();
+ }
+
+ const MouseCursor getMouseCursor()
+ {
+ return owner->getMouseCursor();
+ }
+};
+
+class TextEditorViewport : public Viewport
+{
+ TextEditor* const owner;
+ float lastWordWrapWidth;
+
+ TextEditorViewport (const TextEditorViewport&);
+ const TextEditorViewport& operator= (const TextEditorViewport&);
+
+public:
+ TextEditorViewport (TextEditor* const owner_)
+ : owner (owner_),
+ lastWordWrapWidth (0)
+ {
+ }
+
+ ~TextEditorViewport()
+ {
+ }
+
+ void visibleAreaChanged (int, int, int, int)
+ {
+ const float wordWrapWidth = owner->getWordWrapWidth();
+
+ if (wordWrapWidth != lastWordWrapWidth)
+ {
+ lastWordWrapWidth = wordWrapWidth;
+ owner->updateTextHolderSize();
+ }
+ }
+};
+
+const int flashSpeedIntervalMs = 380;
+
+const int textChangeMessageId = 0x10003001;
+const int returnKeyMessageId = 0x10003002;
+const int escapeKeyMessageId = 0x10003003;
+const int focusLossMessageId = 0x10003004;
+
+TextEditor::TextEditor (const String& name,
+ const tchar passwordCharacter_)
+ : Component (name),
+ borderSize (1, 1, 1, 3),
+ readOnly (false),
+ multiline (false),
+ wordWrap (false),
+ returnKeyStartsNewLine (false),
+ caretVisible (true),
+ popupMenuEnabled (true),
+ selectAllTextWhenFocused (false),
+ scrollbarVisible (true),
+ wasFocused (false),
+ caretFlashState (true),
+ keepCursorOnScreen (true),
+ tabKeyUsed (false),
+ menuActive (false),
+ cursorX (0),
+ cursorY (0),
+ cursorHeight (0),
+ maxTextLength (0),
+ selectionStart (0),
+ selectionEnd (0),
+ leftIndent (4),
+ topIndent (4),
+ lastTransactionTime (0),
+ currentFont (14.0f),
+ totalNumChars (0),
+ caretPosition (0),
+ sections (8),
+ passwordCharacter (passwordCharacter_),
+ dragType (notDragging),
+ listeners (2)
+{
+ setOpaque (true);
+
+ addAndMakeVisible (viewport = new TextEditorViewport (this));
+ viewport->setViewedComponent (textHolder = new TextHolderComponent (this));
+ viewport->setWantsKeyboardFocus (false);
+ viewport->setScrollBarsShown (false, false);
+
+ setMouseCursor (MouseCursor::IBeamCursor);
+ setWantsKeyboardFocus (true);
+}
+
+TextEditor::~TextEditor()
+{
+ clearInternal (0);
+ delete viewport;
+}
+
+void TextEditor::newTransaction() throw()
+{
+ lastTransactionTime = Time::getApproximateMillisecondCounter();
+ undoManager.beginNewTransaction();
+}
+
+void TextEditor::doUndoRedo (const bool isRedo)
+{
+ if (! isReadOnly())
+ {
+ if ((isRedo) ? undoManager.redo()
+ : undoManager.undo())
+ {
+ scrollToMakeSureCursorIsVisible();
+ repaint();
+ textChanged();
+ }
+ }
+}
+
+void TextEditor::setMultiLine (const bool shouldBeMultiLine,
+ const bool shouldWordWrap)
+{
+ multiline = shouldBeMultiLine;
+ wordWrap = shouldWordWrap && shouldBeMultiLine;
+
+ setScrollbarsShown (scrollbarVisible);
+
+ viewport->setViewPosition (0, 0);
+
+ resized();
+ scrollToMakeSureCursorIsVisible();
+}
+
+bool TextEditor::isMultiLine() const throw()
+{
+ return multiline;
+}
+
+void TextEditor::setScrollbarsShown (bool enabled) throw()
+{
+ scrollbarVisible = enabled;
+
+ enabled = enabled && isMultiLine();
+
+ viewport->setScrollBarsShown (enabled, enabled);
+}
+
+void TextEditor::setReadOnly (const bool shouldBeReadOnly)
+{
+ readOnly = shouldBeReadOnly;
+ enablementChanged();
+}
+
+bool TextEditor::isReadOnly() const throw()
+{
+ return readOnly || ! isEnabled();
+}
+
+void TextEditor::setReturnKeyStartsNewLine (const bool shouldStartNewLine)
+{
+ returnKeyStartsNewLine = shouldStartNewLine;
+}
+
+void TextEditor::setTabKeyUsedAsCharacter (const bool shouldTabKeyBeUsed) throw()
+{
+ tabKeyUsed = shouldTabKeyBeUsed;
+}
+
+void TextEditor::setPopupMenuEnabled (const bool b) throw()
+{
+ popupMenuEnabled = b;
+}
+
+void TextEditor::setSelectAllWhenFocused (const bool b) throw()
+{
+ selectAllTextWhenFocused = b;
+}
+
+const Font TextEditor::getFont() const throw()
+{
+ return currentFont;
+}
+
+void TextEditor::setFont (const Font& newFont) throw()
+{
+ currentFont = newFont;
+ scrollToMakeSureCursorIsVisible();
+}
+
+void TextEditor::applyFontToAllText (const Font& newFont)
+{
+ currentFont = newFont;
+
+ const Colour overallColour (findColour (textColourId));
+
+ for (int i = sections.size(); --i >= 0;)
+ {
+ UniformTextSection* const uts = (UniformTextSection*) sections.getUnchecked(i);
+ uts->setFont (newFont, passwordCharacter);
+ uts->colour = overallColour;
+ }
+
+ coalesceSimilarSections();
+ updateTextHolderSize();
+ scrollToMakeSureCursorIsVisible();
+ repaint();
+}
+
+void TextEditor::colourChanged()
+{
+ setOpaque (findColour (backgroundColourId).isOpaque());
+ repaint();
+}
+
+void TextEditor::setCaretVisible (const bool shouldCaretBeVisible) throw()
+{
+ caretVisible = shouldCaretBeVisible;
+
+ if (shouldCaretBeVisible)
+ textHolder->startTimer (flashSpeedIntervalMs);
+
+ setMouseCursor (shouldCaretBeVisible ? MouseCursor::IBeamCursor
+ : MouseCursor::NormalCursor);
+}
+
+void TextEditor::setInputRestrictions (const int maxLen,
+ const String& chars) throw()
+{
+ maxTextLength = jmax (0, maxLen);
+ allowedCharacters = chars;
+}
+
+void TextEditor::setTextToShowWhenEmpty (const String& text, const Colour& colourToUse) throw()
+{
+ textToShowWhenEmpty = text;
+ colourForTextWhenEmpty = colourToUse;
+}
+
+void TextEditor::setPasswordCharacter (const tchar newPasswordCharacter) throw()
+{
+ if (passwordCharacter != newPasswordCharacter)
+ {
+ passwordCharacter = newPasswordCharacter;
+ resized();
+ repaint();
+ }
+}
+
+void TextEditor::setScrollBarThickness (const int newThicknessPixels)
+{
+ viewport->setScrollBarThickness (newThicknessPixels);
+}
+
+void TextEditor::setScrollBarButtonVisibility (const bool buttonsVisible)
+{
+ viewport->setScrollBarButtonVisibility (buttonsVisible);
+}
+
+void TextEditor::clear()
+{
+ clearInternal (0);
+ updateTextHolderSize();
+ undoManager.clearUndoHistory();
+}
+
+void TextEditor::setText (const String& newText,
+ const bool sendTextChangeMessage)
+{
+ const int newLength = newText.length();
+
+ if (newLength != getTotalNumChars() || getText() != newText)
+ {
+ const int oldCursorPos = caretPosition;
+ const bool cursorWasAtEnd = oldCursorPos >= getTotalNumChars();
+
+ clearInternal (0);
+ insert (newText, 0, currentFont, findColour (textColourId), 0, caretPosition);
+
+ // if you're adding text with line-feeds to a single-line text editor, it
+ // ain't gonna look right!
+ jassert (multiline || ! newText.containsAnyOf (T("\r\n")));
+
+ if (cursorWasAtEnd && ! isMultiLine())
+ moveCursorTo (getTotalNumChars(), false);
+ else
+ moveCursorTo (oldCursorPos, false);
+
+ if (sendTextChangeMessage)
+ textChanged();
+
+ repaint();
+ }
+
+ updateTextHolderSize();
+ scrollToMakeSureCursorIsVisible();
+ undoManager.clearUndoHistory();
+}
+
+void TextEditor::textChanged() throw()
+{
+ updateTextHolderSize();
+ postCommandMessage (textChangeMessageId);
+}
+
+void TextEditor::returnPressed()
+{
+ postCommandMessage (returnKeyMessageId);
+}
+
+void TextEditor::escapePressed()
+{
+ postCommandMessage (escapeKeyMessageId);
+}
+
+void TextEditor::addListener (TextEditorListener* const newListener) throw()
+{
+ jassert (newListener != 0)
+
+ if (newListener != 0)
+ listeners.add (newListener);
+}
+
+void TextEditor::removeListener (TextEditorListener* const listenerToRemove) throw()
+{
+ listeners.removeValue (listenerToRemove);
+}
+
+void TextEditor::timerCallbackInt()
+{
+ const bool newState = (! caretFlashState) && ! isCurrentlyBlockedByAnotherModalComponent();
+
+ if (caretFlashState != newState)
+ {
+ caretFlashState = newState;
+
+ if (caretFlashState)
+ wasFocused = true;
+
+ if (caretVisible
+ && hasKeyboardFocus (false)
+ && ! isReadOnly())
+ {
+ repaintCaret();
+ }
+ }
+
+ const unsigned int now = Time::getApproximateMillisecondCounter();
+
+ if (now > lastTransactionTime + 200)
+ newTransaction();
+}
+
+void TextEditor::repaintCaret()
+{
+ if (! findColour (caretColourId).isTransparent())
+ repaint (borderSize.getLeft() + textHolder->getX() + leftIndent + roundFloatToInt (cursorX) - 1,
+ borderSize.getTop() + textHolder->getY() + topIndent + roundFloatToInt (cursorY) - 1,
+ 4,
+ roundFloatToInt (cursorHeight) + 2);
+}
+
+void TextEditor::repaintText (int textStartIndex, int textEndIndex)
+{
+ if (textStartIndex > textEndIndex && textEndIndex > 0)
+ swapVariables (textStartIndex, textEndIndex);
+
+ float x = 0, y = 0, lh = currentFont.getHeight();
+
+ const float wordWrapWidth = getWordWrapWidth();
+
+ if (wordWrapWidth > 0)
+ {
+ TextEditorIterator i (sections, wordWrapWidth, passwordCharacter);
+
+ i.getCharPosition (textStartIndex, x, y, lh);
+
+ const int y1 = (int) y;
+ int y2;
+
+ if (textEndIndex >= 0)
+ {
+ i.getCharPosition (textEndIndex, x, y, lh);
+ y2 = (int) (y + lh * 2.0f);
+ }
+ else
+ {
+ y2 = textHolder->getHeight();
+ }
+
+ textHolder->repaint (0, y1, textHolder->getWidth(), y2 - y1);
+ }
+}
+
+void TextEditor::moveCaret (int newCaretPos) throw()
+{
+ if (newCaretPos < 0)
+ newCaretPos = 0;
+ else if (newCaretPos > getTotalNumChars())
+ newCaretPos = getTotalNumChars();
+
+ if (newCaretPos != getCaretPosition())
+ {
+ repaintCaret();
+ caretFlashState = true;
+ caretPosition = newCaretPos;
+ textHolder->startTimer (flashSpeedIntervalMs);
+ scrollToMakeSureCursorIsVisible();
+ repaintCaret();
+ }
+}
+
+void TextEditor::setCaretPosition (const int newIndex) throw()
+{
+ moveCursorTo (newIndex, false);
+}
+
+int TextEditor::getCaretPosition() const throw()
+{
+ return caretPosition;
+}
+
+float TextEditor::getWordWrapWidth() const throw()
+{
+ return (wordWrap) ? (float) (viewport->getMaximumVisibleWidth() - leftIndent - leftIndent / 2)
+ : 1.0e10f;
+}
+
+void TextEditor::updateTextHolderSize() throw()
+{
+ const float wordWrapWidth = getWordWrapWidth();
+
+ if (wordWrapWidth > 0)
+ {
+ float maxWidth = 0.0f;
+
+ TextEditorIterator i (sections, wordWrapWidth, passwordCharacter);
+
+ while (i.next())
+ maxWidth = jmax (maxWidth, i.atomRight);
+
+ const int w = leftIndent + roundFloatToInt (maxWidth);
+ const int h = topIndent + roundFloatToInt (jmax (i.lineY + i.lineHeight,
+ currentFont.getHeight()));
+
+ textHolder->setSize (w + 1, h + 1);
+ }
+}
+
+int TextEditor::getTextWidth() const throw()
+{
+ return textHolder->getWidth();
+}
+
+int TextEditor::getTextHeight() const throw()
+{
+ return textHolder->getHeight();
+}
+
+void TextEditor::setIndents (const int newLeftIndent,
+ const int newTopIndent) throw()
+{
+ leftIndent = newLeftIndent;
+ topIndent = newTopIndent;
+}
+
+void TextEditor::setBorder (const BorderSize& border) throw()
+{
+ borderSize = border;
+ resized();
+}
+
+const BorderSize TextEditor::getBorder() const throw()
+{
+ return borderSize;
+}
+
+void TextEditor::setScrollToShowCursor (const bool shouldScrollToShowCursor) throw()
+{
+ keepCursorOnScreen = shouldScrollToShowCursor;
+}
+
+void TextEditor::scrollToMakeSureCursorIsVisible() throw()
+{
+ cursorHeight = currentFont.getHeight(); // (in case the text is empty and the call below doesn't set this value)
+
+ getCharPosition (caretPosition,
+ cursorX, cursorY,
+ cursorHeight);
+
+ if (keepCursorOnScreen)
+ {
+ int x = viewport->getViewPositionX();
+ int y = viewport->getViewPositionY();
+
+ const int relativeCursorX = roundFloatToInt (cursorX) - x;
+ const int relativeCursorY = roundFloatToInt (cursorY) - y;
+
+ if (relativeCursorX < jmax (1, proportionOfWidth (0.05f)))
+ {
+ x += relativeCursorX - proportionOfWidth (0.2f);
+ }
+ else if (relativeCursorX > jmax (0, viewport->getMaximumVisibleWidth() - (wordWrap ? 2 : 10)))
+ {
+ x += relativeCursorX + (isMultiLine() ? proportionOfWidth (0.2f) : 10) - viewport->getMaximumVisibleWidth();
+ }
+
+ x = jlimit (0, jmax (0, textHolder->getWidth() + 8 - viewport->getMaximumVisibleWidth()), x);
+
+ if (! isMultiLine())
+ {
+ y = (getHeight() - textHolder->getHeight() - topIndent) / -2;
+ }
+ else
+ {
+ const int curH = roundFloatToInt (cursorHeight);
+
+ if (relativeCursorY < 0)
+ {
+ y = jmax (0, relativeCursorY + y);
+ }
+ else if (relativeCursorY > jmax (0, viewport->getMaximumVisibleHeight() - topIndent - curH))
+ {
+ y += relativeCursorY + 2 + curH + topIndent - viewport->getMaximumVisibleHeight();
+ }
+ }
+
+ viewport->setViewPosition (x, y);
+ }
+}
+
+void TextEditor::moveCursorTo (const int newPosition,
+ const bool isSelecting) throw()
+{
+ if (isSelecting)
+ {
+ moveCaret (newPosition);
+
+ const int oldSelStart = selectionStart;
+ const int oldSelEnd = selectionEnd;
+
+ if (dragType == notDragging)
+ {
+ if (abs (getCaretPosition() - selectionStart) < abs (getCaretPosition() - selectionEnd))
+ dragType = draggingSelectionStart;
+ else
+ dragType = draggingSelectionEnd;
+ }
+
+ if (dragType == draggingSelectionStart)
+ {
+ selectionStart = getCaretPosition();
+
+ if (selectionEnd < selectionStart)
+ {
+ swapVariables (selectionStart, selectionEnd);
+ dragType = draggingSelectionEnd;
+ }
+ }
+ else
+ {
+ selectionEnd = getCaretPosition();
+
+ if (selectionEnd < selectionStart)
+ {
+ swapVariables (selectionStart, selectionEnd);
+ dragType = draggingSelectionStart;
+ }
+ }
+
+ jassert (selectionStart <= selectionEnd);
+ jassert (oldSelStart <= oldSelEnd);
+
+ repaintText (jmin (oldSelStart, selectionStart),
+ jmax (oldSelEnd, selectionEnd));
+ }
+ else
+ {
+ dragType = notDragging;
+
+ if (selectionEnd > selectionStart)
+ repaintText (selectionStart, selectionEnd);
+
+ moveCaret (newPosition);
+ selectionStart = getCaretPosition();
+ selectionEnd = getCaretPosition();
+ }
+}
+
+int TextEditor::getTextIndexAt (const int x,
+ const int y) throw()
+{
+ return indexAtPosition ((float) (x + viewport->getViewPositionX() - leftIndent),
+ (float) (y + viewport->getViewPositionY() - topIndent));
+}
+
+void TextEditor::insertTextAtCursor (String newText)
+{
+ if (allowedCharacters.isNotEmpty())
+ newText = newText.retainCharacters (allowedCharacters);
+
+ if (! isMultiLine())
+ newText = newText.replaceCharacters (T("\r\n"), T(" "));
+ else
+ newText = newText.replace (T("\r\n"), T("\n"));
+
+ const int newCaretPos = selectionStart + newText.length();
+ const int insertIndex = selectionStart;
+
+ remove (selectionStart, selectionEnd,
+ &undoManager,
+ newCaretPos);
+
+ if (maxTextLength > 0)
+ newText = newText.substring (0, maxTextLength - getTotalNumChars());
+
+ if (newText.isNotEmpty())
+ insert (newText,
+ insertIndex,
+ currentFont,
+ findColour (textColourId),
+ &undoManager,
+ newCaretPos);
+
+ textChanged();
+}
+
+void TextEditor::setHighlightedRegion (int startPos, int numChars) throw()
+{
+ moveCursorTo (startPos, false);
+ moveCursorTo (startPos + numChars, true);
+}
+
+void TextEditor::copy()
+{
+ const String selection (getTextSubstring (selectionStart, selectionEnd));
+
+ if (selection.isNotEmpty())
+ SystemClipboard::copyTextToClipboard (selection);
+}
+
+void TextEditor::paste()
+{
+ if (! isReadOnly())
+ {
+ const String clip (SystemClipboard::getTextFromClipboard());
+
+ if (clip.isNotEmpty())
+ insertTextAtCursor (clip);
+ }
+}
+
+void TextEditor::cut()
+{
+ if (! isReadOnly())
+ {
+ moveCaret (selectionEnd);
+ insertTextAtCursor (String::empty);
+ }
+}
+
+void TextEditor::drawContent (Graphics& g)
+{
+ const float wordWrapWidth = getWordWrapWidth();
+
+ if (wordWrapWidth > 0)
+ {
+ g.setOrigin (leftIndent, topIndent);
+ const Rectangle clip (g.getClipBounds());
+ Colour selectedTextColour;
+
+ TextEditorIterator i (sections, wordWrapWidth, passwordCharacter);
+
+ while (i.lineY + 200.0 < clip.getY() && i.next())
+ {}
+
+ if (selectionStart < selectionEnd)
+ {
+ g.setColour (findColour (highlightColourId)
+ .withMultipliedAlpha (hasKeyboardFocus (true) ? 1.0f : 0.5f));
+
+ selectedTextColour = findColour (highlightedTextColourId);
+
+ TextEditorIterator i2 (i);
+
+ while (i2.next() && i2.lineY < clip.getBottom())
+ {
+ i2.updateLineHeight();
+
+ if (i2.lineY + i2.lineHeight >= clip.getY()
+ && selectionEnd >= i2.indexInText
+ && selectionStart <= i2.indexInText + i2.atom->numChars)
+ {
+ i2.drawSelection (g, selectionStart, selectionEnd);
+ }
+ }
+ }
+
+ const UniformTextSection* lastSection = 0;
+
+ while (i.next() && i.lineY < clip.getBottom())
+ {
+ i.updateLineHeight();
+
+ if (i.lineY + i.lineHeight >= clip.getY())
+ {
+ if (selectionEnd >= i.indexInText
+ && selectionStart <= i.indexInText + i.atom->numChars)
+ {
+ i.drawSelectedText (g, selectionStart, selectionEnd, selectedTextColour);
+ lastSection = 0;
+ }
+ else
+ {
+ i.draw (g, lastSection);
+ }
+ }
+ }
+ }
+}
+
+void TextEditor::paint (Graphics& g)
+{
+ getLookAndFeel().fillTextEditorBackground (g, getWidth(), getHeight(), *this);
+}
+
+void TextEditor::paintOverChildren (Graphics& g)
+{
+ if (caretFlashState
+ && hasKeyboardFocus (false)
+ && caretVisible
+ && ! isReadOnly())
+ {
+ g.setColour (findColour (caretColourId));
+
+ g.fillRect (borderSize.getLeft() + textHolder->getX() + leftIndent + cursorX,
+ borderSize.getTop() + textHolder->getY() + topIndent + cursorY,
+ 2.0f, cursorHeight);
+ }
+
+ if (textToShowWhenEmpty.isNotEmpty()
+ && (! hasKeyboardFocus (false))
+ && getTotalNumChars() == 0)
+ {
+ g.setColour (colourForTextWhenEmpty);
+ g.setFont (getFont());
+
+ if (isMultiLine())
+ {
+ g.drawText (textToShowWhenEmpty,
+ 0, 0, getWidth(), getHeight(),
+ Justification::centred, true);
+ }
+ else
+ {
+ g.drawText (textToShowWhenEmpty,
+ leftIndent, topIndent,
+ viewport->getWidth() - leftIndent,
+ viewport->getHeight() - topIndent,
+ Justification::centredLeft, true);
+ }
+ }
+
+ getLookAndFeel().drawTextEditorOutline (g, getWidth(), getHeight(), *this);
+}
+
+void TextEditor::mouseDown (const MouseEvent& e)
+{
+ beginDragAutoRepeat (100);
+ newTransaction();
+
+ if (wasFocused || ! selectAllTextWhenFocused)
+ {
+ if (! (popupMenuEnabled && e.mods.isPopupMenu()))
+ {
+ moveCursorTo (getTextIndexAt (e.x, e.y),
+ e.mods.isShiftDown());
+ }
+ else
+ {
+ PopupMenu m;
+ addPopupMenuItems (m, &e);
+
+ menuActive = true;
+ const int result = m.show();
+ menuActive = false;
+
+ if (result != 0)
+ performPopupMenuAction (result);
+ }
+ }
+}
+
+void TextEditor::mouseDrag (const MouseEvent& e)
+{
+ if (wasFocused || ! selectAllTextWhenFocused)
+ {
+ if (! (popupMenuEnabled && e.mods.isPopupMenu()))
+ {
+ moveCursorTo (getTextIndexAt (e.x, e.y), true);
+ }
+ }
+}
+
+void TextEditor::mouseUp (const MouseEvent& e)
+{
+ newTransaction();
+ textHolder->startTimer (flashSpeedIntervalMs);
+
+ if (wasFocused || ! selectAllTextWhenFocused)
+ {
+ if (! (popupMenuEnabled && e.mods.isPopupMenu()))
+ {
+ moveCaret (getTextIndexAt (e.x, e.y));
+ }
+ }
+
+ wasFocused = true;
+}
+
+void TextEditor::mouseDoubleClick (const MouseEvent& e)
+{
+ int tokenEnd = getTextIndexAt (e.x, e.y);
+ int tokenStart = tokenEnd;
+
+ if (e.getNumberOfClicks() > 3)
+ {
+ tokenStart = 0;
+ tokenEnd = getTotalNumChars();
+ }
+ else
+ {
+ const String t (getText());
+ const int totalLength = getTotalNumChars();
+
+ while (tokenEnd < totalLength)
+ {
+ if (CharacterFunctions::isLetterOrDigit (t [tokenEnd]))
+ ++tokenEnd;
+ else
+ break;
+ }
+
+ tokenStart = tokenEnd;
+
+ while (tokenStart > 0)
+ {
+ if (CharacterFunctions::isLetterOrDigit (t [tokenStart - 1]))
+ --tokenStart;
+ else
+ break;
+ }
+
+ if (e.getNumberOfClicks() > 2)
+ {
+ while (tokenEnd < totalLength)
+ {
+ if (t [tokenEnd] != T('\r') && t [tokenEnd] != T('\n'))
+ ++tokenEnd;
+ else
+ break;
+ }
+
+ while (tokenStart > 0)
+ {
+ if (t [tokenStart - 1] != T('\r') && t [tokenStart - 1] != T('\n'))
+ --tokenStart;
+ else
+ break;
+ }
+ }
+ }
+
+ moveCursorTo (tokenEnd, false);
+ moveCursorTo (tokenStart, true);
+}
+
+void TextEditor::mouseWheelMove (const MouseEvent& e, float wheelIncrementX, float wheelIncrementY)
+{
+ if (! viewport->useMouseWheelMoveIfNeeded (e, wheelIncrementX, wheelIncrementY))
+ Component::mouseWheelMove (e, wheelIncrementX, wheelIncrementY);
+}
+
+bool TextEditor::keyPressed (const KeyPress& key)
+{
+ if (isReadOnly() && key != KeyPress (T('c'), ModifierKeys::commandModifier, 0))
+ return false;
+
+ const bool moveInWholeWordSteps = key.getModifiers().isCtrlDown() || key.getModifiers().isAltDown();
+
+ if (key.isKeyCode (KeyPress::leftKey)
+ || key.isKeyCode (KeyPress::upKey))
+ {
+ newTransaction();
+
+ int newPos;
+
+ if (isMultiLine() && key.isKeyCode (KeyPress::upKey))
+ newPos = indexAtPosition (cursorX, cursorY - 1);
+ else if (moveInWholeWordSteps)
+ newPos = findWordBreakBefore (getCaretPosition());
+ else
+ newPos = getCaretPosition() - 1;
+
+ moveCursorTo (newPos, key.getModifiers().isShiftDown());
+ }
+ else if (key.isKeyCode (KeyPress::rightKey)
+ || key.isKeyCode (KeyPress::downKey))
+ {
+ newTransaction();
+
+ int newPos;
+
+ if (isMultiLine() && key.isKeyCode (KeyPress::downKey))
+ newPos = indexAtPosition (cursorX, cursorY + cursorHeight + 1);
+ else if (moveInWholeWordSteps)
+ newPos = findWordBreakAfter (getCaretPosition());
+ else
+ newPos = getCaretPosition() + 1;
+
+ moveCursorTo (newPos, key.getModifiers().isShiftDown());
+ }
+ else if (key.isKeyCode (KeyPress::pageDownKey) && isMultiLine())
+ {
+ newTransaction();
+
+ moveCursorTo (indexAtPosition (cursorX, cursorY + cursorHeight + viewport->getViewHeight()),
+ key.getModifiers().isShiftDown());
+ }
+ else if (key.isKeyCode (KeyPress::pageUpKey) && isMultiLine())
+ {
+ newTransaction();
+
+ moveCursorTo (indexAtPosition (cursorX, cursorY - viewport->getViewHeight()),
+ key.getModifiers().isShiftDown());
+ }
+ else if (key.isKeyCode (KeyPress::homeKey))
+ {
+ newTransaction();
+
+ if (isMultiLine() && ! moveInWholeWordSteps)
+ moveCursorTo (indexAtPosition (0.0f, cursorY),
+ key.getModifiers().isShiftDown());
+ else
+ moveCursorTo (0, key.getModifiers().isShiftDown());
+ }
+ else if (key.isKeyCode (KeyPress::endKey))
+ {
+ newTransaction();
+
+ if (isMultiLine() && ! moveInWholeWordSteps)
+ moveCursorTo (indexAtPosition ((float) textHolder->getWidth(), cursorY),
+ key.getModifiers().isShiftDown());
+ else
+ moveCursorTo (getTotalNumChars(), key.getModifiers().isShiftDown());
+ }
+ else if (key.isKeyCode (KeyPress::backspaceKey))
+ {
+ if (moveInWholeWordSteps)
+ {
+ moveCursorTo (findWordBreakBefore (getCaretPosition()), true);
+ }
+ else
+ {
+ if (selectionStart == selectionEnd && selectionStart > 0)
+ --selectionStart;
+ }
+
+ cut();
+ }
+ else if (key.isKeyCode (KeyPress::deleteKey))
+ {
+ if (key.getModifiers().isShiftDown())
+ copy();
+
+ if (selectionStart == selectionEnd
+ && selectionEnd < getTotalNumChars())
+ {
+ ++selectionEnd;
+ }
+
+ cut();
+ }
+ else if (key == KeyPress (T('c'), ModifierKeys::commandModifier, 0)
+ || key == KeyPress (KeyPress::insertKey, ModifierKeys::ctrlModifier, 0))
+ {
+ newTransaction();
+ copy();
+ }
+ else if (key == KeyPress (T('x'), ModifierKeys::commandModifier, 0))
+ {
+ newTransaction();
+ copy();
+ cut();
+ }
+ else if (key == KeyPress (T('v'), ModifierKeys::commandModifier, 0)
+ || key == KeyPress (KeyPress::insertKey, ModifierKeys::shiftModifier, 0))
+ {
+ newTransaction();
+ paste();
+ }
+ else if (key == KeyPress (T('z'), ModifierKeys::commandModifier, 0))
+ {
+ newTransaction();
+ doUndoRedo (false);
+ }
+ else if (key == KeyPress (T('y'), ModifierKeys::commandModifier, 0))
+ {
+ newTransaction();
+ doUndoRedo (true);
+ }
+ else if (key == KeyPress (T('a'), ModifierKeys::commandModifier, 0))
+ {
+ newTransaction();
+ moveCursorTo (getTotalNumChars(), false);
+ moveCursorTo (0, true);
+ }
+ else if (key == KeyPress::returnKey)
+ {
+ newTransaction();
+
+ if (returnKeyStartsNewLine)
+ insertTextAtCursor (T("\n"));
+ else
+ returnPressed();
+ }
+ else if (key.isKeyCode (KeyPress::escapeKey))
+ {
+ newTransaction();
+ moveCursorTo (getCaretPosition(), false);
+ escapePressed();
+ }
+ else if (key.getTextCharacter() >= ' '
+ || (tabKeyUsed && (key.getTextCharacter() == '\t')))
+ {
+ insertTextAtCursor (String::charToString (key.getTextCharacter()));
+
+ lastTransactionTime = Time::getApproximateMillisecondCounter();
+ }
+ else
+ {
+ return false;
+ }
+
+ return true;
+}
+
+bool TextEditor::keyStateChanged()
+{
+ // (overridden to avoid forwarding key events to the parent)
+ return true;
+}
+
+const int baseMenuItemID = 0x7fff0000;
+
+void TextEditor::addPopupMenuItems (PopupMenu& m, const MouseEvent*)
+{
+ const bool writable = ! isReadOnly();
+
+ m.addItem (baseMenuItemID + 1, TRANS("cut"), writable);
+ m.addItem (baseMenuItemID + 2, TRANS("copy"), selectionStart < selectionEnd);
+ m.addItem (baseMenuItemID + 3, TRANS("paste"), writable);
+ m.addItem (baseMenuItemID + 4, TRANS("delete"), writable);
+ m.addSeparator();
+ m.addItem (baseMenuItemID + 5, TRANS("select all"));
+ m.addSeparator();
+ m.addItem (baseMenuItemID + 6, TRANS("undo"), undoManager.canUndo());
+ m.addItem (baseMenuItemID + 7, TRANS("redo"), undoManager.canRedo());
+}
+
+void TextEditor::performPopupMenuAction (const int menuItemID)
+{
+ switch (menuItemID)
+ {
+ case baseMenuItemID + 1:
+ copy();
+ cut();
+ break;
+
+ case baseMenuItemID + 2:
+ copy();
+ break;
+
+ case baseMenuItemID + 3:
+ paste();
+ break;
+
+ case baseMenuItemID + 4:
+ cut();
+ break;
+
+ case baseMenuItemID + 5:
+ moveCursorTo (getTotalNumChars(), false);
+ moveCursorTo (0, true);
+ break;
+
+ case baseMenuItemID + 6:
+ doUndoRedo (false);
+ break;
+
+ case baseMenuItemID + 7:
+ doUndoRedo (true);
+ break;
+
+ default:
+ break;
+ }
+}
+
+void TextEditor::focusGained (FocusChangeType)
+{
+ newTransaction();
+
+ caretFlashState = true;
+
+ if (selectAllTextWhenFocused)
+ {
+ moveCursorTo (0, false);
+ moveCursorTo (getTotalNumChars(), true);
+ }
+
+ repaint();
+
+ if (caretVisible)
+ textHolder->startTimer (flashSpeedIntervalMs);
+}
+
+void TextEditor::focusLost (FocusChangeType)
+{
+ newTransaction();
+
+ wasFocused = false;
+ textHolder->stopTimer();
+ caretFlashState = false;
+
+ postCommandMessage (focusLossMessageId);
+ repaint();
+}
+
+void TextEditor::resized()
+{
+ viewport->setBoundsInset (borderSize);
+ viewport->setSingleStepSizes (16, roundFloatToInt (currentFont.getHeight()));
+
+ updateTextHolderSize();
+
+ if (! isMultiLine())
+ {
+ scrollToMakeSureCursorIsVisible();
+ }
+ else
+ {
+ cursorHeight = currentFont.getHeight(); // (in case the text is empty and the call below doesn't set this value)
+
+ getCharPosition (caretPosition,
+ cursorX, cursorY,
+ cursorHeight);
+ }
+}
+
+void TextEditor::handleCommandMessage (const int commandId)
+{
+ const ComponentDeletionWatcher deletionChecker (this);
+
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ TextEditorListener* const tl = (TextEditorListener*) listeners [i];
+
+ if (tl != 0)
+ {
+ switch (commandId)
+ {
+ case textChangeMessageId:
+ tl->textEditorTextChanged (*this);
+ break;
+
+ case returnKeyMessageId:
+ tl->textEditorReturnKeyPressed (*this);
+ break;
+
+ case escapeKeyMessageId:
+ tl->textEditorEscapeKeyPressed (*this);
+ break;
+
+ case focusLossMessageId:
+ tl->textEditorFocusLost (*this);
+ break;
+
+ default:
+ jassertfalse
+ break;
+ }
+
+ if (i > 0 && deletionChecker.hasBeenDeleted())
+ return;
+ }
+ }
+}
+
+void TextEditor::enablementChanged()
+{
+ setMouseCursor (MouseCursor (isReadOnly() ? MouseCursor::NormalCursor
+ : MouseCursor::IBeamCursor));
+ repaint();
+}
+
+void TextEditor::clearInternal (UndoManager* const um) throw()
+{
+ remove (0, getTotalNumChars(), um, caretPosition);
+}
+
+void TextEditor::insert (const String& text,
+ const int insertIndex,
+ const Font& font,
+ const Colour& colour,
+ UndoManager* const um,
+ const int caretPositionToMoveTo) throw()
+{
+ if (text.isNotEmpty())
+ {
+ if (um != 0)
+ {
+ um->perform (new TextEditorInsertAction (*this,
+ text,
+ insertIndex,
+ font,
+ colour,
+ caretPosition,
+ caretPositionToMoveTo));
+ }
+ else
+ {
+ repaintText (insertIndex, -1); // must do this before and after changing the data, in case
+ // a line gets moved due to word wrap
+
+ int index = 0;
+ int nextIndex = 0;
+
+ for (int i = 0; i < sections.size(); ++i)
+ {
+ nextIndex = index + ((UniformTextSection*) sections.getUnchecked(i))->getTotalLength();
+
+ if (insertIndex == index)
+ {
+ sections.insert (i, new UniformTextSection (text,
+ font, colour,
+ passwordCharacter));
+ break;
+ }
+ else if (insertIndex > index && insertIndex < nextIndex)
+ {
+ splitSection (i, insertIndex - index);
+ sections.insert (i + 1, new UniformTextSection (text,
+ font, colour,
+ passwordCharacter));
+ break;
+ }
+
+ index = nextIndex;
+ }
+
+ if (nextIndex == insertIndex)
+ sections.add (new UniformTextSection (text,
+ font, colour,
+ passwordCharacter));
+
+ coalesceSimilarSections();
+ totalNumChars = -1;
+
+ moveCursorTo (caretPositionToMoveTo, false);
+
+ repaintText (insertIndex, -1);
+ }
+ }
+}
+
+void TextEditor::reinsert (const int insertIndex,
+ const VoidArray& sectionsToInsert) throw()
+{
+ int index = 0;
+ int nextIndex = 0;
+
+ for (int i = 0; i < sections.size(); ++i)
+ {
+ nextIndex = index + ((UniformTextSection*) sections.getUnchecked(i))->getTotalLength();
+
+ if (insertIndex == index)
+ {
+ for (int j = sectionsToInsert.size(); --j >= 0;)
+ sections.insert (i, new UniformTextSection (*(UniformTextSection*) sectionsToInsert.getUnchecked(j)));
+
+ break;
+ }
+ else if (insertIndex > index && insertIndex < nextIndex)
+ {
+ splitSection (i, insertIndex - index);
+
+ for (int j = sectionsToInsert.size(); --j >= 0;)
+ sections.insert (i + 1, new UniformTextSection (*(UniformTextSection*) sectionsToInsert.getUnchecked(j)));
+
+ break;
+ }
+
+ index = nextIndex;
+ }
+
+ if (nextIndex == insertIndex)
+ {
+ for (int j = 0; j < sectionsToInsert.size(); ++j)
+ sections.add (new UniformTextSection (*(UniformTextSection*) sectionsToInsert.getUnchecked(j)));
+ }
+
+ coalesceSimilarSections();
+ totalNumChars = -1;
+}
+
+void TextEditor::remove (const int startIndex,
+ int endIndex,
+ UndoManager* const um,
+ const int caretPositionToMoveTo) throw()
+{
+ if (endIndex > startIndex)
+ {
+ int index = 0;
+
+ for (int i = 0; i < sections.size(); ++i)
+ {
+ const int nextIndex = index + ((UniformTextSection*) sections[i])->getTotalLength();
+
+ if (startIndex > index && startIndex < nextIndex)
+ {
+ splitSection (i, startIndex - index);
+ --i;
+ }
+ else if (endIndex > index && endIndex < nextIndex)
+ {
+ splitSection (i, endIndex - index);
+ --i;
+ }
+ else
+ {
+ index = nextIndex;
+
+ if (index > endIndex)
+ break;
+ }
+ }
+
+ index = 0;
+
+ if (um != 0)
+ {
+ VoidArray removedSections;
+
+ for (int i = 0; i < sections.size(); ++i)
+ {
+ if (endIndex <= startIndex)
+ break;
+
+ UniformTextSection* const section = (UniformTextSection*) sections.getUnchecked (i);
+
+ const int nextIndex = index + section->getTotalLength();
+
+ if (startIndex <= index && endIndex >= nextIndex)
+ removedSections.add (new UniformTextSection (*section));
+
+ index = nextIndex;
+ }
+
+ um->perform (new TextEditorRemoveAction (*this,
+ startIndex,
+ endIndex,
+ caretPosition,
+ caretPositionToMoveTo,
+ removedSections));
+ }
+ else
+ {
+ for (int i = 0; i < sections.size(); ++i)
+ {
+ if (endIndex <= startIndex)
+ break;
+
+ UniformTextSection* const section = (UniformTextSection*) sections.getUnchecked (i);
+
+ const int nextIndex = index + section->getTotalLength();
+
+ if (startIndex <= index && endIndex >= nextIndex)
+ {
+ sections.remove(i);
+ endIndex -= (nextIndex - index);
+ section->clear();
+ delete section;
+ --i;
+ }
+ else
+ {
+ index = nextIndex;
+ }
+ }
+
+ coalesceSimilarSections();
+ totalNumChars = -1;
+
+ moveCursorTo (caretPositionToMoveTo, false);
+
+ repaintText (startIndex, -1);
+ }
+ }
+}
+
+const String TextEditor::getText() const throw()
+{
+ String t;
+
+ for (int i = 0; i < sections.size(); ++i)
+ t += ((const UniformTextSection*) sections.getUnchecked(i))->getAllText();
+
+ return t;
+}
+
+const String TextEditor::getTextSubstring (const int startCharacter, const int endCharacter) const throw()
+{
+ String t;
+ int index = 0;
+
+ for (int i = 0; i < sections.size(); ++i)
+ {
+ const UniformTextSection* const s = (const UniformTextSection*) sections.getUnchecked(i);
+ const int nextIndex = index + s->getTotalLength();
+
+ if (startCharacter < nextIndex)
+ {
+ if (endCharacter <= index)
+ break;
+
+ const int start = jmax (index, startCharacter);
+ t += s->getTextSubstring (start - index, endCharacter - index);
+ }
+
+ index = nextIndex;
+ }
+
+ return t;
+}
+
+const String TextEditor::getHighlightedText() const throw()
+{
+ return getTextSubstring (getHighlightedRegionStart(),
+ getHighlightedRegionStart() + getHighlightedRegionLength());
+}
+
+int TextEditor::getTotalNumChars() throw()
+{
+ if (totalNumChars < 0)
+ {
+ totalNumChars = 0;
+
+ for (int i = sections.size(); --i >= 0;)
+ totalNumChars += ((const UniformTextSection*) sections.getUnchecked(i))->getTotalLength();
+ }
+
+ return totalNumChars;
+}
+
+bool TextEditor::isEmpty() const throw()
+{
+ if (totalNumChars != 0)
+ {
+ for (int i = sections.size(); --i >= 0;)
+ if (((const UniformTextSection*) sections.getUnchecked(i))->getTotalLength() > 0)
+ return false;
+ }
+
+ return true;
+}
+
+void TextEditor::getCharPosition (const int index, float& cx, float& cy, float& lineHeight) const throw()
+{
+ const float wordWrapWidth = getWordWrapWidth();
+
+ if (wordWrapWidth > 0 && sections.size() > 0)
+ {
+ TextEditorIterator i (sections, wordWrapWidth, passwordCharacter);
+
+ i.getCharPosition (index, cx, cy, lineHeight);
+ }
+ else
+ {
+ cx = cy = 0;
+ lineHeight = currentFont.getHeight();
+ }
+}
+
+int TextEditor::indexAtPosition (const float x, const float y) throw()
+{
+ const float wordWrapWidth = getWordWrapWidth();
+
+ if (wordWrapWidth > 0)
+ {
+ TextEditorIterator i (sections, wordWrapWidth, passwordCharacter);
+
+ while (i.next())
+ {
+ if (i.lineY + getHeight() > y)
+ i.updateLineHeight();
+
+ if (i.lineY + i.lineHeight > y)
+ {
+ if (i.lineY > y)
+ return jmax (0, i.indexInText - 1);
+
+ if (i.atomX >= x)
+ return i.indexInText;
+
+ if (x < i.atomRight)
+ return i.xToIndex (x);
+ }
+ }
+ }
+
+ return getTotalNumChars();
+}
+
+static int getCharacterCategory (const tchar character) throw()
+{
+ return CharacterFunctions::isLetterOrDigit (character)
+ ? 2 : (CharacterFunctions::isWhitespace (character) ? 0 : 1);
+}
+
+int TextEditor::findWordBreakAfter (const int position) const throw()
+{
+ const String t (getTextSubstring (position, position + 512));
+ const int totalLength = t.length();
+ int i = 0;
+
+ while (i < totalLength && CharacterFunctions::isWhitespace (t[i]))
+ ++i;
+
+ const int type = getCharacterCategory (t[i]);
+
+ while (i < totalLength && type == getCharacterCategory (t[i]))
+ ++i;
+
+ while (i < totalLength && CharacterFunctions::isWhitespace (t[i]))
+ ++i;
+
+ return position + i;
+}
+
+int TextEditor::findWordBreakBefore (const int position) const throw()
+{
+ if (position <= 0)
+ return 0;
+
+ const int startOfBuffer = jmax (0, position - 512);
+ const String t (getTextSubstring (startOfBuffer, position));
+
+ int i = position - startOfBuffer;
+
+ while (i > 0 && CharacterFunctions::isWhitespace (t [i - 1]))
+ --i;
+
+ if (i > 0)
+ {
+ const int type = getCharacterCategory (t [i - 1]);
+
+ while (i > 0 && type == getCharacterCategory (t [i - 1]))
+ --i;
+ }
+
+ jassert (startOfBuffer + i >= 0);
+ return startOfBuffer + i;
+}
+
+void TextEditor::splitSection (const int sectionIndex,
+ const int charToSplitAt) throw()
+{
+ jassert (sections[sectionIndex] != 0);
+
+ sections.insert (sectionIndex + 1,
+ ((UniformTextSection*) sections.getUnchecked (sectionIndex))
+ ->split (charToSplitAt, passwordCharacter));
+}
+
+void TextEditor::coalesceSimilarSections() throw()
+{
+ for (int i = 0; i < sections.size() - 1; ++i)
+ {
+ UniformTextSection* const s1 = (UniformTextSection*) (sections.getUnchecked (i));
+ UniformTextSection* const s2 = (UniformTextSection*) (sections.getUnchecked (i + 1));
+
+ if (s1->font == s2->font
+ && s1->colour == s2->colour)
+ {
+ s1->append (*s2, passwordCharacter);
+ sections.remove (i + 1);
+ delete s2;
+ --i;
+ }
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_TextEditor.cpp *********/
+
+/********* Start of inlined file: juce_Toolbar.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+const tchar* const Toolbar::toolbarDragDescriptor = T("_toolbarItem_");
+
+class ToolbarSpacerComp : public ToolbarItemComponent
+{
+public:
+ ToolbarSpacerComp (const int itemId, const float fixedSize_, const bool drawBar_)
+ : ToolbarItemComponent (itemId, String::empty, false),
+ fixedSize (fixedSize_),
+ drawBar (drawBar_)
+ {
+ }
+
+ ~ToolbarSpacerComp()
+ {
+ }
+
+ bool getToolbarItemSizes (int toolbarThickness, bool /*isToolbarVertical*/,
+ int& preferredSize, int& minSize, int& maxSize)
+ {
+ if (fixedSize <= 0)
+ {
+ preferredSize = toolbarThickness * 2;
+ minSize = 4;
+ maxSize = 32768;
+ }
+ else
+ {
+ maxSize = roundFloatToInt (toolbarThickness * fixedSize);
+ minSize = drawBar ? maxSize : jmin (4, maxSize);
+ preferredSize = maxSize;
+
+ if (getEditingMode() == editableOnPalette)
+ preferredSize = maxSize = toolbarThickness / (drawBar ? 3 : 2);
+ }
+
+ return true;
+ }
+
+ void paintButtonArea (Graphics&, int, int, bool, bool)
+ {
+ }
+
+ void contentAreaChanged (const Rectangle&)
+ {
+ }
+
+ int getResizeOrder() const throw()
+ {
+ return fixedSize <= 0 ? 0 : 1;
+ }
+
+ void paint (Graphics& g)
+ {
+ const int w = getWidth();
+ const int h = getHeight();
+
+ if (drawBar)
+ {
+ g.setColour (findColour (Toolbar::separatorColourId, true));
+
+ const float thickness = 0.2f;
+
+ if (isToolbarVertical())
+ g.fillRect (w * 0.1f, h * (0.5f - thickness * 0.5f), w * 0.8f, h * thickness);
+ else
+ g.fillRect (w * (0.5f - thickness * 0.5f), h * 0.1f, w * thickness, h * 0.8f);
+ }
+
+ if (getEditingMode() != normalMode && ! drawBar)
+ {
+ g.setColour (findColour (Toolbar::separatorColourId, true));
+
+ const int indentX = jmin (2, (w - 3) / 2);
+ const int indentY = jmin (2, (h - 3) / 2);
+ g.drawRect (indentX, indentY, w - indentX * 2, h - indentY * 2, 1);
+
+ if (fixedSize <= 0)
+ {
+ float x1, y1, x2, y2, x3, y3, x4, y4, hw, hl;
+
+ if (isToolbarVertical())
+ {
+ x1 = w * 0.5f;
+ y1 = h * 0.4f;
+ x2 = x1;
+ y2 = indentX * 2.0f;
+
+ x3 = x1;
+ y3 = h * 0.6f;
+ x4 = x1;
+ y4 = h - y2;
+
+ hw = w * 0.15f;
+ hl = w * 0.2f;
+ }
+ else
+ {
+ x1 = w * 0.4f;
+ y1 = h * 0.5f;
+ x2 = indentX * 2.0f;
+ y2 = y1;
+
+ x3 = w * 0.6f;
+ y3 = y1;
+ x4 = w - x2;
+ y4 = y1;
+
+ hw = h * 0.15f;
+ hl = h * 0.2f;
+ }
+
+ Path p;
+ p.addArrow (x1, y1, x2, y2, 1.5f, hw, hl);
+ p.addArrow (x3, y3, x4, y4, 1.5f, hw, hl);
+ g.fillPath (p);
+ }
+ }
+ }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ const float fixedSize;
+ const bool drawBar;
+
+ ToolbarSpacerComp (const ToolbarSpacerComp&);
+ const ToolbarSpacerComp& operator= (const ToolbarSpacerComp&);
+};
+
+class MissingItemsComponent : public PopupMenuCustomComponent
+{
+public:
+ MissingItemsComponent (Toolbar& owner_, const int height_)
+ : PopupMenuCustomComponent (true),
+ owner (owner_),
+ height (height_)
+ {
+ for (int i = owner_.getNumChildComponents(); --i >= 0;)
+ {
+ ToolbarItemComponent* const tc = dynamic_cast (owner_.getChildComponent (i));
+
+ if (tc != 0 && dynamic_cast (tc) == 0 && ! tc->isVisible())
+ {
+ oldIndexes.insert (0, i);
+ addAndMakeVisible (tc, 0);
+ }
+ }
+
+ layout (400);
+ }
+
+ ~MissingItemsComponent()
+ {
+ // deleting the toolbar while its menu it open??
+ jassert (owner.isValidComponent());
+
+ for (int i = 0; i < getNumChildComponents(); ++i)
+ {
+ ToolbarItemComponent* const tc = dynamic_cast (getChildComponent (i));
+
+ if (tc != 0)
+ {
+ tc->setVisible (false);
+ owner.addChildComponent (tc, oldIndexes.remove (i));
+ --i;
+ }
+ }
+
+ owner.resized();
+ }
+
+ void layout (const int preferredWidth)
+ {
+ const int indent = 8;
+ int x = indent;
+ int y = indent;
+ int maxX = 0;
+
+ for (int i = 0; i < getNumChildComponents(); ++i)
+ {
+ ToolbarItemComponent* const tc = dynamic_cast (getChildComponent (i));
+
+ if (tc != 0)
+ {
+ int preferredSize = 1, minSize = 1, maxSize = 1;
+
+ if (tc->getToolbarItemSizes (height, false, preferredSize, minSize, maxSize))
+ {
+ if (x + preferredSize > preferredWidth && x > indent)
+ {
+ x = indent;
+ y += height;
+ }
+
+ tc->setBounds (x, y, preferredSize, height);
+
+ x += preferredSize;
+ maxX = jmax (maxX, x);
+ }
+ }
+ }
+
+ setSize (maxX + 8, y + height + 8);
+ }
+
+ void getIdealSize (int& idealWidth, int& idealHeight)
+ {
+ idealWidth = getWidth();
+ idealHeight = getHeight();
+ }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ Toolbar& owner;
+ const int height;
+ Array oldIndexes;
+
+ MissingItemsComponent (const MissingItemsComponent&);
+ const MissingItemsComponent& operator= (const MissingItemsComponent&);
+};
+
+Toolbar::Toolbar()
+ : vertical (false),
+ isEditingActive (false),
+ toolbarStyle (Toolbar::iconsOnly)
+{
+ addChildComponent (missingItemsButton = getLookAndFeel().createToolbarMissingItemsButton (*this));
+
+ missingItemsButton->setAlwaysOnTop (true);
+ missingItemsButton->addButtonListener (this);
+}
+
+Toolbar::~Toolbar()
+{
+ animator.cancelAllAnimations (true);
+ deleteAllChildren();
+}
+
+void Toolbar::setVertical (const bool shouldBeVertical)
+{
+ if (vertical != shouldBeVertical)
+ {
+ vertical = shouldBeVertical;
+ resized();
+ }
+}
+
+void Toolbar::clear()
+{
+ for (int i = getNumChildComponents(); --i >= 0;)
+ {
+ ToolbarItemComponent* const tc = dynamic_cast (getChildComponent (i));
+ if (tc != 0)
+ delete tc;
+ }
+
+ resized();
+}
+
+ToolbarItemComponent* Toolbar::createItem (ToolbarItemFactory& factory, const int itemId)
+{
+ if (itemId == ToolbarItemFactory::separatorBarId)
+ return new ToolbarSpacerComp (itemId, 0.1f, true);
+ else if (itemId == ToolbarItemFactory::spacerId)
+ return new ToolbarSpacerComp (itemId, 0.5f, false);
+ else if (itemId == ToolbarItemFactory::flexibleSpacerId)
+ return new ToolbarSpacerComp (itemId, 0, false);
+
+ return factory.createItem (itemId);
+}
+
+void Toolbar::addItemInternal (ToolbarItemFactory& factory,
+ const int itemId,
+ const int insertIndex)
+{
+ // An ID can't be zero - this might indicate a mistake somewhere?
+ jassert (itemId != 0);
+
+ ToolbarItemComponent* const tc = createItem (factory, itemId);
+
+ if (tc != 0)
+ {
+#ifdef JUCE_DEBUG
+ Array allowedIds;
+ factory.getAllToolbarItemIds (allowedIds);
+
+ // If your factory can create an item for a given ID, it must also return
+ // that ID from its getAllToolbarItemIds() method!
+ jassert (allowedIds.contains (itemId));
+#endif
+
+ addAndMakeVisible (tc, insertIndex);
+ }
+}
+
+void Toolbar::addItem (ToolbarItemFactory& factory,
+ const int itemId,
+ const int insertIndex)
+{
+ addItemInternal (factory, itemId, insertIndex);
+ resized();
+}
+
+void Toolbar::addDefaultItems (ToolbarItemFactory& factoryToUse)
+{
+ Array ids;
+ factoryToUse.getDefaultItemSet (ids);
+
+ clear();
+
+ for (int i = 0; i < ids.size(); ++i)
+ addItemInternal (factoryToUse, ids.getUnchecked (i), -1);
+
+ resized();
+}
+
+void Toolbar::removeToolbarItem (const int itemIndex)
+{
+ ToolbarItemComponent* const tc = getItemComponent (itemIndex);
+
+ if (tc != 0)
+ {
+ delete tc;
+ resized();
+ }
+}
+
+int Toolbar::getNumItems() const throw()
+{
+ return getNumChildComponents() - 1;
+}
+
+int Toolbar::getItemId (const int itemIndex) const throw()
+{
+ ToolbarItemComponent* const tc = getItemComponent (itemIndex);
+ return tc != 0 ? tc->getItemId() : 0;
+}
+
+ToolbarItemComponent* Toolbar::getItemComponent (const int itemIndex) const throw()
+{
+ if (itemIndex < getNumItems())
+ return dynamic_cast (getChildComponent (itemIndex));
+
+ return 0;
+}
+
+ToolbarItemComponent* Toolbar::getNextActiveComponent (int index, const int delta) const
+{
+ for (;;)
+ {
+ index += delta;
+ ToolbarItemComponent* const tc = getItemComponent (index);
+
+ if (tc == 0)
+ break;
+
+ if (tc->isActive)
+ return tc;
+ }
+
+ return 0;
+}
+
+void Toolbar::setStyle (const ToolbarItemStyle& newStyle)
+{
+ if (toolbarStyle != newStyle)
+ {
+ toolbarStyle = newStyle;
+ updateAllItemPositions (false);
+ }
+}
+
+const String Toolbar::toString() const
+{
+ String s (T("TB:"));
+
+ for (int i = 0; i < getNumItems(); ++i)
+ s << getItemId(i) << T(' ');
+
+ return s.trimEnd();
+}
+
+bool Toolbar::restoreFromString (ToolbarItemFactory& factoryToUse,
+ const String& savedVersion)
+{
+ if (! savedVersion.startsWith (T("TB:")))
+ return false;
+
+ StringArray tokens;
+ tokens.addTokens (savedVersion.substring (3), false);
+
+ clear();
+
+ for (int i = 0; i < tokens.size(); ++i)
+ addItemInternal (factoryToUse, tokens[i].getIntValue(), -1);
+
+ resized();
+ return true;
+}
+
+void Toolbar::paint (Graphics& g)
+{
+ getLookAndFeel().paintToolbarBackground (g, getWidth(), getHeight(), *this);
+}
+
+int Toolbar::getThickness() const throw()
+{
+ return vertical ? getWidth() : getHeight();
+}
+
+int Toolbar::getLength() const throw()
+{
+ return vertical ? getHeight() : getWidth();
+}
+
+void Toolbar::setEditingActive (const bool active)
+{
+ if (isEditingActive != active)
+ {
+ isEditingActive = active;
+ updateAllItemPositions (false);
+ }
+}
+
+void Toolbar::resized()
+{
+ updateAllItemPositions (false);
+}
+
+void Toolbar::updateAllItemPositions (const bool animate)
+{
+ if (getWidth() > 0 && getHeight() > 0)
+ {
+ StretchableObjectResizer resizer;
+
+ const int numComponents = getNumChildComponents();
+ Array activeComps;
+
+ int i;
+ for (i = 0; i < numComponents; ++i)
+ {
+ ToolbarItemComponent* const tc = dynamic_cast (getChildComponent (i));
+
+ // have you added a component directly to the toolbar? That's not advisable! Only use addCustomToolbarItem()!
+ jassert (tc != 0 || getChildComponent(i) == missingItemsButton);
+
+ if (tc != 0)
+ {
+ tc->setEditingMode (isEditingActive ? ToolbarItemComponent::editableOnToolbar
+ : ToolbarItemComponent::normalMode);
+
+ tc->setStyle (toolbarStyle);
+
+ ToolbarSpacerComp* const spacer = dynamic_cast (tc);
+
+ int preferredSize = 1, minSize = 1, maxSize = 1;
+
+ if (tc->getToolbarItemSizes (getThickness(), isVertical(),
+ preferredSize, minSize, maxSize))
+ {
+ tc->isActive = true;
+ resizer.addItem (preferredSize, minSize, maxSize,
+ spacer != 0 ? spacer->getResizeOrder() : 2);
+ }
+ else
+ {
+ tc->isActive = false;
+ tc->setVisible (false);
+ }
+ }
+ }
+
+ resizer.resizeToFit (getLength());
+
+ int totalLength = 0;
+
+ for (i = 0; i < resizer.getNumItems(); ++i)
+ totalLength += (int) resizer.getItemSize (i);
+
+ const bool itemsOffTheEnd = totalLength > getLength();
+
+ const int extrasButtonSize = getThickness() / 2;
+ missingItemsButton->setSize (extrasButtonSize, extrasButtonSize);
+ missingItemsButton->setVisible (itemsOffTheEnd);
+ missingItemsButton->setEnabled (! isEditingActive);
+
+ if (vertical)
+ missingItemsButton->setCentrePosition (getWidth() / 2,
+ getHeight() - 4 - extrasButtonSize / 2);
+ else
+ missingItemsButton->setCentrePosition (getWidth() - 4 - extrasButtonSize / 2,
+ getHeight() / 2);
+
+ const int maxLength = itemsOffTheEnd ? (vertical ? missingItemsButton->getY()
+ : missingItemsButton->getX()) - 4
+ : getLength();
+
+ int pos = 0, activeIndex = 0;
+ for (i = 0; i < getNumChildComponents(); ++i)
+ {
+ ToolbarItemComponent* const tc = dynamic_cast (getChildComponent (i));
+
+ if (tc != 0 && tc->isActive)
+ {
+ const int size = (int) resizer.getItemSize (activeIndex++);
+
+ Rectangle newBounds;
+ if (vertical)
+ newBounds.setBounds (0, pos, getWidth(), size);
+ else
+ newBounds.setBounds (pos, 0, size, getHeight());
+
+ if (animate)
+ {
+ animator.animateComponent (tc, newBounds, 200, 3.0, 0.0);
+ }
+ else
+ {
+ animator.cancelAnimation (tc, false);
+ tc->setBounds (newBounds);
+ }
+
+ pos += size;
+ tc->setVisible (pos <= maxLength
+ && ((! tc->isBeingDragged)
+ || tc->getEditingMode() == ToolbarItemComponent::editableOnPalette));
+ }
+ }
+ }
+}
+
+void Toolbar::buttonClicked (Button*)
+{
+ jassert (missingItemsButton->isShowing());
+
+ if (missingItemsButton->isShowing())
+ {
+ PopupMenu m;
+ m.addCustomItem (1, new MissingItemsComponent (*this, getThickness()));
+ m.showAt (missingItemsButton);
+ }
+}
+
+bool Toolbar::isInterestedInDragSource (const String& sourceDescription,
+ Component* /*sourceComponent*/)
+{
+ return sourceDescription == toolbarDragDescriptor && isEditingActive;
+}
+
+void Toolbar::itemDragMove (const String&, Component* sourceComponent, int x, int y)
+{
+ ToolbarItemComponent* const tc = dynamic_cast (sourceComponent);
+
+ if (tc != 0)
+ {
+ if (getNumItems() == 0)
+ {
+ if (tc->getEditingMode() == ToolbarItemComponent::editableOnPalette)
+ {
+ ToolbarItemPalette* const palette = tc->findParentComponentOfClass ((ToolbarItemPalette*) 0);
+
+ if (palette != 0)
+ palette->replaceComponent (tc);
+ }
+ else
+ {
+ jassert (tc->getEditingMode() == ToolbarItemComponent::editableOnToolbar);
+ }
+
+ addChildComponent (tc);
+ updateAllItemPositions (false);
+ }
+ else
+ {
+ for (int i = getNumItems(); --i >= 0;)
+ {
+ int currentIndex = getIndexOfChildComponent (tc);
+
+ if (currentIndex < 0)
+ {
+ if (tc->getEditingMode() == ToolbarItemComponent::editableOnPalette)
+ {
+ ToolbarItemPalette* const palette = tc->findParentComponentOfClass ((ToolbarItemPalette*) 0);
+
+ if (palette != 0)
+ palette->replaceComponent (tc);
+ }
+ else
+ {
+ jassert (tc->getEditingMode() == ToolbarItemComponent::editableOnToolbar);
+ }
+
+ addChildComponent (tc);
+ currentIndex = getIndexOfChildComponent (tc);
+ updateAllItemPositions (true);
+ }
+
+ int newIndex = currentIndex;
+
+ const int dragObjectLeft = vertical ? (y - tc->dragOffsetY) : (x - tc->dragOffsetX);
+ const int dragObjectRight = dragObjectLeft + (vertical ? tc->getHeight() : tc->getWidth());
+
+ const Rectangle current (animator.getComponentDestination (getChildComponent (newIndex)));
+ ToolbarItemComponent* const prev = getNextActiveComponent (newIndex, -1);
+
+ if (prev != 0)
+ {
+ const Rectangle previousPos (animator.getComponentDestination (prev));
+
+ if (abs (dragObjectLeft - (vertical ? previousPos.getY() : previousPos.getX())
+ < abs (dragObjectRight - (vertical ? current.getBottom() : current.getRight()))))
+ {
+ newIndex = getIndexOfChildComponent (prev);
+ }
+ }
+
+ ToolbarItemComponent* const next = getNextActiveComponent (newIndex, 1);
+ if (next != 0)
+ {
+ const Rectangle nextPos (animator.getComponentDestination (next));
+
+ if (abs (dragObjectLeft - (vertical ? current.getY() : current.getX())
+ > abs (dragObjectRight - (vertical ? nextPos.getBottom() : nextPos.getRight()))))
+ {
+ newIndex = getIndexOfChildComponent (next) + 1;
+ }
+ }
+
+ if (newIndex != currentIndex)
+ {
+ removeChildComponent (tc);
+ addChildComponent (tc, newIndex);
+ updateAllItemPositions (true);
+ }
+ else
+ {
+ break;
+ }
+ }
+ }
+ }
+}
+
+void Toolbar::itemDragExit (const String&, Component* sourceComponent)
+{
+ ToolbarItemComponent* const tc = dynamic_cast (sourceComponent);
+
+ if (tc != 0)
+ {
+ if (isParentOf (tc))
+ {
+ removeChildComponent (tc);
+ updateAllItemPositions (true);
+ }
+ }
+}
+
+void Toolbar::itemDropped (const String&, Component*, int, int)
+{
+}
+
+void Toolbar::mouseDown (const MouseEvent& e)
+{
+ if (e.mods.isPopupMenu())
+ {
+ }
+}
+
+class ToolbarCustomisationDialog : public DialogWindow
+{
+public:
+ ToolbarCustomisationDialog (ToolbarItemFactory& factory,
+ Toolbar* const toolbar_,
+ const int optionFlags)
+ : DialogWindow (TRANS("Add/remove items from toolbar"), Colours::white, true, true),
+ toolbar (toolbar_)
+ {
+ setContentComponent (new CustomiserPanel (factory, toolbar, optionFlags), true, true);
+ setResizable (true, true);
+ setResizeLimits (400, 300, 1500, 1000);
+ positionNearBar();
+ }
+
+ ~ToolbarCustomisationDialog()
+ {
+ setContentComponent (0, true);
+ }
+
+ void closeButtonPressed()
+ {
+ setVisible (false);
+ }
+
+ bool canModalEventBeSentToComponent (const Component* comp)
+ {
+ return toolbar->isParentOf (comp);
+ }
+
+ void positionNearBar()
+ {
+ const Rectangle screenSize (toolbar->getParentMonitorArea());
+ const int tbx = toolbar->getScreenX();
+ const int tby = toolbar->getScreenY();
+ const int gap = 8;
+
+ int x, y;
+
+ if (toolbar->isVertical())
+ {
+ y = tby;
+
+ if (tbx > screenSize.getCentreX())
+ x = tbx - getWidth() - gap;
+ else
+ x = tbx + toolbar->getWidth() + gap;
+ }
+ else
+ {
+ x = tbx + (toolbar->getWidth() - getWidth()) / 2;
+
+ if (tby > screenSize.getCentreY())
+ y = tby - getHeight() - gap;
+ else
+ y = tby + toolbar->getHeight() + gap;
+ }
+
+ setTopLeftPosition (x, y);
+ }
+
+private:
+ Toolbar* const toolbar;
+
+ class CustomiserPanel : public Component,
+ private ComboBoxListener,
+ private ButtonListener
+ {
+ public:
+ CustomiserPanel (ToolbarItemFactory& factory_,
+ Toolbar* const toolbar_,
+ const int optionFlags)
+ : factory (factory_),
+ toolbar (toolbar_),
+ styleBox (0),
+ defaultButton (0)
+ {
+ addAndMakeVisible (palette = new ToolbarItemPalette (factory, toolbar));
+
+ if ((optionFlags & (Toolbar::allowIconsOnlyChoice
+ | Toolbar::allowIconsWithTextChoice
+ | Toolbar::allowTextOnlyChoice)) != 0)
+ {
+ addAndMakeVisible (styleBox = new ComboBox (String::empty));
+ styleBox->setEditableText (false);
+
+ if ((optionFlags & Toolbar::allowIconsOnlyChoice) != 0)
+ styleBox->addItem (TRANS("Show icons only"), 1);
+ if ((optionFlags & Toolbar::allowIconsWithTextChoice) != 0)
+ styleBox->addItem (TRANS("Show icons and descriptions"), 2);
+ if ((optionFlags & Toolbar::allowTextOnlyChoice) != 0)
+ styleBox->addItem (TRANS("Show descriptions only"), 3);
+
+ if (toolbar_->getStyle() == Toolbar::iconsOnly)
+ styleBox->setSelectedId (1);
+ else if (toolbar_->getStyle() == Toolbar::iconsWithText)
+ styleBox->setSelectedId (2);
+ else if (toolbar_->getStyle() == Toolbar::textOnly)
+ styleBox->setSelectedId (3);
+
+ styleBox->addListener (this);
+ }
+
+ if ((optionFlags & Toolbar::showResetToDefaultsButton) != 0)
+ {
+ addAndMakeVisible (defaultButton = new TextButton (TRANS ("Restore to default set of items")));
+ defaultButton->addButtonListener (this);
+ }
+
+ addAndMakeVisible (instructions = new Label (String::empty,
+ TRANS ("You can drag the items above and drop them onto a toolbar to add them.\n\nItems on the toolbar can also be dragged around to change their order, or dragged off the edge to delete them.")));
+ instructions->setFont (Font (13.0f));
+
+ setSize (500, 300);
+ }
+
+ ~CustomiserPanel()
+ {
+ deleteAllChildren();
+ }
+
+ void comboBoxChanged (ComboBox*)
+ {
+ if (styleBox->getSelectedId() == 1)
+ toolbar->setStyle (Toolbar::iconsOnly);
+ else if (styleBox->getSelectedId() == 2)
+ toolbar->setStyle (Toolbar::iconsWithText);
+ else if (styleBox->getSelectedId() == 3)
+ toolbar->setStyle (Toolbar::textOnly);
+
+ palette->resized(); // to make it update the styles
+ }
+
+ void buttonClicked (Button*)
+ {
+ toolbar->addDefaultItems (factory);
+ }
+
+ void paint (Graphics& g)
+ {
+ Colour background;
+
+ DialogWindow* const dw = findParentComponentOfClass ((DialogWindow*) 0);
+
+ if (dw != 0)
+ background = dw->getBackgroundColour();
+
+ g.setColour (background.contrasting().withAlpha (0.3f));
+ g.fillRect (palette->getX(), palette->getBottom() - 1, palette->getWidth(), 1);
+ }
+
+ void resized()
+ {
+ palette->setBounds (0, 0, getWidth(), getHeight() - 120);
+
+ if (styleBox != 0)
+ styleBox->setBounds (10, getHeight() - 110, 200, 22);
+
+ if (defaultButton != 0)
+ {
+ defaultButton->changeWidthToFitText (22);
+ defaultButton->setTopLeftPosition (240, getHeight() - 110);
+ }
+
+ instructions->setBounds (10, getHeight() - 80, getWidth() - 20, 80);
+ }
+
+ private:
+ ToolbarItemFactory& factory;
+ Toolbar* const toolbar;
+
+ Label* instructions;
+ ToolbarItemPalette* palette;
+ ComboBox* styleBox;
+ TextButton* defaultButton;
+ };
+};
+
+void Toolbar::showCustomisationDialog (ToolbarItemFactory& factory, const int optionFlags)
+{
+ setEditingActive (true);
+
+ ToolbarCustomisationDialog dw (factory, this, optionFlags);
+ dw.runModalLoop();
+
+ jassert (isValidComponent()); // ? deleting the toolbar while it's being edited?
+ setEditingActive (false);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_Toolbar.cpp *********/
+
+/********* Start of inlined file: juce_ToolbarItemComponent.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ToolbarItemFactory::ToolbarItemFactory()
+{
+}
+
+ToolbarItemFactory::~ToolbarItemFactory()
+{
+}
+
+class ItemDragAndDropOverlayComponent : public Component
+{
+public:
+ ItemDragAndDropOverlayComponent()
+ : isDragging (false)
+ {
+ setAlwaysOnTop (true);
+ setRepaintsOnMouseActivity (true);
+ setMouseCursor (MouseCursor::DraggingHandCursor);
+ }
+
+ ~ItemDragAndDropOverlayComponent()
+ {
+ }
+
+ void paint (Graphics& g)
+ {
+ ToolbarItemComponent* const tc = dynamic_cast (getParentComponent());
+
+ if (isMouseOverOrDragging()
+ && tc != 0
+ && tc->getEditingMode() == ToolbarItemComponent::editableOnToolbar)
+ {
+ g.setColour (findColour (Toolbar::editingModeOutlineColourId, true));
+ g.drawRect (0, 0, getWidth(), getHeight(),
+ jmin (2, (getWidth() - 1) / 2, (getHeight() - 1) / 2));
+ }
+ }
+
+ void mouseDown (const MouseEvent& e)
+ {
+ isDragging = false;
+ ToolbarItemComponent* const tc = dynamic_cast (getParentComponent());
+
+ if (tc != 0)
+ {
+ tc->dragOffsetX = e.x;
+ tc->dragOffsetY = e.y;
+ }
+ }
+
+ void mouseDrag (const MouseEvent& e)
+ {
+ if (! (isDragging || e.mouseWasClicked()))
+ {
+ isDragging = true;
+ DragAndDropContainer* const dnd = DragAndDropContainer::findParentDragContainerFor (this);
+
+ if (dnd != 0)
+ {
+ dnd->startDragging (Toolbar::toolbarDragDescriptor, getParentComponent(), 0, true);
+
+ ToolbarItemComponent* const tc = dynamic_cast (getParentComponent());
+
+ if (tc != 0)
+ {
+ tc->isBeingDragged = true;
+
+ if (tc->getEditingMode() == ToolbarItemComponent::editableOnToolbar)
+ tc->setVisible (false);
+ }
+ }
+ }
+ }
+
+ void mouseUp (const MouseEvent&)
+ {
+ isDragging = false;
+ ToolbarItemComponent* const tc = dynamic_cast (getParentComponent());
+
+ if (tc != 0)
+ {
+ tc->isBeingDragged = false;
+
+ Toolbar* const tb = tc->getToolbar();
+
+ if (tb != 0)
+ tb->updateAllItemPositions (true);
+ else if (tc->getEditingMode() == ToolbarItemComponent::editableOnToolbar)
+ delete tc;
+ }
+ }
+
+ void parentSizeChanged()
+ {
+ setBounds (0, 0, getParentWidth(), getParentHeight());
+ }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ bool isDragging;
+
+ ItemDragAndDropOverlayComponent (const ItemDragAndDropOverlayComponent&);
+ const ItemDragAndDropOverlayComponent& operator= (const ItemDragAndDropOverlayComponent&);
+};
+
+ToolbarItemComponent::ToolbarItemComponent (const int itemId_,
+ const String& labelText,
+ const bool isBeingUsedAsAButton_)
+ : Button (labelText),
+ itemId (itemId_),
+ mode (normalMode),
+ toolbarStyle (Toolbar::iconsOnly),
+ overlayComp (0),
+ dragOffsetX (0),
+ dragOffsetY (0),
+ isActive (true),
+ isBeingDragged (false),
+ isBeingUsedAsAButton (isBeingUsedAsAButton_)
+{
+ // Your item ID can't be 0!
+ jassert (itemId_ != 0);
+}
+
+ToolbarItemComponent::~ToolbarItemComponent()
+{
+ jassert (overlayComp == 0 || overlayComp->isValidComponent());
+ delete overlayComp;
+}
+
+Toolbar* ToolbarItemComponent::getToolbar() const
+{
+ return dynamic_cast (getParentComponent());
+}
+
+bool ToolbarItemComponent::isToolbarVertical() const
+{
+ const Toolbar* const t = getToolbar();
+ return t != 0 && t->isVertical();
+}
+
+void ToolbarItemComponent::setStyle (const Toolbar::ToolbarItemStyle& newStyle)
+{
+ if (toolbarStyle != newStyle)
+ {
+ toolbarStyle = newStyle;
+ repaint();
+ resized();
+ }
+}
+
+void ToolbarItemComponent::paintButton (Graphics& g, bool isMouseOver, bool isMouseDown)
+{
+ if (isBeingUsedAsAButton)
+ getLookAndFeel().paintToolbarButtonBackground (g, getWidth(), getHeight(),
+ isMouseOver, isMouseDown, *this);
+
+ if (toolbarStyle != Toolbar::iconsOnly)
+ {
+ const int indent = contentArea.getX();
+ int y = indent;
+ int h = getHeight() - indent * 2;
+
+ if (toolbarStyle == Toolbar::iconsWithText)
+ {
+ y = contentArea.getBottom() + indent / 2;
+ h -= contentArea.getHeight();
+ }
+
+ getLookAndFeel().paintToolbarButtonLabel (g, indent, y, getWidth() - indent * 2, h,
+ getButtonText(), *this);
+ }
+
+ if (! contentArea.isEmpty())
+ {
+ g.saveState();
+ g.setOrigin (contentArea.getX(), contentArea.getY());
+ g.reduceClipRegion (0, 0, contentArea.getWidth(), contentArea.getHeight());
+
+ paintButtonArea (g, contentArea.getWidth(), contentArea.getHeight(), isMouseOver, isMouseDown);
+
+ g.restoreState();
+ }
+}
+
+void ToolbarItemComponent::resized()
+{
+ if (toolbarStyle != Toolbar::textOnly)
+ {
+ const int indent = jmin (proportionOfWidth (0.08f),
+ proportionOfHeight (0.08f));
+
+ contentArea = Rectangle (indent, indent,
+ getWidth() - indent * 2,
+ toolbarStyle == Toolbar::iconsWithText ? proportionOfHeight (0.55f)
+ : (getHeight() - indent * 2));
+ }
+ else
+ {
+ contentArea = Rectangle();
+ }
+
+ contentAreaChanged (contentArea);
+}
+
+void ToolbarItemComponent::setEditingMode (const ToolbarEditingMode newMode)
+{
+ if (mode != newMode)
+ {
+ mode = newMode;
+ repaint();
+
+ if (mode == normalMode)
+ {
+ jassert (overlayComp == 0 || overlayComp->isValidComponent());
+ delete overlayComp;
+ overlayComp = 0;
+ }
+ else if (overlayComp == 0)
+ {
+ addAndMakeVisible (overlayComp = new ItemDragAndDropOverlayComponent());
+ overlayComp->parentSizeChanged();
+ }
+
+ resized();
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ToolbarItemComponent.cpp *********/
+
+/********* Start of inlined file: juce_ToolbarItemPalette.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ToolbarItemPalette::ToolbarItemPalette (ToolbarItemFactory& factory_,
+ Toolbar* const toolbar_)
+ : factory (factory_),
+ toolbar (toolbar_)
+{
+ Component* const itemHolder = new Component();
+
+ Array allIds;
+ factory_.getAllToolbarItemIds (allIds);
+
+ for (int i = 0; i < allIds.size(); ++i)
+ {
+ ToolbarItemComponent* const tc = Toolbar::createItem (factory_, allIds.getUnchecked (i));
+
+ jassert (tc != 0);
+ if (tc != 0)
+ {
+ itemHolder->addAndMakeVisible (tc);
+ tc->setEditingMode (ToolbarItemComponent::editableOnPalette);
+ }
+ }
+
+ viewport = new Viewport();
+ viewport->setViewedComponent (itemHolder);
+ addAndMakeVisible (viewport);
+}
+
+ToolbarItemPalette::~ToolbarItemPalette()
+{
+ viewport->getViewedComponent()->deleteAllChildren();
+ deleteAllChildren();
+}
+
+void ToolbarItemPalette::resized()
+{
+ viewport->setBoundsInset (BorderSize (1));
+
+ Component* const itemHolder = viewport->getViewedComponent();
+
+ const int indent = 8;
+ const int preferredWidth = viewport->getWidth() - viewport->getScrollBarThickness() - indent;
+ const int height = toolbar->getThickness();
+ int x = indent;
+ int y = indent;
+ int maxX = 0;
+
+ for (int i = 0; i < itemHolder->getNumChildComponents(); ++i)
+ {
+ ToolbarItemComponent* const tc = dynamic_cast (itemHolder->getChildComponent (i));
+
+ if (tc != 0)
+ {
+ tc->setStyle (toolbar->getStyle());
+
+ int preferredSize = 1, minSize = 1, maxSize = 1;
+
+ if (tc->getToolbarItemSizes (height, false, preferredSize, minSize, maxSize))
+ {
+ if (x + preferredSize > preferredWidth && x > indent)
+ {
+ x = indent;
+ y += height;
+ }
+
+ tc->setBounds (x, y, preferredSize, height);
+
+ x += preferredSize + 8;
+ maxX = jmax (maxX, x);
+ }
+ }
+ }
+
+ itemHolder->setSize (maxX, y + height + 8);
+}
+
+void ToolbarItemPalette::replaceComponent (ToolbarItemComponent* const comp)
+{
+ ToolbarItemComponent* const tc = Toolbar::createItem (factory, comp->getItemId());
+
+ jassert (tc != 0);
+
+ if (tc != 0)
+ {
+ tc->setBounds (comp->getBounds());
+ tc->setStyle (toolbar->getStyle());
+ tc->setEditingMode (comp->getEditingMode());
+ viewport->getViewedComponent()->addAndMakeVisible (tc, getIndexOfChildComponent (comp));
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ToolbarItemPalette.cpp *********/
+
+/********* Start of inlined file: juce_TreeView.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+class TreeViewContentComponent : public Component
+{
+public:
+ TreeViewContentComponent (TreeView* const owner_)
+ : owner (owner_),
+ isDragging (false)
+ {
+ }
+
+ ~TreeViewContentComponent()
+ {
+ deleteAllChildren();
+ }
+
+ void mouseDown (const MouseEvent& e)
+ {
+ isDragging = false;
+ needSelectionOnMouseUp = false;
+
+ Rectangle pos;
+ TreeViewItem* const item = findItemAt (e.y, pos);
+
+ if (item != 0 && e.x >= pos.getX())
+ {
+ if (! owner->isMultiSelectEnabled())
+ item->setSelected (true, true);
+ else if (item->isSelected())
+ needSelectionOnMouseUp = ! e.mods.isPopupMenu();
+ else
+ selectBasedOnModifiers (item, e.mods);
+
+ MouseEvent e2 (e);
+ e2.x -= pos.getX();
+ e2.y -= pos.getY();
+ item->itemClicked (e2);
+ }
+ }
+
+ void mouseUp (const MouseEvent& e)
+ {
+ Rectangle pos;
+ TreeViewItem* const item = findItemAt (e.y, pos);
+
+ if (item != 0 && e.mouseWasClicked())
+ {
+ if (needSelectionOnMouseUp)
+ {
+ selectBasedOnModifiers (item, e.mods);
+ }
+ else if (e.mouseWasClicked())
+ {
+ if (e.x >= pos.getX() - owner->getIndentSize()
+ && e.x < pos.getX())
+ {
+ item->setOpen (! item->isOpen());
+ }
+ }
+ }
+ }
+
+ void mouseDoubleClick (const MouseEvent& e)
+ {
+ if (e.getNumberOfClicks() != 3) // ignore triple clicks
+ {
+ Rectangle pos;
+ TreeViewItem* const item = findItemAt (e.y, pos);
+
+ if (item != 0 && e.x >= pos.getX())
+ {
+ MouseEvent e2 (e);
+ e2.x -= pos.getX();
+ e2.y -= pos.getY();
+ item->itemDoubleClicked (e2);
+ }
+ }
+ }
+
+ void mouseDrag (const MouseEvent& e)
+ {
+ if (isEnabled() && ! (e.mouseWasClicked() || isDragging))
+ {
+ isDragging = true;
+
+ Rectangle pos;
+ TreeViewItem* const item = findItemAt (e.getMouseDownY(), pos);
+
+ if (item != 0 && e.getMouseDownX() >= pos.getX())
+ {
+ const String dragDescription (item->getDragSourceDescription());
+
+ if (dragDescription.isNotEmpty())
+ {
+ DragAndDropContainer* const dragContainer
+ = DragAndDropContainer::findParentDragContainerFor (this);
+
+ if (dragContainer != 0)
+ {
+ pos.setSize (pos.getWidth(), item->itemHeight);
+ Image* dragImage = Component::createComponentSnapshot (pos, true);
+ dragImage->multiplyAllAlphas (0.6f);
+
+ dragContainer->startDragging (dragDescription, owner, dragImage, true);
+ }
+ else
+ {
+ // to be able to do a drag-and-drop operation, the treeview needs to
+ // be inside a component which is also a DragAndDropContainer.
+ jassertfalse
+ }
+ }
+ }
+ }
+ }
+
+ void paint (Graphics& g);
+ TreeViewItem* findItemAt (int y, Rectangle& itemPosition) const;
+
+ void updateComponents()
+ {
+ int xAdjust = 0, yAdjust = 0;
+
+ if ((! owner->rootItemVisible) && owner->rootItem != 0)
+ {
+ yAdjust = owner->rootItem->itemHeight;
+ xAdjust = owner->getIndentSize();
+ }
+
+ const int visibleTop = -getY();
+ const int visibleBottom = visibleTop + getParentHeight();
+
+ BitArray itemsToKeep;
+ TreeViewItem* item = owner->rootItem;
+ int y = -yAdjust;
+
+ while (item != 0 && y < visibleBottom)
+ {
+ y += item->itemHeight;
+
+ if (y >= visibleTop)
+ {
+ const int index = rowComponentIds.indexOf (item->uid);
+
+ if (index < 0)
+ {
+ Component* const comp = item->createItemComponent();
+
+ if (comp != 0)
+ {
+ addAndMakeVisible (comp);
+ itemsToKeep.setBit (rowComponentItems.size());
+ rowComponentItems.add (item);
+ rowComponentIds.add (item->uid);
+ rowComponents.add (comp);
+ }
+ }
+ else
+ {
+ itemsToKeep.setBit (index);
+ }
+ }
+
+ item = item->getNextVisibleItem (true);
+ }
+
+ for (int i = rowComponentItems.size(); --i >= 0;)
+ {
+ Component* const comp = (Component*) (rowComponents.getUnchecked(i));
+
+ bool keep = false;
+
+ if ((itemsToKeep[i] || (comp == Component::getComponentUnderMouse() && comp->isMouseButtonDown()))
+ && isParentOf (comp))
+ {
+ if (itemsToKeep[i])
+ {
+ const TreeViewItem* const item = (TreeViewItem*) rowComponentItems.getUnchecked(i);
+
+ Rectangle pos (item->getItemPosition (false));
+ pos.translate (-xAdjust, -yAdjust);
+ pos.setSize (pos.getWidth() + xAdjust, item->itemHeight);
+
+ if (pos.getBottom() >= visibleTop && pos.getY() < visibleBottom)
+ {
+ keep = true;
+ comp->setBounds (pos);
+ }
+ }
+ else
+ {
+ comp->setSize (0, 0);
+ }
+ }
+
+ if (! keep)
+ {
+ delete comp;
+ rowComponents.remove (i);
+ rowComponentIds.remove (i);
+ rowComponentItems.remove (i);
+ }
+ }
+ }
+
+ void resized()
+ {
+ owner->itemsChanged();
+ }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ TreeView* const owner;
+
+ VoidArray rowComponentItems;
+ Array rowComponentIds;
+ VoidArray rowComponents;
+ bool isDragging, needSelectionOnMouseUp;
+
+ TreeViewContentComponent (const TreeViewContentComponent&);
+ const TreeViewContentComponent& operator= (const TreeViewContentComponent&);
+
+ void selectBasedOnModifiers (TreeViewItem* const item, const ModifierKeys& modifiers)
+ {
+ TreeViewItem* firstSelected = 0;
+
+ if (modifiers.isShiftDown() && ((firstSelected = owner->getSelectedItem (0)) != 0))
+ {
+ TreeViewItem* const lastSelected = owner->getSelectedItem (owner->getNumSelectedItems() - 1);
+ jassert (lastSelected != 0);
+
+ int rowStart = firstSelected->getRowNumberInTree();
+ int rowEnd = lastSelected->getRowNumberInTree();
+ if (rowStart > rowEnd)
+ swapVariables (rowStart, rowEnd);
+
+ int ourRow = item->getRowNumberInTree();
+ int otherEnd = ourRow < rowEnd ? rowStart : rowEnd;
+
+ if (ourRow > otherEnd)
+ swapVariables (ourRow, otherEnd);
+
+ for (int i = ourRow; i <= otherEnd; ++i)
+ owner->getItemOnRow (i)->setSelected (true, false);
+ }
+ else
+ {
+ const bool cmd = modifiers.isCommandDown();
+
+ item->setSelected ((! cmd) || (! item->isSelected()), ! cmd);
+ }
+ }
+};
+
+class TreeViewport : public Viewport
+{
+public:
+ TreeViewport() throw() {}
+ ~TreeViewport() throw() {}
+
+ void updateComponents()
+ {
+ if (getViewedComponent() != 0)
+ ((TreeViewContentComponent*) getViewedComponent())->updateComponents();
+
+ repaint();
+ }
+
+ void visibleAreaChanged (int, int, int, int)
+ {
+ updateComponents();
+ }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ TreeViewport (const TreeViewport&);
+ const TreeViewport& operator= (const TreeViewport&);
+};
+
+TreeView::TreeView (const String& componentName)
+ : Component (componentName),
+ rootItem (0),
+ indentSize (24),
+ defaultOpenness (false),
+ needsRecalculating (true),
+ rootItemVisible (true),
+ multiSelectEnabled (false)
+{
+ addAndMakeVisible (viewport = new TreeViewport());
+ viewport->setViewedComponent (new TreeViewContentComponent (this));
+ viewport->setWantsKeyboardFocus (false);
+ setWantsKeyboardFocus (true);
+}
+
+TreeView::~TreeView()
+{
+ if (rootItem != 0)
+ rootItem->setOwnerView (0);
+
+ deleteAllChildren();
+}
+
+void TreeView::setRootItem (TreeViewItem* const newRootItem)
+{
+ if (rootItem != newRootItem)
+ {
+ if (newRootItem != 0)
+ {
+ jassert (newRootItem->ownerView == 0); // can't use a tree item in more than one tree at once..
+
+ if (newRootItem->ownerView != 0)
+ newRootItem->ownerView->setRootItem (0);
+ }
+
+ if (rootItem != 0)
+ rootItem->setOwnerView (0);
+
+ rootItem = newRootItem;
+
+ if (newRootItem != 0)
+ newRootItem->setOwnerView (this);
+
+ needsRecalculating = true;
+ handleAsyncUpdate();
+
+ if (rootItem != 0 && (defaultOpenness || ! rootItemVisible))
+ {
+ rootItem->setOpen (false); // force a re-open
+ rootItem->setOpen (true);
+ }
+ }
+}
+
+void TreeView::setRootItemVisible (const bool shouldBeVisible)
+{
+ rootItemVisible = shouldBeVisible;
+
+ if (rootItem != 0 && (defaultOpenness || ! rootItemVisible))
+ {
+ rootItem->setOpen (false); // force a re-open
+ rootItem->setOpen (true);
+ }
+
+ itemsChanged();
+}
+
+void TreeView::colourChanged()
+{
+ setOpaque (findColour (backgroundColourId).isOpaque());
+ repaint();
+}
+
+void TreeView::setIndentSize (const int newIndentSize)
+{
+ if (indentSize != newIndentSize)
+ {
+ indentSize = newIndentSize;
+ resized();
+ }
+}
+
+void TreeView::setDefaultOpenness (const bool isOpenByDefault)
+{
+ if (defaultOpenness != isOpenByDefault)
+ {
+ defaultOpenness = isOpenByDefault;
+ itemsChanged();
+ }
+}
+
+void TreeView::setMultiSelectEnabled (const bool canMultiSelect)
+{
+ multiSelectEnabled = canMultiSelect;
+}
+
+void TreeView::clearSelectedItems()
+{
+ if (rootItem != 0)
+ rootItem->deselectAllRecursively();
+}
+
+int TreeView::getNumSelectedItems() const throw()
+{
+ return (rootItem != 0) ? rootItem->countSelectedItemsRecursively() : 0;
+}
+
+TreeViewItem* TreeView::getSelectedItem (const int index) const throw()
+{
+ return (rootItem != 0) ? rootItem->getSelectedItemWithIndex (index) : 0;
+}
+
+int TreeView::getNumRowsInTree() const
+{
+ if (rootItem != 0)
+ return rootItem->getNumRows() - (rootItemVisible ? 0 : 1);
+
+ return 0;
+}
+
+TreeViewItem* TreeView::getItemOnRow (int index) const
+{
+ if (! rootItemVisible)
+ ++index;
+
+ if (rootItem != 0 && index >= 0)
+ return rootItem->getItemOnRow (index);
+
+ return 0;
+}
+
+XmlElement* TreeView::getOpennessState (const bool alsoIncludeScrollPosition) const
+{
+ XmlElement* e = 0;
+
+ if (rootItem != 0)
+ {
+ e = rootItem->createXmlOpenness();
+
+ if (e != 0 && alsoIncludeScrollPosition)
+ e->setAttribute (T("scrollPos"), viewport->getViewPositionY());
+ }
+
+ return e;
+}
+
+void TreeView::restoreOpennessState (const XmlElement& newState)
+{
+ if (rootItem != 0)
+ {
+ rootItem->restoreFromXml (newState);
+
+ if (newState.hasAttribute (T("scrollPos")))
+ viewport->setViewPosition (viewport->getViewPositionX(),
+ newState.getIntAttribute (T("scrollPos")));
+ }
+}
+
+void TreeView::paint (Graphics& g)
+{
+ g.fillAll (findColour (backgroundColourId));
+}
+
+void TreeView::resized()
+{
+ viewport->setBounds (0, 0, getWidth(), getHeight());
+ itemsChanged();
+}
+
+void TreeView::moveSelectedRow (int delta)
+{
+ int rowSelected = 0;
+
+ TreeViewItem* const firstSelected = getSelectedItem (0);
+ if (firstSelected != 0)
+ rowSelected = firstSelected->getRowNumberInTree();
+
+ rowSelected = jlimit (0, getNumRowsInTree() - 1, rowSelected + delta);
+
+ TreeViewItem* item = getItemOnRow (rowSelected);
+
+ if (item != 0)
+ {
+ item->setSelected (true, true);
+
+ scrollToKeepItemVisible (item);
+ }
+}
+
+void TreeView::scrollToKeepItemVisible (TreeViewItem* item)
+{
+ if (item != 0 && item->ownerView == this)
+ {
+ handleAsyncUpdate();
+
+ item = item->getDeepestOpenParentItem();
+
+ int y = item->y;
+ if (! rootItemVisible)
+ y -= rootItem->itemHeight;
+
+ int viewTop = viewport->getViewPositionY();
+
+ if (y < viewTop)
+ {
+ viewport->setViewPosition (viewport->getViewPositionX(), y);
+ }
+ else if (y + item->itemHeight > viewTop + viewport->getViewHeight())
+ {
+ viewport->setViewPosition (viewport->getViewPositionX(),
+ (y + item->itemHeight) - viewport->getViewHeight());
+ }
+ }
+}
+
+bool TreeView::keyPressed (const KeyPress& key)
+{
+ if (key.isKeyCode (KeyPress::upKey))
+ {
+ moveSelectedRow (-1);
+ }
+ else if (key.isKeyCode (KeyPress::downKey))
+ {
+ moveSelectedRow (1);
+ }
+ else if (key.isKeyCode (KeyPress::pageDownKey) || key.isKeyCode (KeyPress::pageUpKey))
+ {
+ if (rootItem != 0)
+ {
+ int rowsOnScreen = getHeight() / jmax (1, rootItem->itemHeight);
+
+ if (key.isKeyCode (KeyPress::pageUpKey))
+ rowsOnScreen = -rowsOnScreen;
+
+ moveSelectedRow (rowsOnScreen);
+ }
+ }
+ else if (key.isKeyCode (KeyPress::homeKey))
+ {
+ moveSelectedRow (-0x3fffffff);
+ }
+ else if (key.isKeyCode (KeyPress::endKey))
+ {
+ moveSelectedRow (0x3fffffff);
+ }
+ else if (key.isKeyCode (KeyPress::returnKey))
+ {
+ TreeViewItem* const firstSelected = getSelectedItem (0);
+ if (firstSelected != 0)
+ firstSelected->setOpen (! firstSelected->isOpen());
+ }
+ else if (key.isKeyCode (KeyPress::leftKey))
+ {
+ TreeViewItem* const firstSelected = getSelectedItem (0);
+
+ if (firstSelected != 0)
+ {
+ if (firstSelected->isOpen())
+ {
+ firstSelected->setOpen (false);
+ }
+ else
+ {
+ TreeViewItem* parent = firstSelected->parentItem;
+
+ if ((! rootItemVisible) && parent == rootItem)
+ parent = 0;
+
+ if (parent != 0)
+ {
+ parent->setSelected (true, true);
+ scrollToKeepItemVisible (parent);
+ }
+ }
+ }
+ }
+ else if (key.isKeyCode (KeyPress::rightKey))
+ {
+ TreeViewItem* const firstSelected = getSelectedItem (0);
+
+ if (firstSelected != 0)
+ {
+ if (firstSelected->isOpen() || ! firstSelected->mightContainSubItems())
+ moveSelectedRow (1);
+ else
+ firstSelected->setOpen (true);
+ }
+ }
+ else
+ {
+ return false;
+ }
+
+ return true;
+}
+
+void TreeView::itemsChanged() throw()
+{
+ needsRecalculating = true;
+ repaint();
+ triggerAsyncUpdate();
+}
+
+void TreeView::handleAsyncUpdate()
+{
+ if (needsRecalculating)
+ {
+ needsRecalculating = false;
+
+ const ScopedLock sl (nodeAlterationLock);
+
+ if (rootItem != 0)
+ rootItem->updatePositions (0);
+
+ ((TreeViewport*) viewport)->updateComponents();
+
+ if (rootItem != 0)
+ {
+ viewport->getViewedComponent()
+ ->setSize (jmax (viewport->getMaximumVisibleWidth(), rootItem->totalWidth),
+ rootItem->totalHeight - (rootItemVisible ? 0 : rootItem->itemHeight));
+ }
+ else
+ {
+ viewport->getViewedComponent()->setSize (0, 0);
+ }
+ }
+}
+
+void TreeViewContentComponent::paint (Graphics& g)
+{
+ if (owner->rootItem != 0)
+ {
+ owner->handleAsyncUpdate();
+
+ int w = getWidth();
+
+ if (! owner->rootItemVisible)
+ {
+ const int indentWidth = owner->getIndentSize();
+
+ g.setOrigin (-indentWidth, -owner->rootItem->itemHeight);
+ w += indentWidth;
+ }
+
+ owner->rootItem->paintRecursively (g, w);
+ }
+}
+
+TreeViewItem* TreeViewContentComponent::findItemAt (int y, Rectangle& itemPosition) const
+{
+ if (owner->rootItem != 0)
+ {
+ owner->handleAsyncUpdate();
+
+ if (! owner->rootItemVisible)
+ y += owner->rootItem->itemHeight;
+
+ TreeViewItem* const ti = owner->rootItem->findItemRecursively (y);
+
+ if (ti != 0)
+ {
+ itemPosition = ti->getItemPosition (false);
+
+ if (! owner->rootItemVisible)
+ itemPosition.translate (-owner->getIndentSize(),
+ -owner->rootItem->itemHeight);
+ }
+
+ return ti;
+ }
+
+ return 0;
+}
+
+#define opennessDefault 0
+#define opennessClosed 1
+#define opennessOpen 2
+
+TreeViewItem::TreeViewItem()
+ : ownerView (0),
+ parentItem (0),
+ subItems (8),
+ y (0),
+ itemHeight (0),
+ totalHeight (0),
+ selected (false),
+ redrawNeeded (true),
+ drawLinesInside (true),
+ openness (opennessDefault)
+{
+ static int nextUID = 0;
+ uid = nextUID++;
+}
+
+TreeViewItem::~TreeViewItem()
+{
+}
+
+const String TreeViewItem::getUniqueName() const
+{
+ return String::empty;
+}
+
+void TreeViewItem::itemOpennessChanged (bool)
+{
+}
+
+int TreeViewItem::getNumSubItems() const throw()
+{
+ return subItems.size();
+}
+
+TreeViewItem* TreeViewItem::getSubItem (const int index) const throw()
+{
+ return subItems [index];
+}
+
+void TreeViewItem::clearSubItems()
+{
+ if (subItems.size() > 0)
+ {
+ if (ownerView != 0)
+ {
+ const ScopedLock sl (ownerView->nodeAlterationLock);
+ subItems.clear();
+ treeHasChanged();
+ }
+ else
+ {
+ subItems.clear();
+ }
+ }
+}
+
+void TreeViewItem::addSubItem (TreeViewItem* const newItem, const int insertPosition)
+{
+ if (newItem != 0)
+ {
+ newItem->parentItem = this;
+ newItem->setOwnerView (ownerView);
+ newItem->y = 0;
+ newItem->itemHeight = newItem->getItemHeight();
+ newItem->totalHeight = 0;
+ newItem->itemWidth = newItem->getItemWidth();
+ newItem->totalWidth = 0;
+
+ if (ownerView != 0)
+ {
+ const ScopedLock sl (ownerView->nodeAlterationLock);
+ subItems.insert (insertPosition, newItem);
+ treeHasChanged();
+
+ if (newItem->isOpen())
+ newItem->itemOpennessChanged (true);
+ }
+ else
+ {
+ subItems.insert (insertPosition, newItem);
+
+ if (newItem->isOpen())
+ newItem->itemOpennessChanged (true);
+ }
+ }
+}
+
+void TreeViewItem::removeSubItem (const int index, const bool deleteItem)
+{
+ if (ownerView != 0)
+ ownerView->nodeAlterationLock.enter();
+
+ if (((unsigned int) index) < (unsigned int) subItems.size())
+ {
+ subItems.remove (index, deleteItem);
+ treeHasChanged();
+ }
+
+ if (ownerView != 0)
+ ownerView->nodeAlterationLock.exit();
+}
+
+bool TreeViewItem::isOpen() const throw()
+{
+ if (openness == opennessDefault)
+ return ownerView != 0 && ownerView->defaultOpenness;
+ else
+ return openness == opennessOpen;
+}
+
+void TreeViewItem::setOpen (const bool shouldBeOpen)
+{
+ if (isOpen() != shouldBeOpen)
+ {
+ openness = shouldBeOpen ? opennessOpen
+ : opennessClosed;
+
+ treeHasChanged();
+
+ itemOpennessChanged (isOpen());
+ }
+}
+
+bool TreeViewItem::isSelected() const throw()
+{
+ return selected;
+}
+
+void TreeViewItem::deselectAllRecursively()
+{
+ setSelected (false, false);
+
+ for (int i = 0; i < subItems.size(); ++i)
+ subItems.getUnchecked(i)->deselectAllRecursively();
+}
+
+void TreeViewItem::setSelected (const bool shouldBeSelected,
+ const bool deselectOtherItemsFirst)
+{
+ if (deselectOtherItemsFirst)
+ getTopLevelItem()->deselectAllRecursively();
+
+ if (shouldBeSelected != selected)
+ {
+ selected = shouldBeSelected;
+ if (ownerView != 0)
+ ownerView->repaint();
+
+ itemSelectionChanged (shouldBeSelected);
+ }
+}
+
+void TreeViewItem::paintItem (Graphics&, int, int)
+{
+}
+
+void TreeViewItem::itemClicked (const MouseEvent&)
+{
+}
+
+void TreeViewItem::itemDoubleClicked (const MouseEvent&)
+{
+ if (mightContainSubItems())
+ setOpen (! isOpen());
+}
+
+void TreeViewItem::itemSelectionChanged (bool)
+{
+}
+
+const String TreeViewItem::getDragSourceDescription()
+{
+ return String::empty;
+}
+
+const Rectangle TreeViewItem::getItemPosition (const bool relativeToTreeViewTopLeft) const throw()
+{
+ const int indentX = getIndentX();
+
+ int width = itemWidth;
+
+ if (ownerView != 0 && width < 0)
+ width = ownerView->viewport->getViewWidth() - indentX;
+
+ Rectangle r (indentX, y, jmax (0, width), totalHeight);
+
+ if (relativeToTreeViewTopLeft)
+ r.setPosition (r.getX() - ownerView->viewport->getViewPositionX(),
+ r.getY() - ownerView->viewport->getViewPositionY());
+
+ return r;
+}
+
+void TreeViewItem::treeHasChanged() const throw()
+{
+ if (ownerView != 0)
+ ownerView->itemsChanged();
+}
+
+void TreeViewItem::updatePositions (int newY)
+{
+ y = newY;
+ itemHeight = getItemHeight();
+ totalHeight = itemHeight;
+ itemWidth = getItemWidth();
+ totalWidth = jmax (itemWidth, 0);
+
+ if (isOpen())
+ {
+ const int ourIndent = getIndentX();
+ newY += totalHeight;
+
+ for (int i = 0; i < subItems.size(); ++i)
+ {
+ TreeViewItem* const ti = subItems.getUnchecked(i);
+
+ ti->updatePositions (newY);
+ newY += ti->totalHeight;
+ totalHeight += ti->totalHeight;
+ totalWidth = jmax (totalWidth, ti->totalWidth + ourIndent);
+ }
+ }
+}
+
+TreeViewItem* TreeViewItem::getDeepestOpenParentItem() throw()
+{
+ TreeViewItem* result = this;
+ TreeViewItem* item = this;
+
+ while (item->parentItem != 0)
+ {
+ item = item->parentItem;
+
+ if (! item->isOpen())
+ result = item;
+ }
+
+ return result;
+}
+
+void TreeViewItem::setOwnerView (TreeView* const newOwner) throw()
+{
+ ownerView = newOwner;
+
+ for (int i = subItems.size(); --i >= 0;)
+ subItems.getUnchecked(i)->setOwnerView (newOwner);
+}
+
+int TreeViewItem::getIndentX() const throw()
+{
+ const int indentWidth = ownerView->getIndentSize();
+ int x = indentWidth;
+
+ TreeViewItem* p = parentItem;
+
+ while (p != 0)
+ {
+ x += indentWidth;
+ p = p->parentItem;
+ }
+
+ return x;
+}
+
+void TreeViewItem::paintRecursively (Graphics& g, int width)
+{
+ jassert (ownerView != 0);
+ if (ownerView == 0)
+ return;
+
+ const int indent = getIndentX();
+ const int itemW = itemWidth < 0 ? width - indent : itemWidth;
+
+ g.setColour (ownerView->findColour (TreeView::linesColourId));
+
+ const float halfH = itemHeight * 0.5f;
+ int depth = 0;
+ TreeViewItem* p = parentItem;
+
+ while (p != 0)
+ {
+ ++depth;
+ p = p->parentItem;
+ }
+
+ const int indentWidth = ownerView->getIndentSize();
+ float x = (depth + 0.5f) * indentWidth;
+
+ if (x > 0)
+ {
+ if (depth >= 0)
+ {
+ if (parentItem != 0 && parentItem->drawLinesInside)
+ g.drawLine (x, 0, x, isLastOfSiblings() ? halfH : (float) itemHeight);
+
+ if ((parentItem != 0 && parentItem->drawLinesInside)
+ || (parentItem == 0 && drawLinesInside))
+ g.drawLine (x, halfH, x + indentWidth / 2, halfH);
+ }
+
+ p = parentItem;
+ int d = depth;
+
+ while (p != 0 && --d >= 0)
+ {
+ x -= (float) indentWidth;
+
+ if ((p->parentItem == 0 || p->parentItem->drawLinesInside)
+ && ! p->isLastOfSiblings())
+ {
+ g.drawLine (x, 0, x, (float) itemHeight);
+ }
+
+ p = p->parentItem;
+ }
+
+ if (mightContainSubItems())
+ {
+ ownerView->getLookAndFeel()
+ .drawTreeviewPlusMinusBox (g,
+ depth * indentWidth, 0,
+ indentWidth, itemHeight,
+ ! isOpen());
+ }
+ }
+
+ {
+ g.saveState();
+ g.setOrigin (indent, 0);
+
+ if (g.reduceClipRegion (0, 0, itemW, itemHeight))
+ paintItem (g, itemW, itemHeight);
+
+ g.restoreState();
+ }
+
+ if (isOpen())
+ {
+ const Rectangle clip (g.getClipBounds());
+
+ for (int i = 0; i < subItems.size(); ++i)
+ {
+ TreeViewItem* const ti = subItems.getUnchecked(i);
+
+ const int relY = ti->y - y;
+
+ if (relY >= clip.getBottom())
+ break;
+
+ if (relY + ti->totalHeight >= clip.getY())
+ {
+ g.saveState();
+ g.setOrigin (0, relY);
+
+ if (g.reduceClipRegion (0, 0, width, ti->totalHeight))
+ ti->paintRecursively (g, width);
+
+ g.restoreState();
+ }
+ }
+ }
+}
+
+bool TreeViewItem::isLastOfSiblings() const throw()
+{
+ return parentItem == 0
+ || parentItem->subItems.getLast() == this;
+}
+
+TreeViewItem* TreeViewItem::getTopLevelItem() throw()
+{
+ return (parentItem == 0) ? this
+ : parentItem->getTopLevelItem();
+}
+
+int TreeViewItem::getNumRows() const throw()
+{
+ int num = 1;
+
+ if (isOpen())
+ {
+ for (int i = subItems.size(); --i >= 0;)
+ num += subItems.getUnchecked(i)->getNumRows();
+ }
+
+ return num;
+}
+
+TreeViewItem* TreeViewItem::getItemOnRow (int index) throw()
+{
+ if (index == 0)
+ return this;
+
+ if (index > 0 && isOpen())
+ {
+ --index;
+
+ for (int i = 0; i < subItems.size(); ++i)
+ {
+ TreeViewItem* const item = subItems.getUnchecked(i);
+
+ if (index == 0)
+ return item;
+
+ const int numRows = item->getNumRows();
+
+ if (numRows > index)
+ return item->getItemOnRow (index);
+
+ index -= numRows;
+ }
+ }
+
+ return 0;
+}
+
+TreeViewItem* TreeViewItem::findItemRecursively (int y) throw()
+{
+ if (((unsigned int) y) < (unsigned int) totalHeight)
+ {
+ const int h = itemHeight;
+
+ if (y < h)
+ return this;
+
+ if (isOpen())
+ {
+ y -= h;
+
+ for (int i = 0; i < subItems.size(); ++i)
+ {
+ TreeViewItem* const ti = subItems.getUnchecked(i);
+
+ if (ti->totalHeight >= y)
+ return ti->findItemRecursively (y);
+
+ y -= ti->totalHeight;
+ }
+ }
+ }
+
+ return 0;
+}
+
+int TreeViewItem::countSelectedItemsRecursively() const throw()
+{
+ int total = 0;
+
+ if (isSelected())
+ ++total;
+
+ for (int i = subItems.size(); --i >= 0;)
+ total += subItems.getUnchecked(i)->countSelectedItemsRecursively();
+
+ return total;
+}
+
+TreeViewItem* TreeViewItem::getSelectedItemWithIndex (int index) throw()
+{
+ if (isSelected())
+ {
+ if (index == 0)
+ return this;
+
+ --index;
+ }
+
+ if (index >= 0)
+ {
+ for (int i = 0; i < subItems.size(); ++i)
+ {
+ TreeViewItem* const item = subItems.getUnchecked(i);
+
+ TreeViewItem* const found = item->getSelectedItemWithIndex (index);
+
+ if (found != 0)
+ return found;
+
+ index -= item->countSelectedItemsRecursively();
+ }
+ }
+
+ return 0;
+}
+
+int TreeViewItem::getRowNumberInTree() const throw()
+{
+ if (parentItem != 0 && ownerView != 0)
+ {
+ int n = 1 + parentItem->getRowNumberInTree();
+
+ int ourIndex = parentItem->subItems.indexOf (this);
+ jassert (ourIndex >= 0);
+
+ while (--ourIndex >= 0)
+ n += parentItem->subItems [ourIndex]->getNumRows();
+
+ if (parentItem->parentItem == 0
+ && ! ownerView->rootItemVisible)
+ --n;
+
+ return n;
+ }
+ else
+ {
+ return 0;
+ }
+}
+
+void TreeViewItem::setLinesDrawnForSubItems (const bool drawLines) throw()
+{
+ drawLinesInside = drawLines;
+}
+
+TreeViewItem* TreeViewItem::getNextVisibleItem (const bool recurse) const throw()
+{
+ if (recurse && isOpen() && subItems.size() > 0)
+ return subItems [0];
+
+ if (parentItem != 0)
+ {
+ const int nextIndex = parentItem->subItems.indexOf (this) + 1;
+
+ if (nextIndex >= parentItem->subItems.size())
+ return parentItem->getNextVisibleItem (false);
+
+ return parentItem->subItems [nextIndex];
+ }
+
+ return 0;
+}
+
+void TreeViewItem::restoreFromXml (const XmlElement& e)
+{
+ if (e.hasTagName (T("CLOSED")))
+ {
+ setOpen (false);
+ }
+ else if (e.hasTagName (T("OPEN")))
+ {
+ setOpen (true);
+
+ forEachXmlChildElement (e, n)
+ {
+ const String id (n->getStringAttribute (T("id")));
+
+ for (int i = 0; i < subItems.size(); ++i)
+ {
+ TreeViewItem* const ti = subItems.getUnchecked(i);
+
+ if (ti->getUniqueName() == id)
+ {
+ ti->restoreFromXml (*n);
+ break;
+ }
+ }
+ }
+ }
+}
+
+XmlElement* TreeViewItem::createXmlOpenness() const
+{
+ if (openness != opennessDefault)
+ {
+ const String name (getUniqueName());
+
+ if (name.isNotEmpty())
+ {
+ XmlElement* e;
+
+ if (isOpen())
+ {
+ e = new XmlElement (T("OPEN"));
+
+ for (int i = 0; i < subItems.size(); ++i)
+ e->addChildElement (subItems.getUnchecked(i)->createXmlOpenness());
+ }
+ else
+ {
+ e = new XmlElement (T("CLOSED"));
+ }
+
+ e->setAttribute (T("id"), name);
+
+ return e;
+ }
+ else
+ {
+ // trying to save the openness for an element that has no name - this won't
+ // work because it needs the names to identify what to open.
+ jassertfalse
+ }
+ }
+
+ return 0;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_TreeView.cpp *********/
+
+/********* Start of inlined file: juce_DirectoryContentsDisplayComponent.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+DirectoryContentsDisplayComponent::DirectoryContentsDisplayComponent (DirectoryContentsList& listToShow)
+ : fileList (listToShow),
+ listeners (2)
+{
+}
+
+DirectoryContentsDisplayComponent::~DirectoryContentsDisplayComponent()
+{
+}
+
+FileBrowserListener::~FileBrowserListener()
+{
+}
+
+void DirectoryContentsDisplayComponent::addListener (FileBrowserListener* const listener) throw()
+{
+ jassert (listener != 0);
+
+ if (listener != 0)
+ listeners.add (listener);
+}
+
+void DirectoryContentsDisplayComponent::removeListener (FileBrowserListener* const listener) throw()
+{
+ listeners.removeValue (listener);
+}
+
+void DirectoryContentsDisplayComponent::sendSelectionChangeMessage()
+{
+ const ComponentDeletionWatcher deletionWatcher (dynamic_cast (this));
+
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ ((FileBrowserListener*) listeners.getUnchecked (i))->selectionChanged();
+
+ if (deletionWatcher.hasBeenDeleted())
+ return;
+
+ i = jmin (i, listeners.size() - 1);
+ }
+}
+
+void DirectoryContentsDisplayComponent::sendMouseClickMessage (const File& file, const MouseEvent& e)
+{
+ if (fileList.getDirectory().exists())
+ {
+ const ComponentDeletionWatcher deletionWatcher (dynamic_cast (this));
+
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ ((FileBrowserListener*) listeners.getUnchecked (i))->fileClicked (file, e);
+
+ if (deletionWatcher.hasBeenDeleted())
+ return;
+
+ i = jmin (i, listeners.size() - 1);
+ }
+ }
+}
+
+void DirectoryContentsDisplayComponent::sendDoubleClickMessage (const File& file)
+{
+ if (fileList.getDirectory().exists())
+ {
+ const ComponentDeletionWatcher deletionWatcher (dynamic_cast (this));
+
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ ((FileBrowserListener*) listeners.getUnchecked (i))->fileDoubleClicked (file);
+
+ if (deletionWatcher.hasBeenDeleted())
+ return;
+
+ i = jmin (i, listeners.size() - 1);
+ }
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_DirectoryContentsDisplayComponent.cpp *********/
+
+/********* Start of inlined file: juce_DirectoryContentsList.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+void* juce_findFileStart (const String& directory, const String& wildCard, String& firstResultFile,
+ bool* isDirectory, bool* isHidden, int64* fileSize, Time* modTime,
+ Time* creationTime, bool* isReadOnly) throw();
+bool juce_findFileNext (void* handle, String& resultFile,
+ bool* isDirectory, bool* isHidden, int64* fileSize,
+ Time* modTime, Time* creationTime, bool* isReadOnly) throw();
+void juce_findFileClose (void* handle) throw();
+
+DirectoryContentsList::DirectoryContentsList (const FileFilter* const fileFilter_,
+ TimeSliceThread& thread_)
+ : fileFilter (fileFilter_),
+ thread (thread_),
+ includeDirectories (false),
+ includeFiles (false),
+ ignoreHiddenFiles (true),
+ fileFindHandle (0),
+ shouldStop (true)
+{
+}
+
+DirectoryContentsList::~DirectoryContentsList()
+{
+ clear();
+}
+
+void DirectoryContentsList::setIgnoresHiddenFiles (const bool shouldIgnoreHiddenFiles)
+{
+ ignoreHiddenFiles = shouldIgnoreHiddenFiles;
+}
+
+const File& DirectoryContentsList::getDirectory() const throw()
+{
+ return root;
+}
+
+void DirectoryContentsList::setDirectory (const File& directory,
+ const bool includeDirectories_,
+ const bool includeFiles_)
+{
+ if (directory != root
+ || includeDirectories != includeDirectories_
+ || includeFiles != includeFiles_)
+ {
+ clear();
+
+ root = directory;
+ includeDirectories = includeDirectories_;
+ includeFiles = includeFiles_;
+
+ refresh();
+ }
+}
+
+void DirectoryContentsList::clear()
+{
+ shouldStop = true;
+ thread.removeTimeSliceClient (this);
+
+ if (fileFindHandle != 0)
+ {
+ juce_findFileClose (fileFindHandle);
+ fileFindHandle = 0;
+ }
+
+ if (files.size() > 0)
+ {
+ files.clear();
+ changed();
+ }
+}
+
+void DirectoryContentsList::refresh()
+{
+ clear();
+
+ if (root.isDirectory())
+ {
+ String fileFound;
+ bool fileFoundIsDir, isHidden, isReadOnly;
+ int64 fileSize;
+ Time modTime, creationTime;
+
+ String path (root.getFullPathName());
+ if (! path.endsWithChar (File::separator))
+ path += File::separator;
+
+ jassert (fileFindHandle == 0);
+
+ fileFindHandle = juce_findFileStart (path, T("*"), fileFound,
+ &fileFoundIsDir,
+ &isHidden,
+ &fileSize,
+ &modTime,
+ &creationTime,
+ &isReadOnly);
+
+ if (fileFindHandle != 0 && fileFound.isNotEmpty())
+ {
+ if (addFile (fileFound, fileFoundIsDir, isHidden,
+ fileSize, modTime, creationTime, isReadOnly))
+ {
+ changed();
+ }
+ }
+
+ shouldStop = false;
+
+ thread.addTimeSliceClient (this);
+ }
+}
+
+int DirectoryContentsList::getNumFiles() const
+{
+ return files.size();
+}
+
+bool DirectoryContentsList::getFileInfo (const int index,
+ FileInfo& result) const
+{
+ const ScopedLock sl (fileListLock);
+ const FileInfo* const info = files [index];
+
+ if (info != 0)
+ {
+ result = *info;
+ return true;
+ }
+
+ return false;
+}
+
+const File DirectoryContentsList::getFile (const int index) const
+{
+ const ScopedLock sl (fileListLock);
+ const FileInfo* const info = files [index];
+
+ if (info != 0)
+ return root.getChildFile (info->filename);
+
+ return File::nonexistent;
+}
+
+bool DirectoryContentsList::isStillLoading() const
+{
+ return fileFindHandle != 0;
+}
+
+void DirectoryContentsList::changed()
+{
+ sendChangeMessage (this);
+}
+
+bool DirectoryContentsList::useTimeSlice()
+{
+ const uint32 startTime = Time::getApproximateMillisecondCounter();
+ bool hasChanged = false;
+
+ for (int i = 100; --i >= 0;)
+ {
+ if (! checkNextFile (hasChanged))
+ {
+ if (hasChanged)
+ changed();
+
+ return false;
+ }
+
+ if (shouldStop || (Time::getApproximateMillisecondCounter() > startTime + 150))
+ break;
+ }
+
+ if (hasChanged)
+ changed();
+
+ return true;
+}
+
+bool DirectoryContentsList::checkNextFile (bool& hasChanged)
+{
+ if (fileFindHandle != 0)
+ {
+ String fileFound;
+ bool fileFoundIsDir, isHidden, isReadOnly;
+ int64 fileSize;
+ Time modTime, creationTime;
+
+ if (juce_findFileNext (fileFindHandle, fileFound,
+ &fileFoundIsDir, &isHidden,
+ &fileSize,
+ &modTime,
+ &creationTime,
+ &isReadOnly))
+ {
+ if (addFile (fileFound, fileFoundIsDir, isHidden, fileSize,
+ modTime, creationTime, isReadOnly))
+ {
+ hasChanged = true;
+ }
+
+ return true;
+ }
+ else
+ {
+ juce_findFileClose (fileFindHandle);
+ fileFindHandle = 0;
+ }
+ }
+
+ return false;
+}
+
+int DirectoryContentsList::compareElements (const DirectoryContentsList::FileInfo* const first,
+ const DirectoryContentsList::FileInfo* const second) throw()
+{
+#if JUCE_WIN32
+ if (first->isDirectory != second->isDirectory)
+ return first->isDirectory ? -1 : 1;
+#endif
+
+ return first->filename.compareIgnoreCase (second->filename);
+}
+
+bool DirectoryContentsList::addFile (const String& filename,
+ const bool isDir,
+ const bool isHidden,
+ const int64 fileSize,
+ const Time& modTime,
+ const Time& creationTime,
+ const bool isReadOnly)
+{
+ if (filename == T("..")
+ || filename == T(".")
+ || (ignoreHiddenFiles && isHidden))
+ return false;
+
+ const File file (root.getChildFile (filename));
+
+ if (((isDir && includeDirectories) || ((! isDir) && includeFiles))
+ && (fileFilter == 0
+ || ((! isDir) && fileFilter->isFileSuitable (file))
+ || (isDir && fileFilter->isDirectorySuitable (file))))
+ {
+ FileInfo* const info = new FileInfo();
+
+ info->filename = filename;
+ info->fileSize = fileSize;
+ info->modificationTime = modTime;
+ info->creationTime = creationTime;
+ info->isDirectory = isDir;
+ info->isReadOnly = isReadOnly;
+
+ const ScopedLock sl (fileListLock);
+
+ for (int i = files.size(); --i >= 0;)
+ {
+ if (files.getUnchecked(i)->filename == info->filename)
+ {
+ delete info;
+ return false;
+ }
+ }
+
+ files.addSorted (*this, info);
+ return true;
+ }
+
+ return false;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_DirectoryContentsList.cpp *********/
+
+/********* Start of inlined file: juce_FileBrowserComponent.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+class DirectoriesOnlyFilter : public FileFilter
+{
+public:
+ DirectoriesOnlyFilter() : FileFilter (String::empty) {}
+
+ bool isFileSuitable (const File&) const { return false; }
+ bool isDirectorySuitable (const File&) const { return true; }
+};
+
+FileBrowserComponent::FileBrowserComponent (FileChooserMode mode_,
+ const File& initialFileOrDirectory,
+ const FileFilter* fileFilter,
+ FilePreviewComponent* previewComp_,
+ const bool useTreeView,
+ const bool filenameTextBoxIsReadOnly)
+ : directoriesOnlyFilter (0),
+ mode (mode_),
+ listeners (2),
+ previewComp (previewComp_),
+ thread ("Juce FileBrowser")
+{
+ String filename;
+
+ if (initialFileOrDirectory == File::nonexistent)
+ {
+ currentRoot = File::getCurrentWorkingDirectory();
+ }
+ else if (initialFileOrDirectory.isDirectory())
+ {
+ currentRoot = initialFileOrDirectory;
+ }
+ else
+ {
+ currentRoot = initialFileOrDirectory.getParentDirectory();
+ filename = initialFileOrDirectory.getFileName();
+ }
+
+ if (mode_ == chooseDirectoryMode)
+ fileFilter = directoriesOnlyFilter = new DirectoriesOnlyFilter();
+
+ fileList = new DirectoryContentsList (fileFilter, thread);
+
+ if (useTreeView)
+ {
+ FileTreeComponent* const tree = new FileTreeComponent (*fileList);
+ addAndMakeVisible (tree);
+ fileListComponent = tree;
+ }
+ else
+ {
+ FileListComponent* const list = new FileListComponent (*fileList);
+ list->setOutlineThickness (1);
+ addAndMakeVisible (list);
+ fileListComponent = list;
+ }
+
+ fileListComponent->addListener (this);
+
+ addAndMakeVisible (currentPathBox = new ComboBox ("path"));
+ currentPathBox->setEditableText (true);
+
+ StringArray rootNames, rootPaths;
+ const BitArray separators (getRoots (rootNames, rootPaths));
+
+ for (int i = 0; i < rootNames.size(); ++i)
+ {
+ if (separators [i])
+ currentPathBox->addSeparator();
+
+ currentPathBox->addItem (rootNames[i], i + 1);
+ }
+
+ currentPathBox->addSeparator();
+ currentPathBox->addListener (this);
+
+ addAndMakeVisible (filenameBox = new TextEditor());
+ filenameBox->setMultiLine (false);
+ filenameBox->setSelectAllWhenFocused (true);
+ filenameBox->setText (filename, false);
+ filenameBox->addListener (this);
+ filenameBox->setReadOnly (filenameTextBoxIsReadOnly);
+
+ Label* label = new Label ("f", (mode == chooseDirectoryMode) ? TRANS("folder:")
+ : TRANS("file:"));
+ addAndMakeVisible (label);
+ label->attachToComponent (filenameBox, true);
+
+ addAndMakeVisible (goUpButton = getLookAndFeel().createFileBrowserGoUpButton());
+
+ goUpButton->addButtonListener (this);
+ goUpButton->setTooltip (TRANS ("go up to parent directory"));
+
+ if (previewComp != 0)
+ addAndMakeVisible (previewComp);
+
+ setRoot (currentRoot);
+
+ thread.startThread (4);
+}
+
+FileBrowserComponent::~FileBrowserComponent()
+{
+ if (previewComp != 0)
+ removeChildComponent (previewComp);
+
+ deleteAllChildren();
+
+ deleteAndZero (fileList);
+ delete directoriesOnlyFilter;
+
+ thread.stopThread (10000);
+}
+
+void FileBrowserComponent::addListener (FileBrowserListener* const newListener) throw()
+{
+ jassert (newListener != 0)
+
+ if (newListener != 0)
+ listeners.add (newListener);
+}
+
+void FileBrowserComponent::removeListener (FileBrowserListener* const listener) throw()
+{
+ listeners.removeValue (listener);
+}
+
+const File FileBrowserComponent::getCurrentFile() const throw()
+{
+ return currentRoot.getChildFile (filenameBox->getText());
+}
+
+bool FileBrowserComponent::currentFileIsValid() const
+{
+ if (mode == saveFileMode)
+ return ! getCurrentFile().isDirectory();
+ else if (mode == loadFileMode)
+ return getCurrentFile().existsAsFile();
+ else if (mode == chooseDirectoryMode)
+ return getCurrentFile().isDirectory();
+
+ jassertfalse
+ return false;
+}
+
+const File FileBrowserComponent::getRoot() const
+{
+ return currentRoot;
+}
+
+void FileBrowserComponent::setRoot (const File& newRootDirectory)
+{
+ if (currentRoot != newRootDirectory)
+ {
+ fileListComponent->scrollToTop();
+
+ if (mode == chooseDirectoryMode)
+ filenameBox->setText (String::empty, false);
+
+ String path (newRootDirectory.getFullPathName());
+
+ if (path.isEmpty())
+ path += File::separator;
+
+ StringArray rootNames, rootPaths;
+ getRoots (rootNames, rootPaths);
+
+ if (! rootPaths.contains (path, true))
+ {
+ bool alreadyListed = false;
+
+ for (int i = currentPathBox->getNumItems(); --i >= 0;)
+ {
+ if (currentPathBox->getItemText (i).equalsIgnoreCase (path))
+ {
+ alreadyListed = true;
+ break;
+ }
+ }
+
+ if (! alreadyListed)
+ currentPathBox->addItem (path, currentPathBox->getNumItems() + 2);
+ }
+ }
+
+ currentRoot = newRootDirectory;
+ fileList->setDirectory (currentRoot, true, true);
+
+ String currentRootName (currentRoot.getFullPathName());
+ if (currentRootName.isEmpty())
+ currentRootName += File::separator;
+
+ currentPathBox->setText (currentRootName, true);
+
+ goUpButton->setEnabled (currentRoot.getParentDirectory().isDirectory()
+ && currentRoot.getParentDirectory() != currentRoot);
+}
+
+void FileBrowserComponent::goUp()
+{
+ setRoot (getRoot().getParentDirectory());
+}
+
+void FileBrowserComponent::refresh()
+{
+ fileList->refresh();
+}
+
+const String FileBrowserComponent::getActionVerb() const
+{
+ return (mode == chooseDirectoryMode) ? TRANS("Choose")
+ : ((mode == saveFileMode) ? TRANS("Save") : TRANS("Open"));
+}
+
+FilePreviewComponent* FileBrowserComponent::getPreviewComponent() const throw()
+{
+ return previewComp;
+}
+
+void FileBrowserComponent::resized()
+{
+ getLookAndFeel()
+ .layoutFileBrowserComponent (*this, fileListComponent,
+ previewComp, currentPathBox,
+ filenameBox, goUpButton);
+}
+
+void FileBrowserComponent::sendListenerChangeMessage()
+{
+ ComponentDeletionWatcher deletionWatcher (this);
+
+ if (previewComp != 0)
+ previewComp->selectedFileChanged (getCurrentFile());
+
+ jassert (! deletionWatcher.hasBeenDeleted());
+
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ ((FileBrowserListener*) listeners.getUnchecked (i))->selectionChanged();
+
+ if (deletionWatcher.hasBeenDeleted())
+ return;
+
+ i = jmin (i, listeners.size() - 1);
+ }
+}
+
+void FileBrowserComponent::selectionChanged()
+{
+ const File selected (fileListComponent->getSelectedFile());
+
+ if ((mode == chooseDirectoryMode && selected.isDirectory())
+ || selected.existsAsFile())
+ {
+ filenameBox->setText (selected.getRelativePathFrom (getRoot()), false);
+ }
+
+ sendListenerChangeMessage();
+}
+
+void FileBrowserComponent::fileClicked (const File& f, const MouseEvent& e)
+{
+ ComponentDeletionWatcher deletionWatcher (this);
+
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ ((FileBrowserListener*) listeners.getUnchecked (i))->fileClicked (f, e);
+
+ if (deletionWatcher.hasBeenDeleted())
+ return;
+
+ i = jmin (i, listeners.size() - 1);
+ }
+}
+
+void FileBrowserComponent::fileDoubleClicked (const File& f)
+{
+ if (f.isDirectory())
+ {
+ setRoot (f);
+ }
+ else
+ {
+ ComponentDeletionWatcher deletionWatcher (this);
+
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ ((FileBrowserListener*) listeners.getUnchecked (i))->fileDoubleClicked (f);
+
+ if (deletionWatcher.hasBeenDeleted())
+ return;
+
+ i = jmin (i, listeners.size() - 1);
+ }
+ }
+}
+
+void FileBrowserComponent::textEditorTextChanged (TextEditor&)
+{
+ sendListenerChangeMessage();
+}
+
+void FileBrowserComponent::textEditorReturnKeyPressed (TextEditor&)
+{
+ if (filenameBox->getText().containsChar (File::separator))
+ {
+ const File f (currentRoot.getChildFile (filenameBox->getText()));
+
+ if (f.isDirectory())
+ {
+ setRoot (f);
+ filenameBox->setText (String::empty);
+ }
+ else
+ {
+ setRoot (f.getParentDirectory());
+ filenameBox->setText (f.getFileName());
+ }
+ }
+ else
+ {
+ fileDoubleClicked (getCurrentFile());
+ }
+}
+
+void FileBrowserComponent::textEditorEscapeKeyPressed (TextEditor&)
+{
+}
+
+void FileBrowserComponent::textEditorFocusLost (TextEditor&)
+{
+ if (mode != saveFileMode)
+ selectionChanged();
+}
+
+void FileBrowserComponent::buttonClicked (Button*)
+{
+ goUp();
+}
+
+void FileBrowserComponent::comboBoxChanged (ComboBox*)
+{
+ const String newText (currentPathBox->getText().trim().unquoted());
+
+ if (newText.isNotEmpty())
+ {
+ const int index = currentPathBox->getSelectedId() - 1;
+
+ StringArray rootNames, rootPaths;
+ getRoots (rootNames, rootPaths);
+
+ if (rootPaths [index].isNotEmpty())
+ {
+ setRoot (File (rootPaths [index]));
+ }
+ else
+ {
+ File f (newText);
+
+ for (;;)
+ {
+ if (f.isDirectory())
+ {
+ setRoot (f);
+ break;
+ }
+
+ if (f.getParentDirectory() == f)
+ break;
+
+ f = f.getParentDirectory();
+ }
+ }
+ }
+}
+
+const BitArray FileBrowserComponent::getRoots (StringArray& rootNames, StringArray& rootPaths)
+{
+ BitArray separators;
+
+#if JUCE_WIN32
+ OwnedArray roots;
+ File::findFileSystemRoots (roots);
+ rootPaths.clear();
+
+ for (int i = 0; i < roots.size(); ++i)
+ {
+ const File* const drive = roots.getUnchecked(i);
+
+ String name (drive->getFullPathName());
+ rootPaths.add (name);
+
+ if (drive->isOnHardDisk())
+ {
+ String volume (drive->getVolumeLabel());
+
+ if (volume.isEmpty())
+ volume = TRANS("Hard Drive");
+
+ name << " [" << drive->getVolumeLabel() << ']';
+ }
+ else if (drive->isOnCDRomDrive())
+ {
+ name << TRANS(" [CD/DVD drive]");
+ }
+
+ rootNames.add (name);
+ }
+
+ separators.setBit (rootPaths.size());
+
+ rootPaths.add (File::getSpecialLocation (File::userDocumentsDirectory).getFullPathName());
+ rootNames.add ("Documents");
+ rootPaths.add (File::getSpecialLocation (File::userDesktopDirectory).getFullPathName());
+ rootNames.add ("Desktop");
+#endif
+
+#if JUCE_MAC
+ rootPaths.add (File::getSpecialLocation (File::userHomeDirectory).getFullPathName());
+ rootNames.add ("Home folder");
+ rootPaths.add (File::getSpecialLocation (File::userDocumentsDirectory).getFullPathName());
+ rootNames.add ("Documents");
+ rootPaths.add (File::getSpecialLocation (File::userDesktopDirectory).getFullPathName());
+ rootNames.add ("Desktop");
+
+ separators.setBit (rootPaths.size());
+
+ OwnedArray volumes;
+ File vol ("/Volumes");
+ vol.findChildFiles (volumes, File::findDirectories, false);
+
+ for (int i = 0; i < volumes.size(); ++i)
+ {
+ const File* const volume = volumes.getUnchecked(i);
+
+ if (volume->isDirectory() && ! volume->getFileName().startsWithChar (T('.')))
+ {
+ rootPaths.add (volume->getFullPathName());
+ rootNames.add (volume->getFileName());
+ }
+ }
+#endif
+
+#if JUCE_LINUX
+ rootPaths.add ("/");
+ rootNames.add ("/");
+ rootPaths.add (File::getSpecialLocation (File::userHomeDirectory).getFullPathName());
+ rootNames.add ("Home folder");
+ rootPaths.add (File::getSpecialLocation (File::userDesktopDirectory).getFullPathName());
+ rootNames.add ("Desktop");
+#endif
+
+ return separators;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_FileBrowserComponent.cpp *********/
+
+/********* Start of inlined file: juce_FileChooser.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+FileChooser::FileChooser (const String& chooserBoxTitle,
+ const File& currentFileOrDirectory,
+ const String& fileFilters,
+ const bool useNativeDialogBox_)
+ : title (chooserBoxTitle),
+ filters (fileFilters),
+ startingFile (currentFileOrDirectory),
+ useNativeDialogBox (useNativeDialogBox_)
+{
+#if JUCE_LINUX
+ useNativeDialogBox = false;
+#endif
+
+ if (fileFilters.trim().isEmpty())
+ filters = T("*");
+}
+
+FileChooser::~FileChooser()
+{
+}
+
+bool FileChooser::browseForFileToOpen (FilePreviewComponent* previewComponent)
+{
+ return showDialog (false, false, false, false, previewComponent);
+}
+
+bool FileChooser::browseForMultipleFilesToOpen (FilePreviewComponent* previewComponent)
+{
+ return showDialog (false, false, false, true, previewComponent);
+}
+
+bool FileChooser::browseForFileToSave (const bool warnAboutOverwritingExistingFiles)
+{
+ return showDialog (false, true, warnAboutOverwritingExistingFiles, false, 0);
+}
+
+bool FileChooser::browseForDirectory()
+{
+ return showDialog (true, false, false, false, 0);
+}
+
+const File FileChooser::getResult() const
+{
+ // if you've used a multiple-file select, you should use the getResults() method
+ // to retrieve all the files that were chosen.
+ jassert (results.size() <= 1);
+
+ const File* const f = results.getFirst();
+
+ if (f != 0)
+ return *f;
+
+ return File::nonexistent;
+}
+
+const OwnedArray & FileChooser::getResults() const
+{
+ return results;
+}
+
+bool FileChooser::showDialog (const bool isDirectory,
+ const bool isSave,
+ const bool warnAboutOverwritingExistingFiles,
+ const bool selectMultipleFiles,
+ FilePreviewComponent* const previewComponent)
+{
+ ComponentDeletionWatcher* currentlyFocusedChecker = 0;
+ Component* const currentlyFocused = Component::getCurrentlyFocusedComponent();
+
+ if (currentlyFocused != 0)
+ currentlyFocusedChecker = new ComponentDeletionWatcher (currentlyFocused);
+
+ results.clear();
+
+ // the preview component needs to be the right size before you pass it in here..
+ jassert (previewComponent == 0 || (previewComponent->getWidth() > 10
+ && previewComponent->getHeight() > 10));
+
+#if JUCE_WIN32
+ if (useNativeDialogBox)
+#else
+ if (useNativeDialogBox && (previewComponent == 0))
+#endif
+ {
+ showPlatformDialog (results, title, startingFile, filters,
+ isDirectory, isSave,
+ warnAboutOverwritingExistingFiles,
+ selectMultipleFiles,
+ previewComponent);
+ }
+ else
+ {
+ jassert (! selectMultipleFiles); // not yet implemented for juce dialogs!
+
+ WildcardFileFilter wildcard (filters, String::empty);
+
+ FileBrowserComponent browserComponent (isDirectory ? FileBrowserComponent::chooseDirectoryMode
+ : (isSave ? FileBrowserComponent::saveFileMode
+ : FileBrowserComponent::loadFileMode),
+ startingFile, &wildcard, previewComponent);
+
+ FileChooserDialogBox box (title, String::empty,
+ browserComponent,
+ warnAboutOverwritingExistingFiles,
+ browserComponent.findColour (AlertWindow::backgroundColourId));
+
+ if (box.show())
+ results.add (new File (browserComponent.getCurrentFile()));
+ }
+
+ if (currentlyFocused != 0 && ! currentlyFocusedChecker->hasBeenDeleted())
+ currentlyFocused->grabKeyboardFocus();
+
+ delete currentlyFocusedChecker;
+
+ return results.size() > 0;
+}
+
+FilePreviewComponent::FilePreviewComponent()
+{
+}
+
+FilePreviewComponent::~FilePreviewComponent()
+{
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_FileChooser.cpp *********/
+
+/********* Start of inlined file: juce_FileChooserDialogBox.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+FileChooserDialogBox::FileChooserDialogBox (const String& name,
+ const String& instructions,
+ FileBrowserComponent& chooserComponent,
+ const bool warnAboutOverwritingExistingFiles_,
+ const Colour& backgroundColour)
+ : ResizableWindow (name, backgroundColour, true),
+ warnAboutOverwritingExistingFiles (warnAboutOverwritingExistingFiles_)
+{
+ content = new ContentComponent();
+ content->setName (name);
+ content->instructions = instructions;
+ content->chooserComponent = &chooserComponent;
+
+ content->addAndMakeVisible (&chooserComponent);
+
+ content->okButton = new TextButton (chooserComponent.getActionVerb());
+ content->addAndMakeVisible (content->okButton);
+ content->okButton->addButtonListener (this);
+ content->okButton->setEnabled (chooserComponent.currentFileIsValid());
+ content->okButton->addShortcut (KeyPress (KeyPress::returnKey, 0, 0));
+
+ content->cancelButton = new TextButton (TRANS("Cancel"));
+ content->addAndMakeVisible (content->cancelButton);
+ content->cancelButton->addButtonListener (this);
+ content->cancelButton->addShortcut (KeyPress (KeyPress::escapeKey, 0, 0));
+
+ setContentComponent (content);
+
+ setResizable (true, true);
+ setResizeLimits (300, 300, 1200, 1000);
+
+ content->chooserComponent->addListener (this);
+}
+
+FileChooserDialogBox::~FileChooserDialogBox()
+{
+ content->chooserComponent->removeListener (this);
+}
+
+bool FileChooserDialogBox::show (int w, int h)
+{
+ if (w <= 0)
+ {
+ Component* const previewComp = content->chooserComponent->getPreviewComponent();
+ if (previewComp != 0)
+ w = 400 + previewComp->getWidth();
+ else
+ w = 600;
+ }
+
+ if (h <= 0)
+ h = 500;
+
+ centreWithSize (w, h);
+
+ const bool ok = (runModalLoop() != 0);
+ setVisible (false);
+ return ok;
+}
+
+void FileChooserDialogBox::buttonClicked (Button* button)
+{
+ if (button == content->okButton)
+ {
+ if (warnAboutOverwritingExistingFiles
+ && content->chooserComponent->getMode() == FileBrowserComponent::saveFileMode
+ && content->chooserComponent->getCurrentFile().exists())
+ {
+ if (! AlertWindow::showOkCancelBox (AlertWindow::WarningIcon,
+ TRANS("File already exists"),
+ TRANS("There's already a file called:\n\n")
+ + content->chooserComponent->getCurrentFile().getFullPathName()
+ + T("\n\nAre you sure you want to overwrite it?"),
+ TRANS("overwrite"),
+ TRANS("cancel")))
+ {
+ return;
+ }
+ }
+
+ exitModalState (1);
+ }
+ else if (button == content->cancelButton)
+ closeButtonPressed();
+}
+
+void FileChooserDialogBox::closeButtonPressed()
+{
+ setVisible (false);
+}
+
+void FileChooserDialogBox::selectionChanged()
+{
+ content->okButton->setEnabled (content->chooserComponent->currentFileIsValid());
+}
+
+void FileChooserDialogBox::fileClicked (const File&, const MouseEvent&)
+{
+}
+
+void FileChooserDialogBox::fileDoubleClicked (const File&)
+{
+ selectionChanged();
+ content->okButton->triggerClick();
+}
+
+FileChooserDialogBox::ContentComponent::ContentComponent()
+{
+ setInterceptsMouseClicks (false, true);
+}
+
+FileChooserDialogBox::ContentComponent::~ContentComponent()
+{
+ delete okButton;
+ delete cancelButton;
+}
+
+void FileChooserDialogBox::ContentComponent::paint (Graphics& g)
+{
+ g.setColour (Colours::black);
+ text.draw (g);
+}
+
+void FileChooserDialogBox::ContentComponent::resized()
+{
+ getLookAndFeel().createFileChooserHeaderText (getName(), instructions, text, getWidth());
+
+ float left, top, right, bottom;
+ text.getBoundingBox (0, text.getNumGlyphs(), left, top, right, bottom, false);
+
+ const int y = roundFloatToInt (bottom) + 10;
+ const int buttonHeight = 26;
+ const int buttonY = getHeight() - buttonHeight - 8;
+
+ chooserComponent->setBounds (0, y, getWidth(), buttonY - y - 20);
+
+ okButton->setBounds (proportionOfWidth (0.25f), buttonY,
+ proportionOfWidth (0.2f), buttonHeight);
+
+ cancelButton->setBounds (proportionOfWidth (0.55f), buttonY,
+ proportionOfWidth (0.2f), buttonHeight);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_FileChooserDialogBox.cpp *********/
+
+/********* Start of inlined file: juce_FileFilter.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+FileFilter::FileFilter (const String& filterDescription)
+ : description (filterDescription)
+{
+}
+
+FileFilter::~FileFilter()
+{
+}
+
+const String& FileFilter::getDescription() const throw()
+{
+ return description;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_FileFilter.cpp *********/
+
+/********* Start of inlined file: juce_FileListComponent.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+Image* juce_createIconForFile (const File& file);
+
+FileListComponent::FileListComponent (DirectoryContentsList& listToShow)
+ : DirectoryContentsDisplayComponent (listToShow),
+ ListBox (String::empty, 0)
+{
+ setModel (this);
+ fileList.addChangeListener (this);
+}
+
+FileListComponent::~FileListComponent()
+{
+ fileList.removeChangeListener (this);
+ deleteAllChildren();
+}
+
+const File FileListComponent::getSelectedFile() const
+{
+ return fileList.getFile (getSelectedRow());
+}
+
+void FileListComponent::scrollToTop()
+{
+ getVerticalScrollBar()->setCurrentRangeStart (0);
+}
+
+void FileListComponent::changeListenerCallback (void*)
+{
+ updateContent();
+}
+
+class FileListItemComponent : public Component,
+ public TimeSliceClient,
+ public AsyncUpdater
+{
+public:
+
+ FileListItemComponent (FileListComponent& owner_,
+ TimeSliceThread& thread_) throw()
+ : owner (owner_),
+ thread (thread_),
+ icon (0)
+ {
+ }
+
+ ~FileListItemComponent() throw()
+ {
+ thread.removeTimeSliceClient (this);
+
+ clearIcon();
+ }
+
+ void paint (Graphics& g)
+ {
+ getLookAndFeel().drawFileBrowserRow (g, getWidth(), getHeight(),
+ file.getFileName(),
+ icon,
+ fileSize, modTime,
+ isDirectory, highlighted);
+ }
+
+ void mouseDown (const MouseEvent& e)
+ {
+ owner.selectRowsBasedOnModifierKeys (index, e.mods);
+ owner.sendMouseClickMessage (file, e);
+ }
+
+ void mouseDoubleClick (const MouseEvent&)
+ {
+ owner.sendDoubleClickMessage (file);
+ }
+
+ void update (const File& root,
+ const DirectoryContentsList::FileInfo* const fileInfo,
+ const int index_,
+ const bool highlighted_) throw()
+ {
+ thread.removeTimeSliceClient (this);
+
+ if (highlighted_ != highlighted
+ || index_ != index)
+ {
+ index = index_;
+ highlighted = highlighted_;
+ repaint();
+ }
+
+ File newFile;
+ String newFileSize;
+ String newModTime;
+
+ if (fileInfo != 0)
+ {
+ newFile = root.getChildFile (fileInfo->filename);
+ newFileSize = File::descriptionOfSizeInBytes (fileInfo->fileSize);
+ newModTime = fileInfo->modificationTime.formatted (T("%d %b '%y %H:%M"));
+ }
+
+ if (newFile != file
+ || fileSize != newFileSize
+ || modTime != newModTime)
+ {
+ file = newFile;
+ fileSize = newFileSize;
+ modTime = newModTime;
+
+ isDirectory = fileInfo != 0 && fileInfo->isDirectory;
+ repaint();
+
+ clearIcon();
+ }
+
+ if (file != File::nonexistent
+ && icon == 0 && ! isDirectory)
+ {
+ updateIcon (true);
+
+ if (icon == 0)
+ thread.addTimeSliceClient (this);
+ }
+ }
+
+ bool useTimeSlice()
+ {
+ updateIcon (false);
+ return false;
+ }
+
+ void handleAsyncUpdate()
+ {
+ repaint();
+ }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ FileListComponent& owner;
+ TimeSliceThread& thread;
+ bool highlighted;
+ int index;
+ File file;
+ String fileSize;
+ String modTime;
+ Image* icon;
+ bool isDirectory;
+
+ void clearIcon() throw()
+ {
+ ImageCache::release (icon);
+ icon = 0;
+ }
+
+ void updateIcon (const bool onlyUpdateIfCached) throw()
+ {
+ if (icon == 0)
+ {
+ const int hashCode = (file.getFullPathName() + T("_iconCacheSalt")).hashCode();
+ Image* im = ImageCache::getFromHashCode (hashCode);
+
+ if (im == 0 && ! onlyUpdateIfCached)
+ {
+ im = juce_createIconForFile (file);
+
+ if (im != 0)
+ ImageCache::addImageToCache (im, hashCode);
+ }
+
+ if (im != 0)
+ {
+ icon = im;
+ triggerAsyncUpdate();
+ }
+ }
+ }
+};
+
+int FileListComponent::getNumRows()
+{
+ return fileList.getNumFiles();
+}
+
+void FileListComponent::paintListBoxItem (int, Graphics&, int, int, bool)
+{
+}
+
+Component* FileListComponent::refreshComponentForRow (int row, bool isSelected, Component* existingComponentToUpdate)
+{
+ FileListItemComponent* comp = dynamic_cast (existingComponentToUpdate);
+
+ if (comp == 0)
+ {
+ delete existingComponentToUpdate;
+ existingComponentToUpdate = comp = new FileListItemComponent (*this, fileList.getTimeSliceThread());
+ }
+
+ DirectoryContentsList::FileInfo fileInfo;
+
+ if (fileList.getFileInfo (row, fileInfo))
+ comp->update (fileList.getDirectory(), &fileInfo, row, isSelected);
+ else
+ comp->update (fileList.getDirectory(), 0, row, isSelected);
+
+ return comp;
+}
+
+void FileListComponent::selectedRowsChanged (int /*lastRowSelected*/)
+{
+ sendSelectionChangeMessage();
+}
+
+void FileListComponent::deleteKeyPressed (int /*currentSelectedRow*/)
+{
+}
+
+void FileListComponent::returnKeyPressed (int currentSelectedRow)
+{
+ sendDoubleClickMessage (fileList.getFile (currentSelectedRow));
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_FileListComponent.cpp *********/
+
+/********* Start of inlined file: juce_FilenameComponent.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+FilenameComponent::FilenameComponent (const String& name,
+ const File& currentFile,
+ const bool canEditFilename,
+ const bool isDirectory,
+ const bool isForSaving,
+ const String& fileBrowserWildcard,
+ const String& enforcedSuffix_,
+ const String& textWhenNothingSelected)
+ : Component (name),
+ maxRecentFiles (30),
+ isDir (isDirectory),
+ isSaving (isForSaving),
+ isFileDragOver (false),
+ wildcard (fileBrowserWildcard),
+ enforcedSuffix (enforcedSuffix_)
+{
+ addAndMakeVisible (filenameBox = new ComboBox (T("fn")));
+ filenameBox->setEditableText (canEditFilename);
+ filenameBox->addListener (this);
+ filenameBox->setTextWhenNothingSelected (textWhenNothingSelected);
+ filenameBox->setTextWhenNoChoicesAvailable (TRANS("(no recently seleced files)"));
+
+ browseButton = 0;
+ setBrowseButtonText (T("..."));
+
+ setCurrentFile (currentFile, true);
+}
+
+FilenameComponent::~FilenameComponent()
+{
+ deleteAllChildren();
+}
+
+void FilenameComponent::paintOverChildren (Graphics& g)
+{
+ if (isFileDragOver)
+ {
+ g.setColour (Colours::red.withAlpha (0.2f));
+ g.drawRect (0, 0, getWidth(), getHeight(), 3);
+ }
+}
+
+void FilenameComponent::resized()
+{
+ getLookAndFeel().layoutFilenameComponent (*this, filenameBox, browseButton);
+}
+
+void FilenameComponent::setBrowseButtonText (const String& newBrowseButtonText)
+{
+ browseButtonText = newBrowseButtonText;
+ lookAndFeelChanged();
+}
+
+void FilenameComponent::lookAndFeelChanged()
+{
+ deleteAndZero (browseButton);
+
+ addAndMakeVisible (browseButton = getLookAndFeel().createFilenameComponentBrowseButton (browseButtonText));
+ browseButton->setConnectedEdges (Button::ConnectedOnLeft);
+ resized();
+
+ browseButton->addButtonListener (this);
+}
+
+void FilenameComponent::setTooltip (const String& newTooltip)
+{
+ SettableTooltipClient::setTooltip (newTooltip);
+ filenameBox->setTooltip (newTooltip);
+}
+
+void FilenameComponent::setDefaultBrowseTarget (const File& newDefaultDirectory) throw()
+{
+ defaultBrowseFile = newDefaultDirectory;
+}
+
+void FilenameComponent::buttonClicked (Button*)
+{
+ FileChooser fc (TRANS("Choose a new file"),
+ getCurrentFile() == File::nonexistent ? defaultBrowseFile
+ : getCurrentFile(),
+ wildcard);
+
+ if (isDir ? fc.browseForDirectory()
+ : (isSaving ? fc.browseForFileToSave (false)
+ : fc.browseForFileToOpen()))
+ {
+ setCurrentFile (fc.getResult(), true);
+ }
+}
+
+void FilenameComponent::comboBoxChanged (ComboBox*)
+{
+ setCurrentFile (getCurrentFile(), true);
+}
+
+bool FilenameComponent::isInterestedInFileDrag (const StringArray&)
+{
+ return true;
+}
+
+void FilenameComponent::filesDropped (const StringArray& filenames, int, int)
+{
+ isFileDragOver = false;
+ repaint();
+
+ const File f (filenames[0]);
+
+ if (f.exists() && (f.isDirectory() == isDir))
+ setCurrentFile (f, true);
+}
+
+void FilenameComponent::fileDragEnter (const StringArray&, int, int)
+{
+ isFileDragOver = true;
+ repaint();
+}
+
+void FilenameComponent::fileDragExit (const StringArray&)
+{
+ isFileDragOver = false;
+ repaint();
+}
+
+const File FilenameComponent::getCurrentFile() const
+{
+ File f (filenameBox->getText());
+
+ if (enforcedSuffix.isNotEmpty())
+ f = f.withFileExtension (enforcedSuffix);
+
+ return f;
+}
+
+void FilenameComponent::setCurrentFile (File newFile,
+ const bool addToRecentlyUsedList,
+ const bool sendChangeNotification)
+{
+ if (enforcedSuffix.isNotEmpty())
+ newFile = newFile.withFileExtension (enforcedSuffix);
+
+ if (newFile.getFullPathName() != lastFilename)
+ {
+ lastFilename = newFile.getFullPathName();
+
+ if (addToRecentlyUsedList)
+ addRecentlyUsedFile (newFile);
+
+ filenameBox->setText (lastFilename, true);
+
+ if (sendChangeNotification)
+ triggerAsyncUpdate();
+ }
+}
+
+void FilenameComponent::setFilenameIsEditable (const bool shouldBeEditable)
+{
+ filenameBox->setEditableText (shouldBeEditable);
+}
+
+const StringArray FilenameComponent::getRecentlyUsedFilenames() const
+{
+ StringArray names;
+
+ for (int i = 0; i < filenameBox->getNumItems(); ++i)
+ names.add (filenameBox->getItemText (i));
+
+ return names;
+}
+
+void FilenameComponent::setRecentlyUsedFilenames (const StringArray& filenames)
+{
+ if (filenames != getRecentlyUsedFilenames())
+ {
+ filenameBox->clear();
+
+ for (int i = 0; i < jmin (filenames.size(), maxRecentFiles); ++i)
+ filenameBox->addItem (filenames[i], i + 1);
+ }
+}
+
+void FilenameComponent::setMaxNumberOfRecentFiles (const int newMaximum)
+{
+ maxRecentFiles = jmax (1, newMaximum);
+
+ setRecentlyUsedFilenames (getRecentlyUsedFilenames());
+}
+
+void FilenameComponent::addRecentlyUsedFile (const File& file)
+{
+ StringArray files (getRecentlyUsedFilenames());
+
+ if (file.getFullPathName().isNotEmpty())
+ {
+ files.removeString (file.getFullPathName(), true);
+ files.insert (0, file.getFullPathName());
+
+ setRecentlyUsedFilenames (files);
+ }
+}
+
+void FilenameComponent::addListener (FilenameComponentListener* const listener) throw()
+{
+ jassert (listener != 0);
+
+ if (listener != 0)
+ listeners.add (listener);
+}
+
+void FilenameComponent::removeListener (FilenameComponentListener* const listener) throw()
+{
+ listeners.removeValue (listener);
+}
+
+void FilenameComponent::handleAsyncUpdate()
+{
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ ((FilenameComponentListener*) listeners.getUnchecked (i))->filenameComponentChanged (this);
+ i = jmin (i, listeners.size());
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_FilenameComponent.cpp *********/
+
+/********* Start of inlined file: juce_FileSearchPathListComponent.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+FileSearchPathListComponent::FileSearchPathListComponent()
+{
+ addAndMakeVisible (listBox = new ListBox (String::empty, this));
+ listBox->setColour (ListBox::backgroundColourId, Colours::black.withAlpha (0.02f));
+ listBox->setColour (ListBox::outlineColourId, Colours::black.withAlpha (0.1f));
+ listBox->setOutlineThickness (1);
+
+ addAndMakeVisible (addButton = new TextButton ("+"));
+ addButton->addButtonListener (this);
+ addButton->setConnectedEdges (Button::ConnectedOnLeft | Button::ConnectedOnRight | Button::ConnectedOnBottom | Button::ConnectedOnTop);
+
+ addAndMakeVisible (removeButton = new TextButton ("-"));
+ removeButton->addButtonListener (this);
+ removeButton->setConnectedEdges (Button::ConnectedOnLeft | Button::ConnectedOnRight | Button::ConnectedOnBottom | Button::ConnectedOnTop);
+
+ addAndMakeVisible (changeButton = new TextButton (TRANS("change...")));
+ changeButton->addButtonListener (this);
+
+ addAndMakeVisible (upButton = new DrawableButton (String::empty, DrawableButton::ImageOnButtonBackground));
+ upButton->addButtonListener (this);
+
+ {
+ Path arrowPath;
+ arrowPath.addArrow (50.0f, 100.0f, 50.0f, 0.0, 40.0f, 100.0f, 50.0f);
+ DrawablePath arrowImage;
+ arrowImage.setSolidFill (Colours::black.withAlpha (0.4f));
+ arrowImage.setPath (arrowPath);
+
+ ((DrawableButton*) upButton)->setImages (&arrowImage);
+ }
+
+ addAndMakeVisible (downButton = new DrawableButton (String::empty, DrawableButton::ImageOnButtonBackground));
+ downButton->addButtonListener (this);
+
+ {
+ Path arrowPath;
+ arrowPath.addArrow (50.0f, 0.0f, 50.0f, 100.0f, 40.0f, 100.0f, 50.0f);
+ DrawablePath arrowImage;
+ arrowImage.setSolidFill (Colours::black.withAlpha (0.4f));
+ arrowImage.setPath (arrowPath);
+
+ ((DrawableButton*) downButton)->setImages (&arrowImage);
+ }
+
+ updateButtons();
+}
+
+FileSearchPathListComponent::~FileSearchPathListComponent()
+{
+ deleteAllChildren();
+}
+
+void FileSearchPathListComponent::updateButtons() throw()
+{
+ const bool anythingSelected = listBox->getNumSelectedRows() > 0;
+
+ removeButton->setEnabled (anythingSelected);
+ changeButton->setEnabled (anythingSelected);
+ upButton->setEnabled (anythingSelected);
+ downButton->setEnabled (anythingSelected);
+}
+
+void FileSearchPathListComponent::changed() throw()
+{
+ listBox->updateContent();
+ listBox->repaint();
+ updateButtons();
+}
+
+void FileSearchPathListComponent::setPath (const FileSearchPath& newPath)
+{
+ if (newPath.toString() != path.toString())
+ {
+ path = newPath;
+ changed();
+ }
+}
+
+void FileSearchPathListComponent::setDefaultBrowseTarget (const File& newDefaultDirectory) throw()
+{
+ defaultBrowseTarget = newDefaultDirectory;
+}
+
+int FileSearchPathListComponent::getNumRows()
+{
+ return path.getNumPaths();
+}
+
+void FileSearchPathListComponent::paintListBoxItem (int rowNumber, Graphics& g, int width, int height, bool rowIsSelected)
+{
+ if (rowIsSelected)
+ g.fillAll (findColour (TextEditor::highlightColourId));
+
+ g.setColour (findColour (ListBox::textColourId));
+ Font f (height * 0.7f);
+ f.setHorizontalScale (0.9f);
+ g.setFont (f);
+
+ g.drawText (path [rowNumber].getFullPathName(),
+ 4, 0, width - 6, height,
+ Justification::centredLeft, true);
+}
+
+void FileSearchPathListComponent::deleteKeyPressed (int row)
+{
+ if (((unsigned int) row) < (unsigned int) path.getNumPaths())
+ {
+ path.remove (row);
+ changed();
+ }
+}
+
+void FileSearchPathListComponent::returnKeyPressed (int row)
+{
+ FileChooser chooser (TRANS("Change folder..."), path [row], T("*"));
+
+ if (chooser.browseForDirectory())
+ {
+ path.remove (row);
+ path.add (chooser.getResult(), row);
+ changed();
+ }
+}
+
+void FileSearchPathListComponent::listBoxItemDoubleClicked (int row, const MouseEvent&)
+{
+ returnKeyPressed (row);
+}
+
+void FileSearchPathListComponent::selectedRowsChanged (int)
+{
+ updateButtons();
+}
+
+void FileSearchPathListComponent::paint (Graphics& g)
+{
+ g.fillAll (findColour (backgroundColourId));
+}
+
+void FileSearchPathListComponent::resized()
+{
+ const int buttonH = 22;
+ const int buttonY = getHeight() - buttonH - 4;
+ listBox->setBounds (2, 2, getWidth() - 4, buttonY - 5);
+
+ addButton->setBounds (2, buttonY, buttonH, buttonH);
+ removeButton->setBounds (addButton->getRight(), buttonY, buttonH, buttonH);
+
+ ((TextButton*) changeButton)->changeWidthToFitText (buttonH);
+ downButton->setSize (buttonH * 2, buttonH);
+ upButton->setSize (buttonH * 2, buttonH);
+
+ downButton->setTopRightPosition (getWidth() - 2, buttonY);
+ upButton->setTopRightPosition (downButton->getX() - 4, buttonY);
+ changeButton->setTopRightPosition (upButton->getX() - 8, buttonY);
+}
+
+bool FileSearchPathListComponent::isInterestedInFileDrag (const StringArray&)
+{
+ return true;
+}
+
+void FileSearchPathListComponent::filesDropped (const StringArray& filenames, int, int mouseY)
+{
+ for (int i = filenames.size(); --i >= 0;)
+ {
+ const File f (filenames[i]);
+
+ if (f.isDirectory())
+ {
+ const int row = listBox->getRowContainingPosition (0, mouseY - listBox->getY());
+ path.add (f, row);
+ changed();
+ }
+ }
+}
+
+void FileSearchPathListComponent::buttonClicked (Button* button)
+{
+ const int currentRow = listBox->getSelectedRow();
+
+ if (button == removeButton)
+ {
+ deleteKeyPressed (currentRow);
+ }
+ else if (button == addButton)
+ {
+ File start (defaultBrowseTarget);
+
+ if (start == File::nonexistent)
+ start = path [0];
+
+ if (start == File::nonexistent)
+ start = File::getCurrentWorkingDirectory();
+
+ FileChooser chooser (TRANS("Add a folder..."), start, T("*"));
+
+ if (chooser.browseForDirectory())
+ {
+ path.add (chooser.getResult(), currentRow);
+ }
+ }
+ else if (button == changeButton)
+ {
+ returnKeyPressed (currentRow);
+ }
+ else if (button == upButton)
+ {
+ if (currentRow > 0 && currentRow < path.getNumPaths())
+ {
+ const File f (path[currentRow]);
+ path.remove (currentRow);
+ path.add (f, currentRow - 1);
+ listBox->selectRow (currentRow - 1);
+ }
+ }
+ else if (button == downButton)
+ {
+ if (currentRow >= 0 && currentRow < path.getNumPaths() - 1)
+ {
+ const File f (path[currentRow]);
+ path.remove (currentRow);
+ path.add (f, currentRow + 1);
+ listBox->selectRow (currentRow + 1);
+ }
+ }
+
+ changed();
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_FileSearchPathListComponent.cpp *********/
+
+/********* Start of inlined file: juce_FileTreeComponent.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+Image* juce_createIconForFile (const File& file);
+
+class FileListTreeItem : public TreeViewItem,
+ public TimeSliceClient,
+ public AsyncUpdater,
+ public ChangeListener
+{
+public:
+
+ FileListTreeItem (FileTreeComponent& owner_,
+ DirectoryContentsList* const parentContentsList_,
+ const int indexInContentsList_,
+ const File& file_,
+ TimeSliceThread& thread_) throw()
+ : file (file_),
+ owner (owner_),
+ parentContentsList (parentContentsList_),
+ indexInContentsList (indexInContentsList_),
+ subContentsList (0),
+ canDeleteSubContentsList (false),
+ thread (thread_),
+ icon (0)
+ {
+ DirectoryContentsList::FileInfo fileInfo;
+
+ if (parentContentsList_ != 0
+ && parentContentsList_->getFileInfo (indexInContentsList_, fileInfo))
+ {
+ fileSize = File::descriptionOfSizeInBytes (fileInfo.fileSize);
+ modTime = fileInfo.modificationTime.formatted (T("%d %b '%y %H:%M"));
+ isDirectory = fileInfo.isDirectory;
+ }
+ else
+ {
+ isDirectory = true;
+ }
+ }
+
+ ~FileListTreeItem() throw()
+ {
+ thread.removeTimeSliceClient (this);
+
+ clearSubItems();
+ ImageCache::release (icon);
+
+ if (canDeleteSubContentsList)
+ delete subContentsList;
+ }
+
+ bool mightContainSubItems() { return isDirectory; }
+ const String getUniqueName() const { return file.getFullPathName(); }
+ int getItemHeight() const { return 22; }
+
+ const String getDragSourceDescription() { return owner.getDragAndDropDescription(); }
+
+ void itemOpennessChanged (bool isNowOpen)
+ {
+ if (isNowOpen)
+ {
+ clearSubItems();
+
+ isDirectory = file.isDirectory();
+
+ if (isDirectory)
+ {
+ if (subContentsList == 0)
+ {
+ jassert (parentContentsList != 0);
+
+ DirectoryContentsList* const l = new DirectoryContentsList (parentContentsList->getFilter(), thread);
+ l->setDirectory (file, true, true);
+
+ setSubContentsList (l);
+ canDeleteSubContentsList = true;
+ }
+
+ changeListenerCallback (0);
+ }
+ }
+ }
+
+ void setSubContentsList (DirectoryContentsList* newList) throw()
+ {
+ jassert (subContentsList == 0);
+ subContentsList = newList;
+ newList->addChangeListener (this);
+ }
+
+ void changeListenerCallback (void*)
+ {
+ clearSubItems();
+
+ if (isOpen() && subContentsList != 0)
+ {
+ for (int i = 0; i < subContentsList->getNumFiles(); ++i)
+ {
+ FileListTreeItem* const item
+ = new FileListTreeItem (owner, subContentsList, i, subContentsList->getFile(i), thread);
+
+ addSubItem (item);
+ }
+ }
+ }
+
+ void paintItem (Graphics& g, int width, int height)
+ {
+ if (file != File::nonexistent && ! isDirectory)
+ {
+ updateIcon (true);
+
+ if (icon == 0)
+ thread.addTimeSliceClient (this);
+ }
+
+ owner.getLookAndFeel()
+ .drawFileBrowserRow (g, width, height,
+ file.getFileName(),
+ icon,
+ fileSize, modTime,
+ isDirectory, isSelected());
+ }
+
+ void itemClicked (const MouseEvent& e)
+ {
+ owner.sendMouseClickMessage (file, e);
+ }
+
+ void itemDoubleClicked (const MouseEvent& e)
+ {
+ TreeViewItem::itemDoubleClicked (e);
+
+ owner.sendDoubleClickMessage (file);
+ }
+
+ void itemSelectionChanged (bool)
+ {
+ owner.sendSelectionChangeMessage();
+ }
+
+ bool useTimeSlice()
+ {
+ updateIcon (false);
+ thread.removeTimeSliceClient (this);
+ return false;
+ }
+
+ void handleAsyncUpdate()
+ {
+ owner.repaint();
+ }
+
+ const File file;
+
+ juce_UseDebuggingNewOperator
+
+private:
+ FileTreeComponent& owner;
+ DirectoryContentsList* parentContentsList;
+ int indexInContentsList;
+ DirectoryContentsList* subContentsList;
+ bool isDirectory, canDeleteSubContentsList;
+ TimeSliceThread& thread;
+ Image* icon;
+ String fileSize;
+ String modTime;
+
+ void updateIcon (const bool onlyUpdateIfCached) throw()
+ {
+ if (icon == 0)
+ {
+ const int hashCode = (file.getFullPathName() + T("_iconCacheSalt")).hashCode();
+ Image* im = ImageCache::getFromHashCode (hashCode);
+
+ if (im == 0 && ! onlyUpdateIfCached)
+ {
+ im = juce_createIconForFile (file);
+
+ if (im != 0)
+ ImageCache::addImageToCache (im, hashCode);
+ }
+
+ if (im != 0)
+ {
+ icon = im;
+ triggerAsyncUpdate();
+ }
+ }
+ }
+};
+
+FileTreeComponent::FileTreeComponent (DirectoryContentsList& listToShow)
+ : DirectoryContentsDisplayComponent (listToShow)
+{
+ FileListTreeItem* const root
+ = new FileListTreeItem (*this, 0, 0, listToShow.getDirectory(),
+ listToShow.getTimeSliceThread());
+
+ root->setSubContentsList (&listToShow);
+ setRootItemVisible (false);
+ setRootItem (root);
+}
+
+FileTreeComponent::~FileTreeComponent()
+{
+ TreeViewItem* const root = getRootItem();
+ setRootItem (0);
+ delete root;
+}
+
+const File FileTreeComponent::getSelectedFile() const
+{
+ return getSelectedFile (0);
+}
+
+const File FileTreeComponent::getSelectedFile (const int index) const throw()
+{
+ const FileListTreeItem* const item = dynamic_cast (getSelectedItem (index));
+
+ if (item != 0)
+ return item->file;
+
+ return File::nonexistent;
+}
+
+void FileTreeComponent::scrollToTop()
+{
+ getViewport()->getVerticalScrollBar()->setCurrentRangeStart (0);
+}
+
+void FileTreeComponent::setDragAndDropDescription (const String& description) throw()
+{
+ dragAndDropDescription = description;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_FileTreeComponent.cpp *********/
+
+/********* Start of inlined file: juce_ImagePreviewComponent.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ImagePreviewComponent::ImagePreviewComponent()
+ : currentThumbnail (0)
+{
+}
+
+ImagePreviewComponent::~ImagePreviewComponent()
+{
+ delete currentThumbnail;
+}
+
+void ImagePreviewComponent::getThumbSize (int& w, int& h) const
+{
+ const int availableW = proportionOfWidth (0.97f);
+ const int availableH = getHeight() - 13 * 4;
+
+ const double scale = jmin (1.0,
+ availableW / (double) w,
+ availableH / (double) h);
+
+ w = roundDoubleToInt (scale * w);
+ h = roundDoubleToInt (scale * h);
+}
+
+void ImagePreviewComponent::selectedFileChanged (const File& file)
+{
+ if (fileToLoad != file)
+ {
+ fileToLoad = file;
+ startTimer (100);
+ }
+}
+
+void ImagePreviewComponent::timerCallback()
+{
+ stopTimer();
+
+ deleteAndZero (currentThumbnail);
+ currentDetails = String::empty;
+ repaint();
+
+ FileInputStream* const in = fileToLoad.createInputStream();
+
+ if (in != 0)
+ {
+ ImageFileFormat* const format = ImageFileFormat::findImageFormatForStream (*in);
+
+ if (format != 0)
+ {
+ currentThumbnail = format->decodeImage (*in);
+
+ if (currentThumbnail != 0)
+ {
+ int w = currentThumbnail->getWidth();
+ int h = currentThumbnail->getHeight();
+
+ currentDetails
+ << fileToLoad.getFileName() << "\n"
+ << format->getFormatName() << "\n"
+ << w << " x " << h << " pixels\n"
+ << File::descriptionOfSizeInBytes (fileToLoad.getSize());
+
+ getThumbSize (w, h);
+
+ Image* const reduced = currentThumbnail->createCopy (w, h);
+
+ delete currentThumbnail;
+ currentThumbnail = reduced;
+ }
+ }
+
+ delete in;
+ }
+}
+
+void ImagePreviewComponent::paint (Graphics& g)
+{
+ if (currentThumbnail != 0)
+ {
+ g.setFont (13.0f);
+
+ int w = currentThumbnail->getWidth();
+ int h = currentThumbnail->getHeight();
+ getThumbSize (w, h);
+
+ const int numLines = 4;
+ const int totalH = 13 * numLines + h + 4;
+ const int y = (getHeight() - totalH) / 2;
+
+ g.drawImageWithin (currentThumbnail,
+ (getWidth() - w) / 2, y, w, h,
+ RectanglePlacement::centred | RectanglePlacement::onlyReduceInSize,
+ false);
+
+ g.drawFittedText (currentDetails,
+ 0, y + h + 4, getWidth(), 100,
+ Justification::centredTop, numLines);
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ImagePreviewComponent.cpp *********/
+
+/********* Start of inlined file: juce_WildcardFileFilter.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+WildcardFileFilter::WildcardFileFilter (const String& wildcardPatterns,
+ const String& description)
+ : FileFilter (description.isEmpty() ? wildcardPatterns
+ : (description + T(" (") + wildcardPatterns + T(")")))
+{
+ wildcards.addTokens (wildcardPatterns.toLowerCase(), T(";,"), T("\"'"));
+
+ wildcards.trim();
+ wildcards.removeEmptyStrings();
+
+ // special case for *.*, because people use it to mean "any file", but it
+ // would actually ignore files with no extension.
+ for (int i = wildcards.size(); --i >= 0;)
+ if (wildcards[i] == T("*.*"))
+ wildcards.set (i, T("*"));
+}
+
+WildcardFileFilter::~WildcardFileFilter()
+{
+}
+
+bool WildcardFileFilter::isFileSuitable (const File& file) const
+{
+ const String filename (file.getFileName());
+
+ for (int i = wildcards.size(); --i >= 0;)
+ if (filename.matchesWildcard (wildcards[i], true))
+ return true;
+
+ return false;
+}
+
+bool WildcardFileFilter::isDirectorySuitable (const File&) const
+{
+ return true;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_WildcardFileFilter.cpp *********/
+
+/********* Start of inlined file: juce_KeyboardFocusTraverser.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+KeyboardFocusTraverser::KeyboardFocusTraverser()
+{
+}
+
+KeyboardFocusTraverser::~KeyboardFocusTraverser()
+{
+}
+
+// This will sort a set of components, so that they are ordered in terms of
+// left-to-right and then top-to-bottom.
+class ScreenPositionComparator
+{
+public:
+ ScreenPositionComparator() {}
+
+ static int compareElements (const Component* const first, const Component* const second) throw()
+ {
+ int explicitOrder1 = first->getExplicitFocusOrder();
+ if (explicitOrder1 <= 0)
+ explicitOrder1 = INT_MAX / 2;
+
+ int explicitOrder2 = second->getExplicitFocusOrder();
+ if (explicitOrder2 <= 0)
+ explicitOrder2 = INT_MAX / 2;
+
+ if (explicitOrder1 != explicitOrder2)
+ return explicitOrder1 - explicitOrder2;
+
+ const int diff = first->getY() - second->getY();
+
+ return (diff == 0) ? first->getX() - second->getX()
+ : diff;
+ }
+};
+
+static void findAllFocusableComponents (Component* const parent, Array & comps)
+{
+ if (parent->getNumChildComponents() > 0)
+ {
+ Array localComps;
+ ScreenPositionComparator comparator;
+
+ int i;
+ for (i = parent->getNumChildComponents(); --i >= 0;)
+ {
+ Component* const c = parent->getChildComponent (i);
+
+ if (c->isVisible() && c->isEnabled())
+ localComps.addSorted (comparator, c);
+ }
+
+ for (i = 0; i < localComps.size(); ++i)
+ {
+ Component* const c = localComps.getUnchecked (i);
+
+ if (c->getWantsKeyboardFocus())
+ comps.add (c);
+
+ if (! c->isFocusContainer())
+ findAllFocusableComponents (c, comps);
+ }
+ }
+}
+
+static Component* getIncrementedComponent (Component* const current, const int delta) throw()
+{
+ Component* focusContainer = current->getParentComponent();
+
+ if (focusContainer != 0)
+ {
+ while (focusContainer->getParentComponent() != 0 && ! focusContainer->isFocusContainer())
+ focusContainer = focusContainer->getParentComponent();
+
+ if (focusContainer != 0)
+ {
+ Array comps;
+ findAllFocusableComponents (focusContainer, comps);
+
+ if (comps.size() > 0)
+ {
+ const int index = comps.indexOf (current);
+ return comps [(index + comps.size() + delta) % comps.size()];
+ }
+ }
+ }
+
+ return 0;
+}
+
+Component* KeyboardFocusTraverser::getNextComponent (Component* current)
+{
+ return getIncrementedComponent (current, 1);
+}
+
+Component* KeyboardFocusTraverser::getPreviousComponent (Component* current)
+{
+ return getIncrementedComponent (current, -1);
+}
+
+Component* KeyboardFocusTraverser::getDefaultComponent (Component* parentComponent)
+{
+ Array comps;
+
+ if (parentComponent != 0)
+ findAllFocusableComponents (parentComponent, comps);
+
+ return comps.getFirst();
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_KeyboardFocusTraverser.cpp *********/
+
+/********* Start of inlined file: juce_KeyListener.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+bool KeyListener::keyStateChanged (Component*)
+{
+ return false;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_KeyListener.cpp *********/
+
+/********* Start of inlined file: juce_KeyMappingEditorComponent.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+// N.B. these two includes are put here deliberately to avoid problems with
+// old GCCs failing on long include paths
+
+const int maxKeys = 3;
+
+class KeyMappingChangeButton : public Button
+{
+public:
+ KeyMappingChangeButton (KeyMappingEditorComponent* const owner_,
+ const CommandID commandID_,
+ const String& keyName,
+ const int keyNum_)
+ : Button (keyName),
+ owner (owner_),
+ commandID (commandID_),
+ keyNum (keyNum_)
+ {
+ setWantsKeyboardFocus (false);
+ setTriggeredOnMouseDown (keyNum >= 0);
+
+ if (keyNum_ < 0)
+ setTooltip (TRANS("adds a new key-mapping"));
+ else
+ setTooltip (TRANS("click to change this key-mapping"));
+ }
+
+ ~KeyMappingChangeButton()
+ {
+ }
+
+ void paintButton (Graphics& g, bool isOver, bool isDown)
+ {
+ if (keyNum >= 0)
+ {
+ if (isEnabled())
+ {
+ const float alpha = isDown ? 0.3f : (isOver ? 0.15f : 0.08f);
+ g.fillAll (owner->textColour.withAlpha (alpha));
+
+ g.setOpacity (0.3f);
+ g.drawBevel (0, 0, getWidth(), getHeight(), 2);
+ }
+
+ g.setColour (owner->textColour);
+ g.setFont (getHeight() * 0.6f);
+ g.drawFittedText (getName(),
+ 3, 0, getWidth() - 6, getHeight(),
+ Justification::centred, 1);
+ }
+ else
+ {
+ const float thickness = 7.0f;
+ const float indent = 22.0f;
+
+ Path p;
+ p.addEllipse (0.0f, 0.0f, 100.0f, 100.0f);
+ p.addRectangle (indent, 50.0f - thickness, 100.0f - indent * 2.0f, thickness * 2.0f);
+ p.addRectangle (50.0f - thickness, indent, thickness * 2.0f, 50.0f - indent - thickness);
+ p.addRectangle (50.0f - thickness, 50.0f + thickness, thickness * 2.0f, 50.0f - indent - thickness);
+ p.setUsingNonZeroWinding (false);
+
+ g.setColour (owner->textColour.withAlpha (isDown ? 0.7f : (isOver ? 0.5f : 0.3f)));
+ g.fillPath (p, p.getTransformToScaleToFit (2.0f, 2.0f, getWidth() - 4.0f, getHeight() - 4.0f, true));
+ }
+
+ if (hasKeyboardFocus (false))
+ {
+ g.setColour (owner->textColour.withAlpha (0.4f));
+ g.drawRect (0, 0, getWidth(), getHeight());
+ }
+ }
+
+ void clicked()
+ {
+ if (keyNum >= 0)
+ {
+ // existing key clicked..
+ PopupMenu m;
+ m.addItem (1, TRANS("change this key-mapping"));
+ m.addSeparator();
+ m.addItem (2, TRANS("remove this key-mapping"));
+
+ const int res = m.show();
+
+ if (res == 1)
+ {
+ owner->assignNewKey (commandID, keyNum);
+ }
+ else if (res == 2)
+ {
+ owner->getMappings()->removeKeyPress (commandID, keyNum);
+ }
+ }
+ else
+ {
+ // + button pressed..
+ owner->assignNewKey (commandID, -1);
+ }
+ }
+
+ void fitToContent (const int h) throw()
+ {
+ if (keyNum < 0)
+ {
+ setSize (h, h);
+ }
+ else
+ {
+ Font f (h * 0.6f);
+ setSize (jlimit (h * 4, h * 8, 6 + f.getStringWidth (getName())), h);
+ }
+ }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ KeyMappingEditorComponent* const owner;
+ const CommandID commandID;
+ const int keyNum;
+
+ KeyMappingChangeButton (const KeyMappingChangeButton&);
+ const KeyMappingChangeButton& operator= (const KeyMappingChangeButton&);
+};
+
+class KeyMappingItemComponent : public Component
+{
+public:
+ KeyMappingItemComponent (KeyMappingEditorComponent* const owner_,
+ const CommandID commandID_)
+ : owner (owner_),
+ commandID (commandID_)
+ {
+ setInterceptsMouseClicks (false, true);
+
+ const bool isReadOnly = owner_->isCommandReadOnly (commandID);
+
+ const Array keyPresses (owner_->getMappings()->getKeyPressesAssignedToCommand (commandID));
+
+ for (int i = 0; i < jmin (maxKeys, keyPresses.size()); ++i)
+ {
+ KeyMappingChangeButton* const kb
+ = new KeyMappingChangeButton (owner_, commandID,
+ owner_->getDescriptionForKeyPress (keyPresses.getReference (i)), i);
+
+ kb->setEnabled (! isReadOnly);
+ addAndMakeVisible (kb);
+ }
+
+ KeyMappingChangeButton* const kb
+ = new KeyMappingChangeButton (owner_, commandID, String::empty, -1);
+
+ addChildComponent (kb);
+ kb->setVisible (keyPresses.size() < maxKeys && ! isReadOnly);
+ }
+
+ ~KeyMappingItemComponent()
+ {
+ deleteAllChildren();
+ }
+
+ void paint (Graphics& g)
+ {
+ g.setFont (getHeight() * 0.7f);
+ g.setColour (owner->textColour);
+
+ g.drawFittedText (owner->getMappings()->getCommandManager()->getNameOfCommand (commandID),
+ 4, 0, jmax (40, getChildComponent (0)->getX() - 5), getHeight(),
+ Justification::centredLeft, true);
+ }
+
+ void resized()
+ {
+ int x = getWidth() - 4;
+
+ for (int i = getNumChildComponents(); --i >= 0;)
+ {
+ KeyMappingChangeButton* const kb = dynamic_cast (getChildComponent (i));
+
+ kb->fitToContent (getHeight() - 2);
+ kb->setTopRightPosition (x, 1);
+ x -= kb->getWidth() + 5;
+ }
+ }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ KeyMappingEditorComponent* const owner;
+ const CommandID commandID;
+
+ KeyMappingItemComponent (const KeyMappingItemComponent&);
+ const KeyMappingItemComponent& operator= (const KeyMappingItemComponent&);
+};
+
+class KeyMappingTreeViewItem : public TreeViewItem
+{
+public:
+ KeyMappingTreeViewItem (KeyMappingEditorComponent* const owner_,
+ const CommandID commandID_)
+ : owner (owner_),
+ commandID (commandID_)
+ {
+ }
+
+ ~KeyMappingTreeViewItem()
+ {
+ }
+
+ const String getUniqueName() const { return String ((int) commandID) + "_id"; }
+ bool mightContainSubItems() { return false; }
+ int getItemHeight() const { return 20; }
+
+ Component* createItemComponent()
+ {
+ return new KeyMappingItemComponent (owner, commandID);
+ }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ KeyMappingEditorComponent* const owner;
+ const CommandID commandID;
+
+ KeyMappingTreeViewItem (const KeyMappingTreeViewItem&);
+ const KeyMappingTreeViewItem& operator= (const KeyMappingTreeViewItem&);
+};
+
+class KeyCategoryTreeViewItem : public TreeViewItem
+{
+public:
+ KeyCategoryTreeViewItem (KeyMappingEditorComponent* const owner_,
+ const String& name)
+ : owner (owner_),
+ categoryName (name)
+ {
+ }
+
+ ~KeyCategoryTreeViewItem()
+ {
+ }
+
+ const String getUniqueName() const { return categoryName + "_cat"; }
+ bool mightContainSubItems() { return true; }
+ int getItemHeight() const { return 28; }
+
+ void paintItem (Graphics& g, int width, int height)
+ {
+ g.setFont (height * 0.6f, Font::bold);
+ g.setColour (owner->textColour);
+
+ g.drawText (categoryName,
+ 2, 0, width - 2, height,
+ Justification::centredLeft, true);
+ }
+
+ void itemOpennessChanged (bool isNowOpen)
+ {
+ if (isNowOpen)
+ {
+ if (getNumSubItems() == 0)
+ {
+ Array commands (owner->getMappings()->getCommandManager()->getCommandsInCategory (categoryName));
+
+ for (int i = 0; i < commands.size(); ++i)
+ {
+ if (owner->shouldCommandBeIncluded (commands[i]))
+ addSubItem (new KeyMappingTreeViewItem (owner, commands[i]));
+ }
+ }
+ }
+ else
+ {
+ clearSubItems();
+ }
+ }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ KeyMappingEditorComponent* owner;
+ String categoryName;
+
+ KeyCategoryTreeViewItem (const KeyCategoryTreeViewItem&);
+ const KeyCategoryTreeViewItem& operator= (const KeyCategoryTreeViewItem&);
+};
+
+KeyMappingEditorComponent::KeyMappingEditorComponent (KeyPressMappingSet* const mappingManager,
+ const bool showResetToDefaultButton)
+ : mappings (mappingManager),
+ textColour (Colours::black)
+{
+ jassert (mappingManager != 0); // can't be null!
+
+ mappingManager->addChangeListener (this);
+
+ setLinesDrawnForSubItems (false);
+
+ resetButton = 0;
+
+ if (showResetToDefaultButton)
+ {
+ addAndMakeVisible (resetButton = new TextButton (TRANS("reset to defaults")));
+ resetButton->addButtonListener (this);
+ }
+
+ addAndMakeVisible (tree = new TreeView());
+ tree->setColour (TreeView::backgroundColourId, backgroundColour);
+ tree->setRootItemVisible (false);
+ tree->setDefaultOpenness (true);
+ tree->setRootItem (this);
+}
+
+KeyMappingEditorComponent::~KeyMappingEditorComponent()
+{
+ mappings->removeChangeListener (this);
+ deleteAllChildren();
+}
+
+bool KeyMappingEditorComponent::mightContainSubItems()
+{
+ return true;
+}
+
+const String KeyMappingEditorComponent::getUniqueName() const
+{
+ return T("keys");
+}
+
+void KeyMappingEditorComponent::setColours (const Colour& mainBackground,
+ const Colour& textColour_)
+{
+ backgroundColour = mainBackground;
+ textColour = textColour_;
+ tree->setColour (TreeView::backgroundColourId, backgroundColour);
+}
+
+void KeyMappingEditorComponent::parentHierarchyChanged()
+{
+ changeListenerCallback (0);
+}
+
+void KeyMappingEditorComponent::resized()
+{
+ int h = getHeight();
+
+ if (resetButton != 0)
+ {
+ const int buttonHeight = 20;
+ h -= buttonHeight + 8;
+ int x = getWidth() - 8;
+ const int y = h + 6;
+
+ resetButton->changeWidthToFitText (buttonHeight);
+ resetButton->setTopRightPosition (x, y);
+ }
+
+ tree->setBounds (0, 0, getWidth(), h);
+}
+
+void KeyMappingEditorComponent::buttonClicked (Button* button)
+{
+ if (button == resetButton)
+ {
+ if (AlertWindow::showOkCancelBox (AlertWindow::QuestionIcon,
+ TRANS("Reset to defaults"),
+ TRANS("Are you sure you want to reset all the key-mappings to their default state?"),
+ TRANS("Reset")))
+ {
+ mappings->resetToDefaultMappings();
+ }
+ }
+}
+
+void KeyMappingEditorComponent::changeListenerCallback (void*)
+{
+ XmlElement* openness = tree->getOpennessState (true);
+
+ clearSubItems();
+
+ const StringArray categories (mappings->getCommandManager()->getCommandCategories());
+
+ for (int i = 0; i < categories.size(); ++i)
+ {
+ const Array commands (mappings->getCommandManager()->getCommandsInCategory (categories[i]));
+ int count = 0;
+
+ for (int j = 0; j < commands.size(); ++j)
+ if (shouldCommandBeIncluded (commands[j]))
+ ++count;
+
+ if (count > 0)
+ addSubItem (new KeyCategoryTreeViewItem (this, categories[i]));
+ }
+
+ if (openness != 0)
+ {
+ tree->restoreOpennessState (*openness);
+ delete openness;
+ }
+}
+
+class KeyEntryWindow : public AlertWindow
+{
+public:
+ KeyEntryWindow (KeyMappingEditorComponent* const owner_)
+ : AlertWindow (TRANS("New key-mapping"),
+ TRANS("Please press a key combination now..."),
+ AlertWindow::NoIcon),
+ owner (owner_)
+ {
+ addButton (TRANS("ok"), 1);
+ addButton (TRANS("cancel"), 0);
+
+ // (avoid return + escape keys getting processed by the buttons..)
+ for (int i = getNumChildComponents(); --i >= 0;)
+ getChildComponent (i)->setWantsKeyboardFocus (false);
+
+ setWantsKeyboardFocus (true);
+ grabKeyboardFocus();
+ }
+
+ ~KeyEntryWindow()
+ {
+ }
+
+ bool keyPressed (const KeyPress& key)
+ {
+ lastPress = key;
+ String message (TRANS("Key: ") + owner->getDescriptionForKeyPress (key));
+
+ const CommandID previousCommand = owner->getMappings()->findCommandForKeyPress (key);
+
+ if (previousCommand != 0)
+ {
+ message << "\n\n"
+ << TRANS("(Currently assigned to \"")
+ << owner->getMappings()->getCommandManager()->getNameOfCommand (previousCommand)
+ << "\")";
+ }
+
+ setMessage (message);
+
+ return true;
+ }
+
+ bool keyStateChanged()
+ {
+ return true;
+ }
+
+ KeyPress lastPress;
+
+ juce_UseDebuggingNewOperator
+
+private:
+ KeyMappingEditorComponent* owner;
+
+ KeyEntryWindow (const KeyEntryWindow&);
+ const KeyEntryWindow& operator= (const KeyEntryWindow&);
+};
+
+void KeyMappingEditorComponent::assignNewKey (const CommandID commandID, const int index)
+{
+ KeyEntryWindow entryWindow (this);
+
+ if (entryWindow.runModalLoop() != 0)
+ {
+ entryWindow.setVisible (false);
+
+ if (entryWindow.lastPress.isValid())
+ {
+ const CommandID previousCommand = mappings->findCommandForKeyPress (entryWindow.lastPress);
+
+ if (previousCommand != 0)
+ {
+ if (! AlertWindow::showOkCancelBox (AlertWindow::WarningIcon,
+ TRANS("Change key-mapping"),
+ TRANS("This key is already assigned to the command \"")
+ + mappings->getCommandManager()->getNameOfCommand (previousCommand)
+ + TRANS("\"\n\nDo you want to re-assign it to this new command instead?"),
+ TRANS("re-assign"),
+ TRANS("cancel")))
+ {
+ return;
+ }
+ }
+
+ mappings->removeKeyPress (entryWindow.lastPress);
+
+ if (index >= 0)
+ mappings->removeKeyPress (commandID, index);
+
+ mappings->addKeyPress (commandID, entryWindow.lastPress, index);
+ }
+ }
+}
+
+bool KeyMappingEditorComponent::shouldCommandBeIncluded (const CommandID commandID)
+{
+ const ApplicationCommandInfo* const ci = mappings->getCommandManager()->getCommandForID (commandID);
+
+ return (ci != 0) && ((ci->flags & ApplicationCommandInfo::hiddenFromKeyEditor) == 0);
+}
+
+bool KeyMappingEditorComponent::isCommandReadOnly (const CommandID commandID)
+{
+ const ApplicationCommandInfo* const ci = mappings->getCommandManager()->getCommandForID (commandID);
+
+ return (ci != 0) && ((ci->flags & ApplicationCommandInfo::readOnlyInKeyEditor) != 0);
+}
+
+const String KeyMappingEditorComponent::getDescriptionForKeyPress (const KeyPress& key)
+{
+ return key.getTextDescription();
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_KeyMappingEditorComponent.cpp *********/
+
+/********* Start of inlined file: juce_KeyPress.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+KeyPress::KeyPress() throw()
+ : keyCode (0),
+ mods (0),
+ textCharacter (0)
+{
+}
+
+KeyPress::KeyPress (const int keyCode_,
+ const ModifierKeys& mods_,
+ const juce_wchar textCharacter_) throw()
+ : keyCode (keyCode_),
+ mods (mods_),
+ textCharacter (textCharacter_)
+{
+}
+
+KeyPress::KeyPress (const int keyCode_) throw()
+ : keyCode (keyCode_),
+ textCharacter (0)
+{
+}
+
+KeyPress::KeyPress (const KeyPress& other) throw()
+ : keyCode (other.keyCode),
+ mods (other.mods),
+ textCharacter (other.textCharacter)
+{
+}
+
+const KeyPress& KeyPress::operator= (const KeyPress& other) throw()
+{
+ keyCode = other.keyCode;
+ mods = other.mods;
+ textCharacter = other.textCharacter;
+
+ return *this;
+}
+
+bool KeyPress::operator== (const KeyPress& other) const throw()
+{
+ return mods.getRawFlags() == other.mods.getRawFlags()
+ && (textCharacter == other.textCharacter
+ || textCharacter == 0
+ || other.textCharacter == 0)
+ && (keyCode == other.keyCode
+ || (keyCode < 256
+ && other.keyCode < 256
+ && CharacterFunctions::toLowerCase ((tchar) keyCode)
+ == CharacterFunctions::toLowerCase ((tchar) other.keyCode)));
+}
+
+bool KeyPress::operator!= (const KeyPress& other) const throw()
+{
+ return ! operator== (other);
+}
+
+bool KeyPress::isCurrentlyDown() const throw()
+{
+ return isKeyCurrentlyDown (keyCode)
+ && (ModifierKeys::getCurrentModifiers().getRawFlags() & ModifierKeys::allKeyboardModifiers)
+ == (mods.getRawFlags() & ModifierKeys::allKeyboardModifiers);
+}
+
+struct KeyNameAndCode
+{
+ const char* name;
+ int code;
+};
+
+static const KeyNameAndCode keyNameTranslations[] =
+{
+ { "spacebar", KeyPress::spaceKey },
+ { "return", KeyPress::returnKey },
+ { "escape", KeyPress::escapeKey },
+ { "backspace", KeyPress::backspaceKey },
+ { "cursor left", KeyPress::leftKey },
+ { "cursor right", KeyPress::rightKey },
+ { "cursor up", KeyPress::upKey },
+ { "cursor down", KeyPress::downKey },
+ { "page up", KeyPress::pageUpKey },
+ { "page down", KeyPress::pageDownKey },
+ { "home", KeyPress::homeKey },
+ { "end", KeyPress::endKey },
+ { "delete", KeyPress::deleteKey },
+ { "insert", KeyPress::insertKey },
+ { "tab", KeyPress::tabKey },
+ { "play", KeyPress::playKey },
+ { "stop", KeyPress::stopKey },
+ { "fast forward", KeyPress::fastForwardKey },
+ { "rewind", KeyPress::rewindKey }
+};
+
+static const tchar* const numberPadPrefix = T("numpad ");
+
+const KeyPress KeyPress::createFromDescription (const String& desc) throw()
+{
+ int modifiers = 0;
+
+ if (desc.containsWholeWordIgnoreCase (T("ctrl"))
+ || desc.containsWholeWordIgnoreCase (T("control"))
+ || desc.containsWholeWordIgnoreCase (T("ctl")))
+ modifiers |= ModifierKeys::ctrlModifier;
+
+ if (desc.containsWholeWordIgnoreCase (T("shift"))
+ || desc.containsWholeWordIgnoreCase (T("shft")))
+ modifiers |= ModifierKeys::shiftModifier;
+
+ if (desc.containsWholeWordIgnoreCase (T("alt"))
+ || desc.containsWholeWordIgnoreCase (T("option")))
+ modifiers |= ModifierKeys::altModifier;
+
+ if (desc.containsWholeWordIgnoreCase (T("command"))
+ || desc.containsWholeWordIgnoreCase (T("cmd")))
+ modifiers |= ModifierKeys::commandModifier;
+
+ int key = 0;
+
+ for (int i = 0; i < numElementsInArray (keyNameTranslations); ++i)
+ {
+ if (desc.containsWholeWordIgnoreCase (String (keyNameTranslations[i].name)))
+ {
+ key = keyNameTranslations[i].code;
+ break;
+ }
+ }
+
+ if (key == 0)
+ {
+ // see if it's a numpad key..
+ if (desc.containsIgnoreCase (numberPadPrefix))
+ {
+ const tchar lastChar = desc.trimEnd().getLastCharacter();
+
+ if (lastChar >= T('0') && lastChar <= T('9'))
+ key = numberPad0 + lastChar - T('0');
+ else if (lastChar == T('+'))
+ key = numberPadAdd;
+ else if (lastChar == T('-'))
+ key = numberPadSubtract;
+ else if (lastChar == T('*'))
+ key = numberPadMultiply;
+ else if (lastChar == T('/'))
+ key = numberPadDivide;
+ else if (lastChar == T('.'))
+ key = numberPadDecimalPoint;
+ else if (lastChar == T('='))
+ key = numberPadEquals;
+ else if (desc.endsWith (T("separator")))
+ key = numberPadSeparator;
+ else if (desc.endsWith (T("delete")))
+ key = numberPadDelete;
+ }
+
+ if (key == 0)
+ {
+ // see if it's a function key..
+ for (int i = 1; i <= 12; ++i)
+ if (desc.containsWholeWordIgnoreCase (T("f") + String (i)))
+ key = F1Key + i - 1;
+
+ if (key == 0)
+ {
+ // give up and use the hex code..
+ const int hexCode = desc.fromFirstOccurrenceOf (T("#"), false, false)
+ .toLowerCase()
+ .retainCharacters (T("0123456789abcdef"))
+ .getHexValue32();
+
+ if (hexCode > 0)
+ key = hexCode;
+ else
+ key = CharacterFunctions::toUpperCase (desc.getLastCharacter());
+ }
+ }
+ }
+
+ return KeyPress (key, ModifierKeys (modifiers), 0);
+}
+
+const String KeyPress::getTextDescription() const throw()
+{
+ String desc;
+
+ if (keyCode > 0)
+ {
+ // some keyboard layouts use a shift-key to get the slash, but in those cases, we
+ // want to store it as being a slash, not shift+whatever.
+ if (textCharacter == T('/'))
+ return "/";
+
+ if (mods.isCtrlDown())
+ desc << "ctrl + ";
+
+ if (mods.isShiftDown())
+ desc << "shift + ";
+
+#if JUCE_MAC
+ // only do this on the mac, because on Windows ctrl and command are the same,
+ // and this would get confusing
+ if (mods.isCommandDown())
+ desc << "command + ";
+
+ if (mods.isAltDown())
+ desc << "option + ";
+#else
+ if (mods.isAltDown())
+ desc << "alt + ";
+#endif
+
+ for (int i = 0; i < numElementsInArray (keyNameTranslations); ++i)
+ if (keyCode == keyNameTranslations[i].code)
+ return desc + keyNameTranslations[i].name;
+
+ if (keyCode >= F1Key && keyCode <= F16Key)
+ desc << 'F' << (1 + keyCode - F1Key);
+ else if (keyCode >= numberPad0 && keyCode <= numberPad9)
+ desc << numberPadPrefix << (keyCode - numberPad0);
+ else if (keyCode >= 33 && keyCode < 176)
+ desc += CharacterFunctions::toUpperCase ((tchar) keyCode);
+ else if (keyCode == numberPadAdd)
+ desc << numberPadPrefix << '+';
+ else if (keyCode == numberPadSubtract)
+ desc << numberPadPrefix << '-';
+ else if (keyCode == numberPadMultiply)
+ desc << numberPadPrefix << '*';
+ else if (keyCode == numberPadDivide)
+ desc << numberPadPrefix << '/';
+ else if (keyCode == numberPadSeparator)
+ desc << numberPadPrefix << "separator";
+ else if (keyCode == numberPadDecimalPoint)
+ desc << numberPadPrefix << '.';
+ else if (keyCode == numberPadDelete)
+ desc << numberPadPrefix << "delete";
+ else
+ desc << '#' << String::toHexString (keyCode);
+ }
+
+ return desc;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_KeyPress.cpp *********/
+
+/********* Start of inlined file: juce_KeyPressMappingSet.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+KeyPressMappingSet::KeyPressMappingSet (ApplicationCommandManager* const commandManager_) throw()
+ : commandManager (commandManager_)
+{
+ // A manager is needed to get the descriptions of commands, and will be called when
+ // a command is invoked. So you can't leave this null..
+ jassert (commandManager_ != 0);
+
+ Desktop::getInstance().addFocusChangeListener (this);
+}
+
+KeyPressMappingSet::KeyPressMappingSet (const KeyPressMappingSet& other) throw()
+ : commandManager (other.commandManager)
+{
+ Desktop::getInstance().addFocusChangeListener (this);
+}
+
+KeyPressMappingSet::~KeyPressMappingSet()
+{
+ Desktop::getInstance().removeFocusChangeListener (this);
+}
+
+const Array KeyPressMappingSet::getKeyPressesAssignedToCommand (const CommandID commandID) const throw()
+{
+ for (int i = 0; i < mappings.size(); ++i)
+ if (mappings.getUnchecked(i)->commandID == commandID)
+ return mappings.getUnchecked (i)->keypresses;
+
+ return Array ();
+}
+
+void KeyPressMappingSet::addKeyPress (const CommandID commandID,
+ const KeyPress& newKeyPress,
+ int insertIndex) throw()
+{
+ if (findCommandForKeyPress (newKeyPress) != commandID)
+ {
+ removeKeyPress (newKeyPress);
+
+ if (newKeyPress.isValid())
+ {
+ for (int i = mappings.size(); --i >= 0;)
+ {
+ if (mappings.getUnchecked(i)->commandID == commandID)
+ {
+ mappings.getUnchecked(i)->keypresses.insert (insertIndex, newKeyPress);
+
+ sendChangeMessage (this);
+ return;
+ }
+ }
+
+ const ApplicationCommandInfo* const ci = commandManager->getCommandForID (commandID);
+
+ if (ci != 0)
+ {
+ CommandMapping* const cm = new CommandMapping();
+ cm->commandID = commandID;
+ cm->keypresses.add (newKeyPress);
+ cm->wantsKeyUpDownCallbacks = (ci->flags & ApplicationCommandInfo::wantsKeyUpDownCallbacks) != 0;
+
+ mappings.add (cm);
+ sendChangeMessage (this);
+ }
+ }
+ }
+}
+
+void KeyPressMappingSet::resetToDefaultMappings() throw()
+{
+ mappings.clear();
+
+ for (int i = 0; i < commandManager->getNumCommands(); ++i)
+ {
+ const ApplicationCommandInfo* const ci = commandManager->getCommandForIndex (i);
+
+ for (int j = 0; j < ci->defaultKeypresses.size(); ++j)
+ {
+ addKeyPress (ci->commandID,
+ ci->defaultKeypresses.getReference (j));
+ }
+ }
+
+ sendChangeMessage (this);
+}
+
+void KeyPressMappingSet::resetToDefaultMapping (const CommandID commandID) throw()
+{
+ clearAllKeyPresses (commandID);
+
+ const ApplicationCommandInfo* const ci = commandManager->getCommandForID (commandID);
+
+ for (int j = 0; j < ci->defaultKeypresses.size(); ++j)
+ {
+ addKeyPress (ci->commandID,
+ ci->defaultKeypresses.getReference (j));
+ }
+}
+
+void KeyPressMappingSet::clearAllKeyPresses() throw()
+{
+ if (mappings.size() > 0)
+ {
+ sendChangeMessage (this);
+ mappings.clear();
+ }
+}
+
+void KeyPressMappingSet::clearAllKeyPresses (const CommandID commandID) throw()
+{
+ for (int i = mappings.size(); --i >= 0;)
+ {
+ if (mappings.getUnchecked(i)->commandID == commandID)
+ {
+ mappings.remove (i);
+ sendChangeMessage (this);
+ }
+ }
+}
+
+void KeyPressMappingSet::removeKeyPress (const KeyPress& keypress) throw()
+{
+ if (keypress.isValid())
+ {
+ for (int i = mappings.size(); --i >= 0;)
+ {
+ CommandMapping* const cm = mappings.getUnchecked(i);
+
+ for (int j = cm->keypresses.size(); --j >= 0;)
+ {
+ if (keypress == cm->keypresses [j])
+ {
+ cm->keypresses.remove (j);
+ sendChangeMessage (this);
+ }
+ }
+ }
+ }
+}
+
+void KeyPressMappingSet::removeKeyPress (const CommandID commandID,
+ const int keyPressIndex) throw()
+{
+ for (int i = mappings.size(); --i >= 0;)
+ {
+ if (mappings.getUnchecked(i)->commandID == commandID)
+ {
+ mappings.getUnchecked(i)->keypresses.remove (keyPressIndex);
+ sendChangeMessage (this);
+ break;
+ }
+ }
+}
+
+CommandID KeyPressMappingSet::findCommandForKeyPress (const KeyPress& keyPress) const throw()
+{
+ for (int i = 0; i < mappings.size(); ++i)
+ if (mappings.getUnchecked(i)->keypresses.contains (keyPress))
+ return mappings.getUnchecked(i)->commandID;
+
+ return 0;
+}
+
+bool KeyPressMappingSet::containsMapping (const CommandID commandID,
+ const KeyPress& keyPress) const throw()
+{
+ for (int i = mappings.size(); --i >= 0;)
+ if (mappings.getUnchecked(i)->commandID == commandID)
+ return mappings.getUnchecked(i)->keypresses.contains (keyPress);
+
+ return false;
+}
+
+void KeyPressMappingSet::invokeCommand (const CommandID commandID,
+ const KeyPress& key,
+ const bool isKeyDown,
+ const int millisecsSinceKeyPressed,
+ Component* const originatingComponent) const
+{
+ ApplicationCommandTarget::InvocationInfo info (commandID);
+
+ info.invocationMethod = ApplicationCommandTarget::InvocationInfo::fromKeyPress;
+ info.isKeyDown = isKeyDown;
+ info.keyPress = key;
+ info.millisecsSinceKeyPressed = millisecsSinceKeyPressed;
+ info.originatingComponent = originatingComponent;
+
+ commandManager->invoke (info, false);
+}
+
+bool KeyPressMappingSet::restoreFromXml (const XmlElement& xmlVersion)
+{
+ if (xmlVersion.hasTagName (T("KEYMAPPINGS")))
+ {
+ if (xmlVersion.getBoolAttribute (T("basedOnDefaults"), true))
+ {
+ // if the XML was created as a set of differences from the default mappings,
+ // (i.e. by calling createXml (true)), then we need to first restore the defaults.
+ resetToDefaultMappings();
+ }
+ else
+ {
+ // if the XML was created calling createXml (false), then we need to clear all
+ // the keys and treat the xml as describing the entire set of mappings.
+ clearAllKeyPresses();
+ }
+
+ forEachXmlChildElement (xmlVersion, map)
+ {
+ const CommandID commandId = map->getStringAttribute (T("commandId")).getHexValue32();
+
+ if (commandId != 0)
+ {
+ const KeyPress key (KeyPress::createFromDescription (map->getStringAttribute (T("key"))));
+
+ if (map->hasTagName (T("MAPPING")))
+ {
+ addKeyPress (commandId, key);
+ }
+ else if (map->hasTagName (T("UNMAPPING")))
+ {
+ if (containsMapping (commandId, key))
+ removeKeyPress (key);
+ }
+ }
+ }
+
+ return true;
+ }
+
+ return false;
+}
+
+XmlElement* KeyPressMappingSet::createXml (const bool saveDifferencesFromDefaultSet) const
+{
+ KeyPressMappingSet* defaultSet = 0;
+
+ if (saveDifferencesFromDefaultSet)
+ {
+ defaultSet = new KeyPressMappingSet (commandManager);
+ defaultSet->resetToDefaultMappings();
+ }
+
+ XmlElement* const doc = new XmlElement (T("KEYMAPPINGS"));
+
+ doc->setAttribute (T("basedOnDefaults"), saveDifferencesFromDefaultSet);
+
+ int i;
+ for (i = 0; i < mappings.size(); ++i)
+ {
+ const CommandMapping* const cm = mappings.getUnchecked(i);
+
+ for (int j = 0; j < cm->keypresses.size(); ++j)
+ {
+ if (defaultSet == 0
+ || ! defaultSet->containsMapping (cm->commandID, cm->keypresses.getReference (j)))
+ {
+ XmlElement* const map = new XmlElement (T("MAPPING"));
+
+ map->setAttribute (T("commandId"), String::toHexString ((int) cm->commandID));
+ map->setAttribute (T("description"), commandManager->getDescriptionOfCommand (cm->commandID));
+ map->setAttribute (T("key"), cm->keypresses.getReference (j).getTextDescription());
+
+ doc->addChildElement (map);
+ }
+ }
+ }
+
+ if (defaultSet != 0)
+ {
+ for (i = 0; i < defaultSet->mappings.size(); ++i)
+ {
+ const CommandMapping* const cm = defaultSet->mappings.getUnchecked(i);
+
+ for (int j = 0; j < cm->keypresses.size(); ++j)
+ {
+ if (! containsMapping (cm->commandID, cm->keypresses.getReference (j)))
+ {
+ XmlElement* const map = new XmlElement (T("UNMAPPING"));
+
+ map->setAttribute (T("commandId"), String::toHexString ((int) cm->commandID));
+ map->setAttribute (T("description"), commandManager->getDescriptionOfCommand (cm->commandID));
+ map->setAttribute (T("key"), cm->keypresses.getReference (j).getTextDescription());
+
+ doc->addChildElement (map);
+ }
+ }
+ }
+
+ delete defaultSet;
+ }
+
+ return doc;
+}
+
+bool KeyPressMappingSet::keyPressed (const KeyPress& key,
+ Component* originatingComponent)
+{
+ bool used = false;
+
+ const CommandID commandID = findCommandForKeyPress (key);
+
+ const ApplicationCommandInfo* const ci = commandManager->getCommandForID (commandID);
+
+ if (ci != 0
+ && (ci->flags & ApplicationCommandInfo::wantsKeyUpDownCallbacks) == 0)
+ {
+ ApplicationCommandInfo info (0);
+
+ if (commandManager->getTargetForCommand (commandID, info) != 0
+ && (info.flags & ApplicationCommandInfo::isDisabled) == 0)
+ {
+ invokeCommand (commandID, key, true, 0, originatingComponent);
+ used = true;
+ }
+ else
+ {
+ if (originatingComponent != 0)
+ originatingComponent->getLookAndFeel().playAlertSound();
+ }
+ }
+
+ return used;
+}
+
+bool KeyPressMappingSet::keyStateChanged (Component* originatingComponent)
+{
+ bool used = false;
+ const uint32 now = Time::getMillisecondCounter();
+
+ for (int i = mappings.size(); --i >= 0;)
+ {
+ CommandMapping* const cm = mappings.getUnchecked(i);
+
+ if (cm->wantsKeyUpDownCallbacks)
+ {
+ for (int j = cm->keypresses.size(); --j >= 0;)
+ {
+ const KeyPress key (cm->keypresses.getReference (j));
+ const bool isDown = key.isCurrentlyDown();
+
+ int keyPressEntryIndex = 0;
+ bool wasDown = false;
+
+ for (int k = keysDown.size(); --k >= 0;)
+ {
+ if (key == keysDown.getUnchecked(k)->key)
+ {
+ keyPressEntryIndex = k;
+ wasDown = true;
+ break;
+ }
+ }
+
+ if (isDown != wasDown)
+ {
+ int millisecs = 0;
+
+ if (isDown)
+ {
+ KeyPressTime* const k = new KeyPressTime();
+ k->key = key;
+ k->timeWhenPressed = now;
+
+ keysDown.add (k);
+ }
+ else
+ {
+ const uint32 pressTime = keysDown.getUnchecked (keyPressEntryIndex)->timeWhenPressed;
+
+ if (now > pressTime)
+ millisecs = now - pressTime;
+
+ keysDown.remove (keyPressEntryIndex);
+ }
+
+ invokeCommand (cm->commandID, key, isDown, millisecs, originatingComponent);
+ used = true;
+ }
+ }
+ }
+ }
+
+ return used;
+}
+
+void KeyPressMappingSet::globalFocusChanged (Component* focusedComponent)
+{
+ if (focusedComponent != 0)
+ focusedComponent->keyStateChanged();
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_KeyPressMappingSet.cpp *********/
+
+/********* Start of inlined file: juce_ModifierKeys.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ModifierKeys::ModifierKeys (const int flags_) throw()
+ : flags (flags_)
+{
+}
+
+ModifierKeys::ModifierKeys (const ModifierKeys& other) throw()
+ : flags (other.flags)
+{
+}
+
+const ModifierKeys& ModifierKeys::operator= (const ModifierKeys& other) throw()
+{
+ flags = other.flags;
+ return *this;
+}
+
+int ModifierKeys::currentModifierFlags = 0;
+
+const ModifierKeys ModifierKeys::getCurrentModifiers() throw()
+{
+ return ModifierKeys (currentModifierFlags);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ModifierKeys.cpp *********/
+
+/********* Start of inlined file: juce_ComponentAnimator.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+struct AnimationTask
+{
+ AnimationTask (Component* const comp)
+ : component (comp),
+ watcher (comp)
+ {
+ }
+
+ Component* component;
+ ComponentDeletionWatcher watcher;
+ Rectangle destination;
+ int msElapsed, msTotal;
+ double startSpeed, midSpeed, endSpeed, lastProgress;
+ double left, top, right, bottom;
+
+ bool useTimeslice (const int elapsed)
+ {
+ if (watcher.hasBeenDeleted())
+ return false;
+
+ msElapsed += elapsed;
+ double newProgress = msElapsed / (double) msTotal;
+
+ if (newProgress >= 0 && newProgress < 1.0)
+ {
+ newProgress = timeToDistance (newProgress);
+ const double delta = (newProgress - lastProgress) / (1.0 - lastProgress);
+ jassert (newProgress >= lastProgress);
+ lastProgress = newProgress;
+
+ left += (destination.getX() - left) * delta;
+ top += (destination.getY() - top) * delta;
+ right += (destination.getRight() - right) * delta;
+ bottom += (destination.getBottom() - bottom) * delta;
+
+ if (delta < 1.0)
+ {
+ const Rectangle newBounds (roundDoubleToInt (left),
+ roundDoubleToInt (top),
+ roundDoubleToInt (right - left),
+ roundDoubleToInt (bottom - top));
+
+ if (newBounds != destination)
+ {
+ component->setBounds (newBounds);
+ return true;
+ }
+ }
+ }
+
+ component->setBounds (destination);
+ return false;
+ }
+
+ void moveToFinalDestination()
+ {
+ if (! watcher.hasBeenDeleted())
+ component->setBounds (destination);
+ }
+
+private:
+ inline double timeToDistance (const double time) const
+ {
+ return (time < 0.5) ? time * (startSpeed + time * (midSpeed - startSpeed))
+ : 0.5 * (startSpeed + 0.5 * (midSpeed - startSpeed))
+ + (time - 0.5) * (midSpeed + (time - 0.5) * (endSpeed - midSpeed));
+ }
+};
+
+ComponentAnimator::ComponentAnimator()
+ : lastTime (0)
+{
+}
+
+ComponentAnimator::~ComponentAnimator()
+{
+ cancelAllAnimations (false);
+ jassert (tasks.size() == 0);
+}
+
+void* ComponentAnimator::findTaskFor (Component* const component) const
+{
+ for (int i = tasks.size(); --i >= 0;)
+ if (component == ((AnimationTask*) tasks.getUnchecked(i))->component)
+ return tasks.getUnchecked(i);
+
+ return 0;
+}
+
+void ComponentAnimator::animateComponent (Component* const component,
+ const Rectangle& finalPosition,
+ const int millisecondsToSpendMoving,
+ const double startSpeed,
+ const double endSpeed)
+{
+ if (component != 0)
+ {
+ AnimationTask* at = (AnimationTask*) findTaskFor (component);
+
+ if (at == 0)
+ {
+ at = new AnimationTask (component);
+ tasks.add (at);
+ }
+
+ at->msElapsed = 0;
+ at->lastProgress = 0;
+ at->msTotal = jmax (1, millisecondsToSpendMoving);
+ at->destination = finalPosition;
+
+ // the speeds must be 0 or greater!
+ jassert (startSpeed >= 0 && endSpeed >= 0)
+
+ const double invTotalDistance = 4.0 / (startSpeed + endSpeed + 2.0);
+ at->startSpeed = jmax (0.0, startSpeed * invTotalDistance);
+ at->midSpeed = invTotalDistance;
+ at->endSpeed = jmax (0.0, endSpeed * invTotalDistance);
+
+ at->left = component->getX();
+ at->top = component->getY();
+ at->right = component->getRight();
+ at->bottom = component->getBottom();
+
+ if (! isTimerRunning())
+ {
+ lastTime = Time::getMillisecondCounter();
+ startTimer (1000 / 50);
+ }
+ }
+}
+
+void ComponentAnimator::cancelAllAnimations (const bool moveComponentsToTheirFinalPositions)
+{
+ for (int i = tasks.size(); --i >= 0;)
+ {
+ AnimationTask* const at = (AnimationTask*) tasks.getUnchecked(i);
+
+ if (moveComponentsToTheirFinalPositions)
+ at->moveToFinalDestination();
+
+ delete at;
+ tasks.remove (i);
+ }
+}
+
+void ComponentAnimator::cancelAnimation (Component* const component,
+ const bool moveComponentToItsFinalPosition)
+{
+ AnimationTask* const at = (AnimationTask*) findTaskFor (component);
+
+ if (at != 0)
+ {
+ if (moveComponentToItsFinalPosition)
+ at->moveToFinalDestination();
+
+ tasks.removeValue (at);
+ delete at;
+ }
+}
+
+const Rectangle ComponentAnimator::getComponentDestination (Component* const component)
+{
+ AnimationTask* const at = (AnimationTask*) findTaskFor (component);
+
+ if (at != 0)
+ return at->destination;
+ else if (component != 0)
+ return component->getBounds();
+
+ return Rectangle();
+}
+
+void ComponentAnimator::timerCallback()
+{
+ const uint32 timeNow = Time::getMillisecondCounter();
+
+ if (lastTime == 0 || lastTime == timeNow)
+ lastTime = timeNow;
+
+ const int elapsed = timeNow - lastTime;
+
+ for (int i = tasks.size(); --i >= 0;)
+ {
+ AnimationTask* const at = (AnimationTask*) tasks.getUnchecked(i);
+
+ if (! at->useTimeslice (elapsed))
+ {
+ tasks.remove (i);
+ delete at;
+ }
+ }
+
+ lastTime = timeNow;
+
+ if (tasks.size() == 0)
+ stopTimer();
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ComponentAnimator.cpp *********/
+
+/********* Start of inlined file: juce_ComponentBoundsConstrainer.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ComponentBoundsConstrainer::ComponentBoundsConstrainer() throw()
+ : minW (0),
+ maxW (0x3fffffff),
+ minH (0),
+ maxH (0x3fffffff),
+ minOffTop (0),
+ minOffLeft (0),
+ minOffBottom (0),
+ minOffRight (0),
+ aspectRatio (0.0)
+{
+}
+
+ComponentBoundsConstrainer::~ComponentBoundsConstrainer()
+{
+}
+
+void ComponentBoundsConstrainer::setMinimumWidth (const int minimumWidth) throw()
+{
+ minW = minimumWidth;
+}
+
+void ComponentBoundsConstrainer::setMaximumWidth (const int maximumWidth) throw()
+{
+ maxW = maximumWidth;
+}
+
+void ComponentBoundsConstrainer::setMinimumHeight (const int minimumHeight) throw()
+{
+ minH = minimumHeight;
+}
+
+void ComponentBoundsConstrainer::setMaximumHeight (const int maximumHeight) throw()
+{
+ maxH = maximumHeight;
+}
+
+void ComponentBoundsConstrainer::setMinimumSize (const int minimumWidth, const int minimumHeight) throw()
+{
+ jassert (maxW >= minimumWidth);
+ jassert (maxH >= minimumHeight);
+ jassert (minimumWidth > 0 && minimumHeight > 0);
+
+ minW = minimumWidth;
+ minH = minimumHeight;
+
+ if (minW > maxW)
+ maxW = minW;
+
+ if (minH > maxH)
+ maxH = minH;
+}
+
+void ComponentBoundsConstrainer::setMaximumSize (const int maximumWidth, const int maximumHeight) throw()
+{
+ jassert (maximumWidth >= minW);
+ jassert (maximumHeight >= minH);
+ jassert (maximumWidth > 0 && maximumHeight > 0);
+
+ maxW = jmax (minW, maximumWidth);
+ maxH = jmax (minH, maximumHeight);
+}
+
+void ComponentBoundsConstrainer::setSizeLimits (const int minimumWidth,
+ const int minimumHeight,
+ const int maximumWidth,
+ const int maximumHeight) throw()
+{
+ jassert (maximumWidth >= minimumWidth);
+ jassert (maximumHeight >= minimumHeight);
+ jassert (maximumWidth > 0 && maximumHeight > 0);
+ jassert (minimumWidth > 0 && minimumHeight > 0);
+
+ minW = jmax (0, minimumWidth);
+ minH = jmax (0, minimumHeight);
+ maxW = jmax (minW, maximumWidth);
+ maxH = jmax (minH, maximumHeight);
+}
+
+void ComponentBoundsConstrainer::setMinimumOnscreenAmounts (const int minimumWhenOffTheTop,
+ const int minimumWhenOffTheLeft,
+ const int minimumWhenOffTheBottom,
+ const int minimumWhenOffTheRight) throw()
+{
+ minOffTop = minimumWhenOffTheTop;
+ minOffLeft = minimumWhenOffTheLeft;
+ minOffBottom = minimumWhenOffTheBottom;
+ minOffRight = minimumWhenOffTheRight;
+}
+
+void ComponentBoundsConstrainer::setFixedAspectRatio (const double widthOverHeight) throw()
+{
+ aspectRatio = jmax (0.0, widthOverHeight);
+}
+
+double ComponentBoundsConstrainer::getFixedAspectRatio() const throw()
+{
+ return aspectRatio;
+}
+
+void ComponentBoundsConstrainer::setBoundsForComponent (Component* const component,
+ int x, int y, int w, int h,
+ const bool isStretchingTop,
+ const bool isStretchingLeft,
+ const bool isStretchingBottom,
+ const bool isStretchingRight)
+{
+ jassert (component != 0);
+
+ Rectangle limits;
+ Component* const p = component->getParentComponent();
+
+ if (p == 0)
+ limits = Desktop::getInstance().getAllMonitorDisplayAreas().getBounds();
+ else
+ limits.setSize (p->getWidth(), p->getHeight());
+
+ if (component->isOnDesktop())
+ {
+ ComponentPeer* const peer = component->getPeer();
+ const BorderSize border (peer->getFrameSize());
+
+ x -= border.getLeft();
+ y -= border.getTop();
+ w += border.getLeftAndRight();
+ h += border.getTopAndBottom();
+
+ checkBounds (x, y, w, h,
+ border.addedTo (component->getBounds()), limits,
+ isStretchingTop, isStretchingLeft,
+ isStretchingBottom, isStretchingRight);
+
+ x += border.getLeft();
+ y += border.getTop();
+ w -= border.getLeftAndRight();
+ h -= border.getTopAndBottom();
+ }
+ else
+ {
+ checkBounds (x, y, w, h,
+ component->getBounds(), limits,
+ isStretchingTop, isStretchingLeft,
+ isStretchingBottom, isStretchingRight);
+ }
+
+ applyBoundsToComponent (component, x, y, w, h);
+}
+
+void ComponentBoundsConstrainer::applyBoundsToComponent (Component* component,
+ int x, int y, int w, int h)
+{
+ component->setBounds (x, y, w, h);
+}
+
+void ComponentBoundsConstrainer::resizeStart()
+{
+}
+
+void ComponentBoundsConstrainer::resizeEnd()
+{
+}
+
+void ComponentBoundsConstrainer::checkBounds (int& x, int& y, int& w, int& h,
+ const Rectangle& old,
+ const Rectangle& limits,
+ const bool isStretchingTop,
+ const bool isStretchingLeft,
+ const bool isStretchingBottom,
+ const bool isStretchingRight)
+{
+ // constrain the size if it's being stretched..
+ if (isStretchingLeft)
+ {
+ x = jlimit (old.getRight() - maxW, old.getRight() - minW, x);
+ w = old.getRight() - x;
+ }
+
+ if (isStretchingRight)
+ {
+ w = jlimit (minW, maxW, w);
+ }
+
+ if (isStretchingTop)
+ {
+ y = jlimit (old.getBottom() - maxH, old.getBottom() - minH, y);
+ h = old.getBottom() - y;
+ }
+
+ if (isStretchingBottom)
+ {
+ h = jlimit (minH, maxH, h);
+ }
+
+ // constrain the aspect ratio if one has been specified..
+ if (aspectRatio > 0.0 && w > 0 && h > 0)
+ {
+ bool adjustWidth;
+
+ if ((isStretchingTop || isStretchingBottom) && ! (isStretchingLeft || isStretchingRight))
+ {
+ adjustWidth = true;
+ }
+ else if ((isStretchingLeft || isStretchingRight) && ! (isStretchingTop || isStretchingBottom))
+ {
+ adjustWidth = false;
+ }
+ else
+ {
+ const double oldRatio = (old.getHeight() > 0) ? fabs (old.getWidth() / (double) old.getHeight()) : 0.0;
+ const double newRatio = fabs (w / (double) h);
+
+ adjustWidth = (oldRatio > newRatio);
+ }
+
+ if (adjustWidth)
+ {
+ w = roundDoubleToInt (h * aspectRatio);
+
+ if (w > maxW || w < minW)
+ {
+ w = jlimit (minW, maxW, w);
+ h = roundDoubleToInt (w / aspectRatio);
+ }
+ }
+ else
+ {
+ h = roundDoubleToInt (w / aspectRatio);
+
+ if (h > maxH || h < minH)
+ {
+ h = jlimit (minH, maxH, h);
+ w = roundDoubleToInt (h * aspectRatio);
+ }
+ }
+
+ if ((isStretchingTop || isStretchingBottom) && ! (isStretchingLeft || isStretchingRight))
+ {
+ x = old.getX() + (old.getWidth() - w) / 2;
+ }
+ else if ((isStretchingLeft || isStretchingRight) && ! (isStretchingTop || isStretchingBottom))
+ {
+ y = old.getY() + (old.getHeight() - h) / 2;
+ }
+ else
+ {
+ if (isStretchingLeft)
+ x = old.getRight() - w;
+
+ if (isStretchingTop)
+ y = old.getBottom() - h;
+ }
+ }
+
+ // ...and constrain the position if limits have been set for that.
+ if (minOffTop > 0 || minOffLeft > 0 || minOffBottom > 0 || minOffRight > 0)
+ {
+ if (minOffTop > 0)
+ {
+ const int limit = limits.getY() + jmin (minOffTop - h, 0);
+
+ if (y < limit)
+ {
+ if (isStretchingTop)
+ h -= (limit - y);
+
+ y = limit;
+ }
+ }
+
+ if (minOffLeft > 0)
+ {
+ const int limit = limits.getX() + jmin (minOffLeft - w, 0);
+
+ if (x < limit)
+ {
+ if (isStretchingLeft)
+ w -= (limit - x);
+
+ x = limit;
+ }
+ }
+
+ if (minOffBottom > 0)
+ {
+ const int limit = limits.getBottom() - jmin (minOffBottom, h);
+
+ if (y > limit)
+ {
+ if (isStretchingBottom)
+ h += (limit - y);
+ else
+ y = limit;
+ }
+ }
+
+ if (minOffRight > 0)
+ {
+ const int limit = limits.getRight() - jmin (minOffRight, w);
+
+ if (x > limit)
+ {
+ if (isStretchingRight)
+ w += (limit - x);
+ else
+ x = limit;
+ }
+ }
+ }
+
+ jassert (w >= 0 && h >= 0);
+
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ComponentBoundsConstrainer.cpp *********/
+
+/********* Start of inlined file: juce_ComponentMovementWatcher.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ComponentMovementWatcher::ComponentMovementWatcher (Component* const component_)
+ : component (component_),
+ lastPeer (0),
+ registeredParentComps (4),
+ reentrant (false)
+{
+ jassert (component != 0); // can't use this with a null pointer..
+
+#ifdef JUCE_DEBUG
+ deletionWatcher = new ComponentDeletionWatcher (component_);
+#endif
+
+ component->addComponentListener (this);
+
+ registerWithParentComps();
+}
+
+ComponentMovementWatcher::~ComponentMovementWatcher()
+{
+ component->removeComponentListener (this);
+
+ unregister();
+
+#ifdef JUCE_DEBUG
+ delete deletionWatcher;
+#endif
+}
+
+void ComponentMovementWatcher::componentParentHierarchyChanged (Component&)
+{
+#ifdef JUCE_DEBUG
+ // agh! don't delete the target component without deleting this object first!
+ jassert (! deletionWatcher->hasBeenDeleted());
+#endif
+
+ if (! reentrant)
+ {
+ reentrant = true;
+
+ ComponentPeer* const peer = component->getPeer();
+
+ if (peer != lastPeer)
+ {
+ ComponentDeletionWatcher watcher (component);
+
+ componentPeerChanged();
+
+ if (watcher.hasBeenDeleted())
+ return;
+
+ lastPeer = peer;
+ }
+
+ unregister();
+ registerWithParentComps();
+
+ reentrant = false;
+
+ componentMovedOrResized (*component, true, true);
+ }
+}
+
+void ComponentMovementWatcher::componentMovedOrResized (Component&, bool wasMoved, bool wasResized)
+{
+#ifdef JUCE_DEBUG
+ // agh! don't delete the target component without deleting this object first!
+ jassert (! deletionWatcher->hasBeenDeleted());
+#endif
+
+ if (wasMoved)
+ {
+ int x = 0, y = 0;
+ component->relativePositionToOtherComponent (component->getTopLevelComponent(), x, y);
+
+ wasMoved = (lastX != x || lastY != y);
+ lastX = x;
+ lastY = y;
+ }
+
+ wasResized = (lastWidth != component->getWidth() || lastHeight != component->getHeight());
+ lastWidth = component->getWidth();
+ lastHeight = component->getHeight();
+
+ if (wasMoved || wasResized)
+ componentMovedOrResized (wasMoved, wasResized);
+}
+
+void ComponentMovementWatcher::registerWithParentComps() throw()
+{
+ Component* p = component->getParentComponent();
+
+ while (p != 0)
+ {
+ p->addComponentListener (this);
+ registeredParentComps.add (p);
+ p = p->getParentComponent();
+ }
+}
+
+void ComponentMovementWatcher::unregister() throw()
+{
+ for (int i = registeredParentComps.size(); --i >= 0;)
+ ((Component*) registeredParentComps.getUnchecked(i))->removeComponentListener (this);
+
+ registeredParentComps.clear();
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ComponentMovementWatcher.cpp *********/
+
+/********* Start of inlined file: juce_GroupComponent.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+GroupComponent::GroupComponent (const String& componentName,
+ const String& labelText)
+ : Component (componentName),
+ text (labelText),
+ justification (Justification::left)
+{
+ setInterceptsMouseClicks (false, true);
+}
+
+GroupComponent::~GroupComponent()
+{
+}
+
+void GroupComponent::setText (const String& newText) throw()
+{
+ if (text != newText)
+ {
+ text = newText;
+ repaint();
+ }
+}
+
+const String GroupComponent::getText() const throw()
+{
+ return text;
+}
+
+void GroupComponent::setTextLabelPosition (const Justification& newJustification)
+{
+ if (justification.getFlags() != newJustification.getFlags())
+ {
+ justification = newJustification;
+ repaint();
+ }
+}
+
+void GroupComponent::paint (Graphics& g)
+{
+ getLookAndFeel()
+ .drawGroupComponentOutline (g, getWidth(), getHeight(),
+ text, justification,
+ *this);
+}
+
+void GroupComponent::enablementChanged()
+{
+ repaint();
+}
+
+void GroupComponent::colourChanged()
+{
+ repaint();
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_GroupComponent.cpp *********/
+
+/********* Start of inlined file: juce_MultiDocumentPanel.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+MultiDocumentPanelWindow::MultiDocumentPanelWindow (const Colour& backgroundColour)
+ : DocumentWindow (String::empty, backgroundColour,
+ DocumentWindow::maximiseButton | DocumentWindow::closeButton, false)
+{
+}
+
+MultiDocumentPanelWindow::~MultiDocumentPanelWindow()
+{
+}
+
+void MultiDocumentPanelWindow::maximiseButtonPressed()
+{
+ MultiDocumentPanel* const owner = getOwner();
+
+ jassert (owner != 0); // these windows are only designed to be used inside a MultiDocumentPanel!
+ if (owner != 0)
+ owner->setLayoutMode (MultiDocumentPanel::MaximisedWindowsWithTabs);
+}
+
+void MultiDocumentPanelWindow::closeButtonPressed()
+{
+ MultiDocumentPanel* const owner = getOwner();
+
+ jassert (owner != 0); // these windows are only designed to be used inside a MultiDocumentPanel!
+ if (owner != 0)
+ owner->closeDocument (getContentComponent(), true);
+}
+
+void MultiDocumentPanelWindow::activeWindowStatusChanged()
+{
+ DocumentWindow::activeWindowStatusChanged();
+ updateOrder();
+}
+
+void MultiDocumentPanelWindow::broughtToFront()
+{
+ DocumentWindow::broughtToFront();
+ updateOrder();
+}
+
+void MultiDocumentPanelWindow::updateOrder()
+{
+ MultiDocumentPanel* const owner = getOwner();
+
+ if (owner != 0)
+ owner->updateOrder();
+}
+
+MultiDocumentPanel* MultiDocumentPanelWindow::getOwner() const throw()
+{
+ // (unable to use the syntax findParentComponentOfClass () because of a VC6 compiler bug)
+ return findParentComponentOfClass ((MultiDocumentPanel*) 0);
+}
+
+class MDITabbedComponentInternal : public TabbedComponent
+{
+public:
+ MDITabbedComponentInternal()
+ : TabbedComponent (TabbedButtonBar::TabsAtTop)
+ {
+ }
+
+ ~MDITabbedComponentInternal()
+ {
+ }
+
+ void currentTabChanged (const int, const String&)
+ {
+ // (unable to use the syntax findParentComponentOfClass () because of a VC6 compiler bug)
+ MultiDocumentPanel* const owner = findParentComponentOfClass ((MultiDocumentPanel*) 0);
+
+ if (owner != 0)
+ owner->updateOrder();
+ }
+};
+
+MultiDocumentPanel::MultiDocumentPanel()
+ : mode (MaximisedWindowsWithTabs),
+ tabComponent (0),
+ backgroundColour (Colours::lightblue),
+ maximumNumDocuments (0),
+ numDocsBeforeTabsUsed (0)
+{
+ setOpaque (true);
+}
+
+MultiDocumentPanel::~MultiDocumentPanel()
+{
+ closeAllDocuments (false);
+}
+
+static bool shouldDeleteComp (Component* const c)
+{
+ return c->getComponentPropertyBool (T("mdiDocumentDelete_"), false);
+}
+
+bool MultiDocumentPanel::closeAllDocuments (const bool checkItsOkToCloseFirst)
+{
+ while (components.size() > 0)
+ if (! closeDocument (components.getLast(), checkItsOkToCloseFirst))
+ return false;
+
+ return true;
+}
+
+MultiDocumentPanelWindow* MultiDocumentPanel::createNewDocumentWindow()
+{
+ return new MultiDocumentPanelWindow (backgroundColour);
+}
+
+void MultiDocumentPanel::addWindow (Component* component)
+{
+ MultiDocumentPanelWindow* const dw = createNewDocumentWindow();
+
+ dw->setResizable (true, false);
+ dw->setContentComponent (component, false, true);
+ dw->setName (component->getName());
+ dw->setBackgroundColour (component->getComponentPropertyColour (T("mdiDocumentBkg_"), false, backgroundColour));
+
+ int x = 4;
+ Component* const topComp = getChildComponent (getNumChildComponents() - 1);
+
+ if (topComp != 0 && topComp->getX() == x && topComp->getY() == x)
+ x += 16;
+
+ dw->setTopLeftPosition (x, x);
+
+ if (component->getComponentProperty (T("mdiDocumentPos_"), false, String::empty).isNotEmpty())
+ dw->restoreWindowStateFromString (component->getComponentProperty (T("mdiDocumentPos_"), false, String::empty));
+
+ addAndMakeVisible (dw);
+ dw->toFront (true);
+}
+
+bool MultiDocumentPanel::addDocument (Component* const component,
+ const Colour& backgroundColour,
+ const bool deleteWhenRemoved)
+{
+ // If you try passing a full DocumentWindow or ResizableWindow in here, you'll end up
+ // with a frame-within-a-frame! Just pass in the bare content component.
+ jassert (dynamic_cast (component) == 0);
+
+ if (component == 0 || (maximumNumDocuments > 0 && components.size() >= maximumNumDocuments))
+ return false;
+
+ components.add (component);
+ component->setComponentProperty (T("mdiDocumentDelete_"), deleteWhenRemoved);
+ component->setComponentProperty (T("mdiDocumentBkg_"), backgroundColour);
+ component->addComponentListener (this);
+
+ if (mode == FloatingWindows)
+ {
+ if (isFullscreenWhenOneDocument())
+ {
+ if (components.size() == 1)
+ {
+ addAndMakeVisible (component);
+ }
+ else
+ {
+ if (components.size() == 2)
+ addWindow (components.getFirst());
+
+ addWindow (component);
+ }
+ }
+ else
+ {
+ addWindow (component);
+ }
+ }
+ else
+ {
+ if (tabComponent == 0 && components.size() > numDocsBeforeTabsUsed)
+ {
+ addAndMakeVisible (tabComponent = new MDITabbedComponentInternal());
+
+ Array temp (components);
+
+ for (int i = 0; i < temp.size(); ++i)
+ tabComponent->addTab (temp[i]->getName(), backgroundColour, temp[i], false);
+
+ resized();
+ }
+ else
+ {
+ if (tabComponent != 0)
+ tabComponent->addTab (component->getName(), backgroundColour, component, false);
+ else
+ addAndMakeVisible (component);
+ }
+
+ setActiveDocument (component);
+ }
+
+ resized();
+ activeDocumentChanged();
+ return true;
+}
+
+bool MultiDocumentPanel::closeDocument (Component* component,
+ const bool checkItsOkToCloseFirst)
+{
+ if (components.contains (component))
+ {
+ if (checkItsOkToCloseFirst && ! tryToCloseDocument (component))
+ return false;
+
+ component->removeComponentListener (this);
+
+ const bool shouldDelete = shouldDeleteComp (component);
+ component->removeComponentProperty (T("mdiDocumentDelete_"));
+ component->removeComponentProperty (T("mdiDocumentBkg_"));
+
+ if (mode == FloatingWindows)
+ {
+ for (int i = getNumChildComponents(); --i >= 0;)
+ {
+ MultiDocumentPanelWindow* const dw = dynamic_cast (getChildComponent (i));
+
+ if (dw != 0 && dw->getContentComponent() == component)
+ {
+ dw->setContentComponent (0, false);
+ delete dw;
+ break;
+ }
+ }
+
+ if (shouldDelete)
+ delete component;
+
+ components.removeValue (component);
+
+ if (isFullscreenWhenOneDocument() && components.size() == 1)
+ {
+ for (int i = getNumChildComponents(); --i >= 0;)
+ {
+ MultiDocumentPanelWindow* const dw = dynamic_cast (getChildComponent (i));
+
+ if (dw != 0)
+ {
+ dw->setContentComponent (0, false);
+ delete dw;
+ }
+ }
+
+ addAndMakeVisible (components.getFirst());
+ }
+ }
+ else
+ {
+ jassert (components.indexOf (component) >= 0);
+
+ if (tabComponent != 0)
+ {
+ for (int i = tabComponent->getNumTabs(); --i >= 0;)
+ if (tabComponent->getTabContentComponent (i) == component)
+ tabComponent->removeTab (i);
+ }
+ else
+ {
+ removeChildComponent (component);
+ }
+
+ if (shouldDelete)
+ delete component;
+
+ if (tabComponent != 0 && tabComponent->getNumTabs() <= numDocsBeforeTabsUsed)
+ deleteAndZero (tabComponent);
+
+ components.removeValue (component);
+
+ if (components.size() > 0 && tabComponent == 0)
+ addAndMakeVisible (components.getFirst());
+ }
+
+ resized();
+ activeDocumentChanged();
+ }
+ else
+ {
+ jassertfalse
+ }
+
+ return true;
+}
+
+int MultiDocumentPanel::getNumDocuments() const throw()
+{
+ return components.size();
+}
+
+Component* MultiDocumentPanel::getDocument (const int index) const throw()
+{
+ return components [index];
+}
+
+Component* MultiDocumentPanel::getActiveDocument() const throw()
+{
+ if (mode == FloatingWindows)
+ {
+ for (int i = getNumChildComponents(); --i >= 0;)
+ {
+ MultiDocumentPanelWindow* const dw = dynamic_cast (getChildComponent (i));
+
+ if (dw != 0 && dw->isActiveWindow())
+ return dw->getContentComponent();
+ }
+ }
+
+ return components.getLast();
+}
+
+void MultiDocumentPanel::setActiveDocument (Component* component)
+{
+ if (mode == FloatingWindows)
+ {
+ component = getContainerComp (component);
+
+ if (component != 0)
+ component->toFront (true);
+ }
+ else if (tabComponent != 0)
+ {
+ jassert (components.indexOf (component) >= 0);
+
+ for (int i = tabComponent->getNumTabs(); --i >= 0;)
+ {
+ if (tabComponent->getTabContentComponent (i) == component)
+ {
+ tabComponent->setCurrentTabIndex (i);
+ break;
+ }
+ }
+ }
+ else
+ {
+ component->grabKeyboardFocus();
+ }
+}
+
+void MultiDocumentPanel::activeDocumentChanged()
+{
+}
+
+void MultiDocumentPanel::setMaximumNumDocuments (const int newNumber)
+{
+ maximumNumDocuments = newNumber;
+}
+
+void MultiDocumentPanel::useFullscreenWhenOneDocument (const bool shouldUseTabs)
+{
+ numDocsBeforeTabsUsed = shouldUseTabs ? 1 : 0;
+}
+
+bool MultiDocumentPanel::isFullscreenWhenOneDocument() const throw()
+{
+ return numDocsBeforeTabsUsed != 0;
+}
+
+void MultiDocumentPanel::setLayoutMode (const LayoutMode newLayoutMode)
+{
+ if (mode != newLayoutMode)
+ {
+ mode = newLayoutMode;
+
+ if (mode == FloatingWindows)
+ {
+ deleteAndZero (tabComponent);
+ }
+ else
+ {
+ for (int i = getNumChildComponents(); --i >= 0;)
+ {
+ MultiDocumentPanelWindow* const dw = dynamic_cast (getChildComponent (i));
+
+ if (dw != 0)
+ {
+ dw->getContentComponent()->setComponentProperty (T("mdiDocumentPos_"), dw->getWindowStateAsString());
+ dw->setContentComponent (0, false);
+ delete dw;
+ }
+ }
+ }
+
+ resized();
+
+ const Array tempComps (components);
+ components.clear();
+
+ for (int i = 0; i < tempComps.size(); ++i)
+ {
+ Component* const c = tempComps.getUnchecked(i);
+ addDocument (c,
+ c->getComponentPropertyColour (T("mdiDocumentBkg_"), false, Colours::white),
+ shouldDeleteComp (c));
+ }
+ }
+}
+
+void MultiDocumentPanel::setBackgroundColour (const Colour& newBackgroundColour)
+{
+ if (backgroundColour != newBackgroundColour)
+ {
+ backgroundColour = newBackgroundColour;
+ setOpaque (newBackgroundColour.isOpaque());
+ repaint();
+ }
+}
+
+void MultiDocumentPanel::paint (Graphics& g)
+{
+ g.fillAll (backgroundColour);
+}
+
+void MultiDocumentPanel::resized()
+{
+ if (mode == MaximisedWindowsWithTabs || components.size() == numDocsBeforeTabsUsed)
+ {
+ for (int i = getNumChildComponents(); --i >= 0;)
+ getChildComponent (i)->setBounds (0, 0, getWidth(), getHeight());
+ }
+
+ setWantsKeyboardFocus (components.size() == 0);
+}
+
+Component* MultiDocumentPanel::getContainerComp (Component* c) const
+{
+ if (mode == FloatingWindows)
+ {
+ for (int i = 0; i < getNumChildComponents(); ++i)
+ {
+ MultiDocumentPanelWindow* const dw = dynamic_cast (getChildComponent (i));
+
+ if (dw != 0 && dw->getContentComponent() == c)
+ {
+ c = dw;
+ break;
+ }
+ }
+ }
+
+ return c;
+}
+
+void MultiDocumentPanel::componentNameChanged (Component&)
+{
+ if (mode == FloatingWindows)
+ {
+ for (int i = 0; i < getNumChildComponents(); ++i)
+ {
+ MultiDocumentPanelWindow* const dw = dynamic_cast (getChildComponent (i));
+
+ if (dw != 0)
+ dw->setName (dw->getContentComponent()->getName());
+ }
+ }
+ else if (tabComponent != 0)
+ {
+ for (int i = tabComponent->getNumTabs(); --i >= 0;)
+ tabComponent->setTabName (i, tabComponent->getTabContentComponent (i)->getName());
+ }
+}
+
+void MultiDocumentPanel::updateOrder()
+{
+ const Array oldList (components);
+
+ if (mode == FloatingWindows)
+ {
+ components.clear();
+
+ for (int i = 0; i < getNumChildComponents(); ++i)
+ {
+ MultiDocumentPanelWindow* const dw = dynamic_cast (getChildComponent (i));
+
+ if (dw != 0)
+ components.add (dw->getContentComponent());
+ }
+ }
+ else
+ {
+ if (tabComponent != 0)
+ {
+ Component* const current = tabComponent->getCurrentContentComponent();
+
+ if (current != 0)
+ {
+ components.removeValue (current);
+ components.add (current);
+ }
+ }
+ }
+
+ if (components != oldList)
+ activeDocumentChanged();
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_MultiDocumentPanel.cpp *********/
+
+/********* Start of inlined file: juce_ResizableBorderComponent.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+const int zoneL = 1;
+const int zoneR = 2;
+const int zoneT = 4;
+const int zoneB = 8;
+
+ResizableBorderComponent::ResizableBorderComponent (Component* const componentToResize,
+ ComponentBoundsConstrainer* const constrainer_)
+ : component (componentToResize),
+ constrainer (constrainer_),
+ borderSize (5),
+ mouseZone (0)
+{
+}
+
+ResizableBorderComponent::~ResizableBorderComponent()
+{
+}
+
+void ResizableBorderComponent::paint (Graphics& g)
+{
+ getLookAndFeel().drawResizableFrame (g, getWidth(), getHeight(), borderSize);
+}
+
+void ResizableBorderComponent::mouseEnter (const MouseEvent& e)
+{
+ updateMouseZone (e);
+}
+
+void ResizableBorderComponent::mouseMove (const MouseEvent& e)
+{
+ updateMouseZone (e);
+}
+
+void ResizableBorderComponent::mouseDown (const MouseEvent& e)
+{
+ if (component->isValidComponent())
+ {
+ updateMouseZone (e);
+
+ originalX = component->getX();
+ originalY = component->getY();
+ originalW = component->getWidth();
+ originalH = component->getHeight();
+
+ if (constrainer != 0)
+ constrainer->resizeStart();
+ }
+ else
+ {
+ jassertfalse
+ }
+}
+
+void ResizableBorderComponent::mouseDrag (const MouseEvent& e)
+{
+ if (! component->isValidComponent())
+ {
+ jassertfalse
+ return;
+ }
+
+ int x = originalX;
+ int y = originalY;
+ int w = originalW;
+ int h = originalH;
+
+ const int dx = e.getDistanceFromDragStartX();
+ const int dy = e.getDistanceFromDragStartY();
+
+ if ((mouseZone & zoneL) != 0)
+ {
+ x += dx;
+ w -= dx;
+ }
+
+ if ((mouseZone & zoneT) != 0)
+ {
+ y += dy;
+ h -= dy;
+ }
+
+ if ((mouseZone & zoneR) != 0)
+ w += dx;
+
+ if ((mouseZone & zoneB) != 0)
+ h += dy;
+
+ if (constrainer != 0)
+ constrainer->setBoundsForComponent (component,
+ x, y, w, h,
+ (mouseZone & zoneT) != 0,
+ (mouseZone & zoneL) != 0,
+ (mouseZone & zoneB) != 0,
+ (mouseZone & zoneR) != 0);
+ else
+ component->setBounds (x, y, w, h);
+}
+
+void ResizableBorderComponent::mouseUp (const MouseEvent&)
+{
+ if (constrainer != 0)
+ constrainer->resizeEnd();
+}
+
+bool ResizableBorderComponent::hitTest (int x, int y)
+{
+ return x < borderSize.getLeft()
+ || x >= getWidth() - borderSize.getRight()
+ || y < borderSize.getTop()
+ || y >= getHeight() - borderSize.getBottom();
+}
+
+void ResizableBorderComponent::setBorderThickness (const BorderSize& newBorderSize) throw()
+{
+ if (borderSize != newBorderSize)
+ {
+ borderSize = newBorderSize;
+ repaint();
+ }
+}
+
+const BorderSize ResizableBorderComponent::getBorderThickness() const throw()
+{
+ return borderSize;
+}
+
+void ResizableBorderComponent::updateMouseZone (const MouseEvent& e) throw()
+{
+ int newZone = 0;
+
+ if (ResizableBorderComponent::hitTest (e.x, e.y))
+ {
+ if (e.x < jmax (borderSize.getLeft(), proportionOfWidth (0.1f)))
+ newZone |= zoneL;
+ else if (e.x >= jmin (getWidth() - borderSize.getRight(), proportionOfWidth (0.9f)))
+ newZone |= zoneR;
+
+ if (e.y < jmax (borderSize.getTop(), proportionOfHeight (0.1f)))
+ newZone |= zoneT;
+ else if (e.y >= jmin (getHeight() - borderSize.getBottom(), proportionOfHeight (0.9f)))
+ newZone |= zoneB;
+ }
+
+ if (mouseZone != newZone)
+ {
+ mouseZone = newZone;
+
+ MouseCursor::StandardCursorType mc = MouseCursor::NormalCursor;
+
+ switch (newZone)
+ {
+ case (zoneL | zoneT):
+ mc = MouseCursor::TopLeftCornerResizeCursor;
+ break;
+
+ case zoneT:
+ mc = MouseCursor::TopEdgeResizeCursor;
+ break;
+
+ case (zoneR | zoneT):
+ mc = MouseCursor::TopRightCornerResizeCursor;
+ break;
+
+ case zoneL:
+ mc = MouseCursor::LeftEdgeResizeCursor;
+ break;
+
+ case zoneR:
+ mc = MouseCursor::RightEdgeResizeCursor;
+ break;
+
+ case (zoneL | zoneB):
+ mc = MouseCursor::BottomLeftCornerResizeCursor;
+ break;
+
+ case zoneB:
+ mc = MouseCursor::BottomEdgeResizeCursor;
+ break;
+
+ case (zoneR | zoneB):
+ mc = MouseCursor::BottomRightCornerResizeCursor;
+ break;
+
+ default:
+ break;
+ }
+
+ setMouseCursor (mc);
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ResizableBorderComponent.cpp *********/
+
+/********* Start of inlined file: juce_ResizableCornerComponent.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+ResizableCornerComponent::ResizableCornerComponent (Component* const componentToResize,
+ ComponentBoundsConstrainer* const constrainer_)
+ : component (componentToResize),
+ constrainer (constrainer_)
+{
+ setRepaintsOnMouseActivity (true);
+ setMouseCursor (MouseCursor::BottomRightCornerResizeCursor);
+}
+
+ResizableCornerComponent::~ResizableCornerComponent()
+{
+}
+
+void ResizableCornerComponent::paint (Graphics& g)
+{
+ getLookAndFeel()
+ .drawCornerResizer (g, getWidth(), getHeight(),
+ isMouseOverOrDragging(),
+ isMouseButtonDown());
+}
+
+void ResizableCornerComponent::mouseDown (const MouseEvent&)
+{
+ if (component->isValidComponent())
+ {
+ originalX = component->getX();
+ originalY = component->getY();
+ originalW = component->getWidth();
+ originalH = component->getHeight();
+
+ if (constrainer != 0)
+ constrainer->resizeStart();
+ }
+ else
+ {
+ jassertfalse
+ }
+}
+
+void ResizableCornerComponent::mouseDrag (const MouseEvent& e)
+{
+ if (! component->isValidComponent())
+ {
+ jassertfalse
+ return;
+ }
+
+ int x = originalX;
+ int y = originalY;
+ int w = originalW + e.getDistanceFromDragStartX();
+ int h = originalH + e.getDistanceFromDragStartY();
+
+ if (constrainer != 0)
+ constrainer->setBoundsForComponent (component, x, y, w, h,
+ false, false, true, true);
+ else
+ component->setBounds (x, y, w, h);
+}
+
+void ResizableCornerComponent::mouseUp (const MouseEvent&)
+{
+ if (constrainer != 0)
+ constrainer->resizeStart();
+}
+
+bool ResizableCornerComponent::hitTest (int x, int y)
+{
+ if (getWidth() <= 0)
+ return false;
+
+ const int yAtX = getHeight() - (getHeight() * x / getWidth());
+
+ return y >= yAtX - getHeight() / 4;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ResizableCornerComponent.cpp *********/
+
+/********* Start of inlined file: juce_ScrollBar.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+class ScrollbarButton : public Button
+{
+public:
+ int direction;
+
+ ScrollbarButton (const int direction_,
+ ScrollBar& owner_) throw()
+ : Button (String::empty),
+ direction (direction_),
+ owner (owner_)
+ {
+ setWantsKeyboardFocus (false);
+ }
+
+ ~ScrollbarButton()
+ {
+ }
+
+ void paintButton (Graphics& g,
+ bool isMouseOver,
+ bool isMouseDown)
+ {
+ getLookAndFeel()
+ .drawScrollbarButton (g, owner,
+ getWidth(), getHeight(),
+ direction,
+ owner.isVertical(),
+ isMouseOver, isMouseDown);
+ }
+
+ void clicked()
+ {
+ owner.moveScrollbarInSteps ((direction == 1 || direction == 2) ? 1 : -1);
+ }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ ScrollBar& owner;
+
+ ScrollbarButton (const ScrollbarButton&);
+ const ScrollbarButton& operator= (const ScrollbarButton&);
+};
+
+ScrollBar::ScrollBar (const bool vertical_,
+ const bool buttonsAreVisible)
+ : minimum (0.0),
+ maximum (1.0),
+ rangeStart (0.0),
+ rangeSize (0.1),
+ singleStepSize (0.1),
+ thumbAreaStart (0),
+ thumbAreaSize (0),
+ thumbStart (0),
+ thumbSize (0),
+ initialDelayInMillisecs (100),
+ repeatDelayInMillisecs (50),
+ minimumDelayInMillisecs (10),
+ vertical (vertical_),
+ isDraggingThumb (false),
+ alwaysVisible (false),
+ upButton (0),
+ downButton (0),
+ listeners (2)
+{
+ setButtonVisibility (buttonsAreVisible);
+
+ setRepaintsOnMouseActivity (true);
+ setFocusContainer (true);
+}
+
+ScrollBar::~ScrollBar()
+{
+ deleteAllChildren();
+}
+
+void ScrollBar::setRangeLimits (const double newMinimum,
+ const double newMaximum) throw()
+{
+ minimum = newMinimum;
+ maximum = newMaximum;
+
+ jassert (maximum >= minimum); // these can't be the wrong way round!
+
+ setCurrentRangeStart (rangeStart);
+ updateThumbPosition();
+}
+
+void ScrollBar::setCurrentRange (double newStart,
+ double newSize) throw()
+{
+ newSize = jlimit (0.0, maximum - minimum, newSize);
+ newStart = jlimit (minimum, maximum - newSize, newStart);
+
+ if (rangeStart != newStart
+ || rangeSize != newSize)
+ {
+ rangeStart = newStart;
+ rangeSize = newSize;
+
+ updateThumbPosition();
+ triggerAsyncUpdate();
+ }
+}
+
+void ScrollBar::setCurrentRangeStart (double newStart) throw()
+{
+ setCurrentRange (newStart, rangeSize);
+}
+
+void ScrollBar::setSingleStepSize (const double newSingleStepSize) throw()
+{
+ singleStepSize = newSingleStepSize;
+}
+
+void ScrollBar::moveScrollbarInSteps (const int howManySteps) throw()
+{
+ setCurrentRangeStart (rangeStart + howManySteps * singleStepSize);
+}
+
+void ScrollBar::moveScrollbarInPages (const int howManyPages) throw()
+{
+ setCurrentRangeStart (rangeStart + howManyPages * rangeSize);
+}
+
+void ScrollBar::scrollToTop() throw()
+{
+ setCurrentRangeStart (minimum);
+}
+
+void ScrollBar::scrollToBottom() throw()
+{
+ setCurrentRangeStart (maximum - rangeSize);
+}
+
+void ScrollBar::setButtonRepeatSpeed (const int initialDelayInMillisecs_,
+ const int repeatDelayInMillisecs_,
+ const int minimumDelayInMillisecs_) throw()
+{
+ initialDelayInMillisecs = initialDelayInMillisecs_;
+ repeatDelayInMillisecs = repeatDelayInMillisecs_;
+ minimumDelayInMillisecs = minimumDelayInMillisecs_;
+
+ if (upButton != 0)
+ {
+ upButton->setRepeatSpeed (initialDelayInMillisecs, repeatDelayInMillisecs, minimumDelayInMillisecs);
+ downButton->setRepeatSpeed (initialDelayInMillisecs, repeatDelayInMillisecs, minimumDelayInMillisecs);
+ }
+}
+
+void ScrollBar::addListener (ScrollBarListener* const listener) throw()
+{
+ jassert (listener != 0);
+ if (listener != 0)
+ listeners.add (listener);
+}
+
+void ScrollBar::removeListener (ScrollBarListener* const listener) throw()
+{
+ listeners.removeValue (listener);
+}
+
+void ScrollBar::handleAsyncUpdate()
+{
+ const double value = getCurrentRangeStart();
+
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ ((ScrollBarListener*) listeners.getUnchecked (i))->scrollBarMoved (this, value);
+ i = jmin (i, listeners.size());
+ }
+}
+
+void ScrollBar::updateThumbPosition() throw()
+{
+ int newThumbSize = roundDoubleToInt ((maximum > minimum) ? (rangeSize * thumbAreaSize) / (maximum - minimum)
+ : thumbAreaSize);
+
+ if (newThumbSize < getLookAndFeel().getMinimumScrollbarThumbSize (*this))
+ newThumbSize = jmin (getLookAndFeel().getMinimumScrollbarThumbSize (*this), thumbAreaSize - 1);
+
+ if (newThumbSize > thumbAreaSize)
+ newThumbSize = thumbAreaSize;
+
+ int newThumbStart = thumbAreaStart;
+
+ if (maximum - minimum > rangeSize)
+ newThumbStart += roundDoubleToInt (((rangeStart - minimum) * (thumbAreaSize - newThumbSize))
+ / ((maximum - minimum) - rangeSize));
+
+ setVisible (alwaysVisible || (maximum - minimum > rangeSize && rangeSize > 0.0));
+
+ if (thumbStart != newThumbStart || thumbSize != newThumbSize)
+ {
+ const int repaintStart = jmin (thumbStart, newThumbStart) - 4;
+ const int repaintSize = jmax (thumbStart + thumbSize, newThumbStart + newThumbSize) + 8 - repaintStart;
+
+ if (vertical)
+ repaint (0, repaintStart, getWidth(), repaintSize);
+ else
+ repaint (repaintStart, 0, repaintSize, getHeight());
+
+ thumbStart = newThumbStart;
+ thumbSize = newThumbSize;
+ }
+}
+
+void ScrollBar::setOrientation (const bool shouldBeVertical) throw()
+{
+ if (vertical != shouldBeVertical)
+ {
+ vertical = shouldBeVertical;
+
+ if (upButton != 0)
+ {
+ ((ScrollbarButton*) upButton)->direction = (vertical) ? 0 : 3;
+ ((ScrollbarButton*) downButton)->direction = (vertical) ? 2 : 1;
+ }
+
+ updateThumbPosition();
+ }
+}
+
+void ScrollBar::setButtonVisibility (const bool buttonsAreVisible)
+{
+ deleteAndZero (upButton);
+ deleteAndZero (downButton);
+
+ if (buttonsAreVisible)
+ {
+ addAndMakeVisible (upButton = new ScrollbarButton ((vertical) ? 0 : 3, *this));
+ addAndMakeVisible (downButton = new ScrollbarButton ((vertical) ? 2 : 1, *this));
+
+ setButtonRepeatSpeed (initialDelayInMillisecs, repeatDelayInMillisecs, minimumDelayInMillisecs);
+ }
+
+ updateThumbPosition();
+}
+
+void ScrollBar::setAutoHide (const bool shouldHideWhenFullRange)
+{
+ alwaysVisible = ! shouldHideWhenFullRange;
+ updateThumbPosition();
+}
+
+void ScrollBar::paint (Graphics& g)
+{
+ if (thumbAreaSize > 0)
+ {
+ LookAndFeel& lf = getLookAndFeel();
+
+ const int thumb = (thumbAreaSize > lf.getMinimumScrollbarThumbSize (*this))
+ ? thumbSize : 0;
+
+ if (vertical)
+ {
+ lf.drawScrollbar (g, *this,
+ 0, thumbAreaStart,
+ getWidth(), thumbAreaSize,
+ vertical,
+ thumbStart, thumb,
+ isMouseOver(), isMouseButtonDown());
+ }
+ else
+ {
+ lf.drawScrollbar (g, *this,
+ thumbAreaStart, 0,
+ thumbAreaSize, getHeight(),
+ vertical,
+ thumbStart, thumb,
+ isMouseOver(), isMouseButtonDown());
+ }
+ }
+}
+
+void ScrollBar::lookAndFeelChanged()
+{
+ setComponentEffect (getLookAndFeel().getScrollbarEffect());
+}
+
+void ScrollBar::resized()
+{
+ const int length = ((vertical) ? getHeight() : getWidth());
+
+ const int buttonSize = (upButton != 0) ? jmin (getLookAndFeel().getScrollbarButtonSize (*this), (length >> 1))
+ : 0;
+
+ if (length < 32 + getLookAndFeel().getMinimumScrollbarThumbSize (*this))
+ {
+ thumbAreaStart = length >> 1;
+ thumbAreaSize = 0;
+ }
+ else
+ {
+ thumbAreaStart = buttonSize;
+ thumbAreaSize = length - (buttonSize << 1);
+ }
+
+ if (upButton != 0)
+ {
+ if (vertical)
+ {
+ upButton->setBounds (0, 0, getWidth(), buttonSize);
+ downButton->setBounds (0, thumbAreaStart + thumbAreaSize, getWidth(), buttonSize);
+ }
+ else
+ {
+ upButton->setBounds (0, 0, buttonSize, getHeight());
+ downButton->setBounds (thumbAreaStart + thumbAreaSize, 0, buttonSize, getHeight());
+ }
+ }
+
+ updateThumbPosition();
+}
+
+void ScrollBar::mouseDown (const MouseEvent& e)
+{
+ isDraggingThumb = false;
+ lastMousePos = vertical ? e.y : e.x;
+ dragStartMousePos = lastMousePos;
+ dragStartRange = rangeStart;
+
+ if (dragStartMousePos < thumbStart)
+ {
+ moveScrollbarInPages (-1);
+ startTimer (400);
+ }
+ else if (dragStartMousePos >= thumbStart + thumbSize)
+ {
+ moveScrollbarInPages (1);
+ startTimer (400);
+ }
+ else
+ {
+ isDraggingThumb = (thumbAreaSize > getLookAndFeel().getMinimumScrollbarThumbSize (*this))
+ && (thumbAreaSize > thumbSize);
+ }
+}
+
+void ScrollBar::mouseDrag (const MouseEvent& e)
+{
+ if (isDraggingThumb)
+ {
+ const int deltaPixels = ((vertical) ? e.y : e.x) - dragStartMousePos;
+
+ setCurrentRangeStart (dragStartRange
+ + deltaPixels * ((maximum - minimum) - rangeSize)
+ / (thumbAreaSize - thumbSize));
+
+ // (repainting synchronously makes it feel a bit snappier..)
+ ComponentPeer* const peer = getPeer();
+
+ if (peer != 0)
+ peer->performAnyPendingRepaintsNow();
+ }
+ else
+ {
+ lastMousePos = (vertical) ? e.y : e.x;
+ }
+}
+
+void ScrollBar::mouseUp (const MouseEvent&)
+{
+ isDraggingThumb = false;
+ stopTimer();
+ repaint();
+}
+
+void ScrollBar::mouseWheelMove (const MouseEvent&,
+ float wheelIncrementX,
+ float wheelIncrementY)
+{
+ float increment = vertical ? wheelIncrementY : wheelIncrementX;
+
+ if (increment < 0)
+ increment = jmin (increment * 10.0f, -1.0f);
+ else if (increment > 0)
+ increment = jmax (increment * 10.0f, 1.0f);
+
+ setCurrentRangeStart (rangeStart - singleStepSize * increment);
+}
+
+void ScrollBar::timerCallback()
+{
+ if (isMouseButtonDown())
+ {
+ startTimer (40);
+
+ if (lastMousePos < thumbStart)
+ setCurrentRangeStart (rangeStart - rangeSize);
+ else if (lastMousePos > thumbStart + thumbSize)
+ setCurrentRangeStart (rangeStart + rangeSize);
+ }
+ else
+ {
+ stopTimer();
+ }
+}
+
+bool ScrollBar::keyPressed (const KeyPress& key)
+{
+ if (! isVisible())
+ return false;
+
+ if (key.isKeyCode (KeyPress::upKey) || key.isKeyCode (KeyPress::leftKey))
+ moveScrollbarInSteps (-1);
+ else if (key.isKeyCode (KeyPress::downKey) || key.isKeyCode (KeyPress::rightKey))
+ moveScrollbarInSteps (1);
+ else if (key.isKeyCode (KeyPress::pageUpKey))
+ moveScrollbarInPages (-1);
+ else if (key.isKeyCode (KeyPress::pageDownKey))
+ moveScrollbarInPages (1);
+ else if (key.isKeyCode (KeyPress::homeKey))
+ scrollToTop();
+ else if (key.isKeyCode (KeyPress::endKey))
+ scrollToBottom();
+ else
+ return false;
+
+ return true;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_ScrollBar.cpp *********/
+
+/********* Start of inlined file: juce_StretchableLayoutManager.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+StretchableLayoutManager::StretchableLayoutManager()
+ : totalSize (0)
+{
+}
+
+StretchableLayoutManager::~StretchableLayoutManager()
+{
+}
+
+void StretchableLayoutManager::clearAllItems()
+{
+ items.clear();
+ totalSize = 0;
+}
+
+void StretchableLayoutManager::setItemLayout (const int itemIndex,
+ const double minimumSize,
+ const double maximumSize,
+ const double preferredSize)
+{
+ ItemLayoutProperties* layout = getInfoFor (itemIndex);
+
+ if (layout == 0)
+ {
+ layout = new ItemLayoutProperties();
+ layout->itemIndex = itemIndex;
+
+ int i;
+ for (i = 0; i < items.size(); ++i)
+ if (items.getUnchecked (i)->itemIndex > itemIndex)
+ break;
+
+ items.insert (i, layout);
+ }
+
+ layout->minSize = minimumSize;
+ layout->maxSize = maximumSize;
+ layout->preferredSize = preferredSize;
+ layout->currentSize = 0;
+}
+
+bool StretchableLayoutManager::getItemLayout (const int itemIndex,
+ double& minimumSize,
+ double& maximumSize,
+ double& preferredSize) const
+{
+ const ItemLayoutProperties* const layout = getInfoFor (itemIndex);
+
+ if (layout != 0)
+ {
+ minimumSize = layout->minSize;
+ maximumSize = layout->maxSize;
+ preferredSize = layout->preferredSize;
+ return true;
+ }
+
+ return false;
+}
+
+void StretchableLayoutManager::setTotalSize (const int newTotalSize)
+{
+ totalSize = newTotalSize;
+
+ fitComponentsIntoSpace (0, items.size(), totalSize, 0);
+}
+
+int StretchableLayoutManager::getItemCurrentPosition (const int itemIndex) const
+{
+ int pos = 0;
+
+ for (int i = 0; i < itemIndex; ++i)
+ {
+ const ItemLayoutProperties* const layout = getInfoFor (i);
+
+ if (layout != 0)
+ pos += layout->currentSize;
+ }
+
+ return pos;
+}
+
+int StretchableLayoutManager::getItemCurrentAbsoluteSize (const int itemIndex) const
+{
+ const ItemLayoutProperties* const layout = getInfoFor (itemIndex);
+
+ if (layout != 0)
+ return layout->currentSize;
+
+ return 0;
+}
+
+double StretchableLayoutManager::getItemCurrentRelativeSize (const int itemIndex) const
+{
+ const ItemLayoutProperties* const layout = getInfoFor (itemIndex);
+
+ if (layout != 0)
+ return -layout->currentSize / (double) totalSize;
+
+ return 0;
+}
+
+void StretchableLayoutManager::setItemPosition (const int itemIndex,
+ int newPosition)
+{
+ for (int i = items.size(); --i >= 0;)
+ {
+ const ItemLayoutProperties* const layout = items.getUnchecked(i);
+
+ if (layout->itemIndex == itemIndex)
+ {
+ int realTotalSize = jmax (totalSize, getMinimumSizeOfItems (0, items.size()));
+ const int minSizeAfterThisComp = getMinimumSizeOfItems (i, items.size());
+ const int maxSizeAfterThisComp = getMaximumSizeOfItems (i + 1, items.size());
+
+ newPosition = jmax (newPosition, totalSize - maxSizeAfterThisComp - layout->currentSize);
+ newPosition = jmin (newPosition, realTotalSize - minSizeAfterThisComp);
+
+ int endPos = fitComponentsIntoSpace (0, i, newPosition, 0);
+
+ endPos += layout->currentSize;
+
+ fitComponentsIntoSpace (i + 1, items.size(), totalSize - endPos, endPos);
+ updatePrefSizesToMatchCurrentPositions();
+ break;
+ }
+ }
+}
+
+void StretchableLayoutManager::layOutComponents (Component** const components,
+ int numComponents,
+ int x, int y, int w, int h,
+ const bool vertically,
+ const bool resizeOtherDimension)
+{
+ setTotalSize (vertically ? h : w);
+ int pos = vertically ? y : x;
+
+ for (int i = 0; i < numComponents; ++i)
+ {
+ const ItemLayoutProperties* const layout = getInfoFor (i);
+
+ if (layout != 0)
+ {
+ Component* const c = components[i];
+
+ if (c != 0)
+ {
+ if (i == numComponents - 1)
+ {
+ // if it's the last item, crop it to exactly fit the available space..
+ if (resizeOtherDimension)
+ {
+ if (vertically)
+ c->setBounds (x, pos, w, jmax (layout->currentSize, h - pos));
+ else
+ c->setBounds (pos, y, jmax (layout->currentSize, w - pos), h);
+ }
+ else
+ {
+ if (vertically)
+ c->setBounds (c->getX(), pos, c->getWidth(), jmax (layout->currentSize, h - pos));
+ else
+ c->setBounds (pos, c->getY(), jmax (layout->currentSize, w - pos), c->getHeight());
+ }
+ }
+ else
+ {
+ if (resizeOtherDimension)
+ {
+ if (vertically)
+ c->setBounds (x, pos, w, layout->currentSize);
+ else
+ c->setBounds (pos, y, layout->currentSize, h);
+ }
+ else
+ {
+ if (vertically)
+ c->setBounds (c->getX(), pos, c->getWidth(), layout->currentSize);
+ else
+ c->setBounds (pos, c->getY(), layout->currentSize, c->getHeight());
+ }
+ }
+ }
+
+ pos += layout->currentSize;
+ }
+ }
+}
+
+StretchableLayoutManager::ItemLayoutProperties* StretchableLayoutManager::getInfoFor (const int itemIndex) const
+{
+ for (int i = items.size(); --i >= 0;)
+ if (items.getUnchecked(i)->itemIndex == itemIndex)
+ return items.getUnchecked(i);
+
+ return 0;
+}
+
+int StretchableLayoutManager::fitComponentsIntoSpace (const int startIndex,
+ const int endIndex,
+ const int availableSpace,
+ int startPos)
+{
+ // calculate the total sizes
+ int i;
+ double totalIdealSize = 0.0;
+ int totalMinimums = 0;
+
+ for (i = startIndex; i < endIndex; ++i)
+ {
+ ItemLayoutProperties* const layout = items.getUnchecked (i);
+
+ layout->currentSize = sizeToRealSize (layout->minSize, totalSize);
+
+ totalMinimums += layout->currentSize;
+ totalIdealSize += sizeToRealSize (layout->preferredSize, availableSpace);
+ }
+
+ if (totalIdealSize <= 0)
+ totalIdealSize = 1.0;
+
+ // now calc the best sizes..
+ int extraSpace = availableSpace - totalMinimums;
+
+ while (extraSpace > 0)
+ {
+ int numWantingMoreSpace = 0;
+ int numHavingTakenExtraSpace = 0;
+
+ // first figure out how many comps want a slice of the extra space..
+ for (i = startIndex; i < endIndex; ++i)
+ {
+ ItemLayoutProperties* const layout = items.getUnchecked (i);
+
+ double sizeWanted = sizeToRealSize (layout->preferredSize, availableSpace);
+
+ const int bestSize = jlimit (layout->currentSize,
+ jmax (layout->currentSize,
+ sizeToRealSize (layout->maxSize, totalSize)),
+ roundDoubleToInt (sizeWanted * availableSpace / totalIdealSize));
+
+ if (bestSize > layout->currentSize)
+ ++numWantingMoreSpace;
+ }
+
+ // ..share out the extra space..
+ for (i = startIndex; i < endIndex; ++i)
+ {
+ ItemLayoutProperties* const layout = items.getUnchecked (i);
+
+ double sizeWanted = sizeToRealSize (layout->preferredSize, availableSpace);
+
+ int bestSize = jlimit (layout->currentSize,
+ jmax (layout->currentSize, sizeToRealSize (layout->maxSize, totalSize)),
+ roundDoubleToInt (sizeWanted * availableSpace / totalIdealSize));
+
+ const int extraWanted = bestSize - layout->currentSize;
+
+ if (extraWanted > 0)
+ {
+ const int extraAllowed = jmin (extraWanted,
+ extraSpace / jmax (1, numWantingMoreSpace));
+
+ if (extraAllowed > 0)
+ {
+ ++numHavingTakenExtraSpace;
+ --numWantingMoreSpace;
+
+ layout->currentSize += extraAllowed;
+ extraSpace -= extraAllowed;
+ }
+ }
+ }
+
+ if (numHavingTakenExtraSpace <= 0)
+ break;
+ }
+
+ // ..and calculate the end position
+ for (i = startIndex; i < endIndex; ++i)
+ {
+ ItemLayoutProperties* const layout = items.getUnchecked(i);
+ startPos += layout->currentSize;
+ }
+
+ return startPos;
+}
+
+int StretchableLayoutManager::getMinimumSizeOfItems (const int startIndex,
+ const int endIndex) const
+{
+ int totalMinimums = 0;
+
+ for (int i = startIndex; i < endIndex; ++i)
+ totalMinimums += sizeToRealSize (items.getUnchecked (i)->minSize, totalSize);
+
+ return totalMinimums;
+}
+
+int StretchableLayoutManager::getMaximumSizeOfItems (const int startIndex, const int endIndex) const
+{
+ int totalMaximums = 0;
+
+ for (int i = startIndex; i < endIndex; ++i)
+ totalMaximums += sizeToRealSize (items.getUnchecked (i)->maxSize, totalSize);
+
+ return totalMaximums;
+}
+
+void StretchableLayoutManager::updatePrefSizesToMatchCurrentPositions()
+{
+ for (int i = 0; i < items.size(); ++i)
+ {
+ ItemLayoutProperties* const layout = items.getUnchecked (i);
+
+ layout->preferredSize
+ = (layout->preferredSize < 0) ? getItemCurrentRelativeSize (i)
+ : getItemCurrentAbsoluteSize (i);
+ }
+}
+
+int StretchableLayoutManager::sizeToRealSize (double size, int totalSpace)
+{
+ if (size < 0)
+ size *= -totalSpace;
+
+ return roundDoubleToInt (size);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_StretchableLayoutManager.cpp *********/
+
+/********* Start of inlined file: juce_StretchableLayoutResizerBar.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+StretchableLayoutResizerBar::StretchableLayoutResizerBar (StretchableLayoutManager* layout_,
+ const int itemIndex_,
+ const bool isVertical_)
+ : layout (layout_),
+ itemIndex (itemIndex_),
+ isVertical (isVertical_)
+{
+ setRepaintsOnMouseActivity (true);
+ setMouseCursor (MouseCursor (isVertical_ ? MouseCursor::LeftRightResizeCursor
+ : MouseCursor::UpDownResizeCursor));
+}
+
+StretchableLayoutResizerBar::~StretchableLayoutResizerBar()
+{
+}
+
+void StretchableLayoutResizerBar::paint (Graphics& g)
+{
+ getLookAndFeel().drawStretchableLayoutResizerBar (g,
+ getWidth(), getHeight(),
+ isVertical,
+ isMouseOver(),
+ isMouseButtonDown());
+}
+
+void StretchableLayoutResizerBar::mouseDown (const MouseEvent&)
+{
+ mouseDownPos = layout->getItemCurrentPosition (itemIndex);
+}
+
+void StretchableLayoutResizerBar::mouseDrag (const MouseEvent& e)
+{
+ const int desiredPos = mouseDownPos + (isVertical ? e.getDistanceFromDragStartX()
+ : e.getDistanceFromDragStartY());
+
+ layout->setItemPosition (itemIndex, desiredPos);
+
+ hasBeenMoved();
+}
+
+void StretchableLayoutResizerBar::hasBeenMoved()
+{
+ if (getParentComponent() != 0)
+ getParentComponent()->resized();
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_StretchableLayoutResizerBar.cpp *********/
+
+/********* Start of inlined file: juce_StretchableObjectResizer.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+StretchableObjectResizer::StretchableObjectResizer()
+{
+}
+
+StretchableObjectResizer::~StretchableObjectResizer()
+{
+}
+
+void StretchableObjectResizer::addItem (const double size,
+ const double minSize, const double maxSize,
+ const int order)
+{
+ jassert (order >= 0 && order < INT_MAX); // the order must be >= 0 and less than INT_MAX
+
+ Item* const item = new Item();
+ item->size = size;
+ item->minSize = minSize;
+ item->maxSize = maxSize;
+ item->order = order;
+ items.add (item);
+}
+
+double StretchableObjectResizer::getItemSize (const int index) const throw()
+{
+ const Item* const it = items [index];
+ return it != 0 ? it->size : 0;
+}
+
+void StretchableObjectResizer::resizeToFit (const double targetSize)
+{
+ int order = 0;
+
+ for (;;)
+ {
+ double currentSize = 0;
+ double minSize = 0;
+ double maxSize = 0;
+
+ int nextHighestOrder = INT_MAX;
+
+ for (int i = 0; i < items.size(); ++i)
+ {
+ const Item* const it = items.getUnchecked(i);
+ currentSize += it->size;
+
+ if (it->order <= order)
+ {
+ minSize += it->minSize;
+ maxSize += it->maxSize;
+ }
+ else
+ {
+ minSize += it->size;
+ maxSize += it->size;
+ nextHighestOrder = jmin (nextHighestOrder, it->order);
+ }
+ }
+
+ const double thisIterationTarget = jlimit (minSize, maxSize, targetSize);
+
+ if (thisIterationTarget >= currentSize)
+ {
+ const double availableExtraSpace = maxSize - currentSize;
+ const double targetAmountOfExtraSpace = thisIterationTarget - currentSize;
+ const double scale = targetAmountOfExtraSpace / availableExtraSpace;
+
+ for (int i = 0; i < items.size(); ++i)
+ {
+ Item* const it = items.getUnchecked(i);
+
+ if (it->order <= order)
+ it->size = jmin (it->maxSize, it->size + (it->maxSize - it->size) * scale);
+ }
+ }
+ else
+ {
+ const double amountOfSlack = currentSize - minSize;
+ const double targetAmountOfSlack = thisIterationTarget - minSize;
+ const double scale = targetAmountOfSlack / amountOfSlack;
+
+ for (int i = 0; i < items.size(); ++i)
+ {
+ Item* const it = items.getUnchecked(i);
+
+ if (it->order <= order)
+ it->size = jmax (it->minSize, it->minSize + (it->size - it->minSize) * scale);
+ }
+ }
+
+ if (nextHighestOrder < INT_MAX)
+ order = nextHighestOrder;
+ else
+ break;
+ }
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_StretchableObjectResizer.cpp *********/
+
+/********* Start of inlined file: juce_TabbedButtonBar.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+TabBarButton::TabBarButton (const String& name,
+ TabbedButtonBar* const owner_,
+ const int index)
+ : Button (name),
+ owner (owner_),
+ tabIndex (index),
+ overlapPixels (0)
+{
+ shadow.setShadowProperties (2.2f, 0.7f, 0, 0);
+ setComponentEffect (&shadow);
+ setWantsKeyboardFocus (false);
+}
+
+TabBarButton::~TabBarButton()
+{
+}
+
+void TabBarButton::paintButton (Graphics& g,
+ bool isMouseOverButton,
+ bool isButtonDown)
+{
+ int x, y, w, h;
+ getActiveArea (x, y, w, h);
+
+ g.setOrigin (x, y);
+
+ getLookAndFeel()
+ .drawTabButton (g, w, h,
+ owner->getTabBackgroundColour (tabIndex),
+ tabIndex, getButtonText(), *this,
+ owner->getOrientation(),
+ isMouseOverButton, isButtonDown,
+ getToggleState());
+}
+
+void TabBarButton::clicked (const ModifierKeys& mods)
+{
+ if (mods.isPopupMenu())
+ owner->popupMenuClickOnTab (tabIndex, getButtonText());
+ else
+ owner->setCurrentTabIndex (tabIndex);
+}
+
+bool TabBarButton::hitTest (int mx, int my)
+{
+ int x, y, w, h;
+ getActiveArea (x, y, w, h);
+
+ if (owner->getOrientation() == TabbedButtonBar::TabsAtLeft
+ || owner->getOrientation() == TabbedButtonBar::TabsAtRight)
+ {
+ if (((unsigned int) mx) < (unsigned int) getWidth()
+ && my >= y + overlapPixels
+ && my < y + h - overlapPixels)
+ return true;
+ }
+ else
+ {
+ if (mx >= x + overlapPixels && mx < x + w - overlapPixels
+ && ((unsigned int) my) < (unsigned int) getHeight())
+ return true;
+ }
+
+ Path p;
+ getLookAndFeel()
+ .createTabButtonShape (p, w, h, tabIndex, getButtonText(), *this,
+ owner->getOrientation(),
+ false, false, getToggleState());
+
+ return p.contains ((float) (mx - x),
+ (float) (my - y));
+}
+
+int TabBarButton::getBestTabLength (const int depth)
+{
+ return jlimit (depth * 2,
+ depth * 7,
+ getLookAndFeel().getTabButtonBestWidth (tabIndex, getButtonText(), depth, *this));
+}
+
+void TabBarButton::getActiveArea (int& x, int& y, int& w, int& h)
+{
+ x = 0;
+ y = 0;
+ int r = getWidth();
+ int b = getHeight();
+
+ const int spaceAroundImage = getLookAndFeel().getTabButtonSpaceAroundImage();
+
+ if (owner->getOrientation() != TabbedButtonBar::TabsAtLeft)
+ r -= spaceAroundImage;
+
+ if (owner->getOrientation() != TabbedButtonBar::TabsAtRight)
+ x += spaceAroundImage;
+
+ if (owner->getOrientation() != TabbedButtonBar::TabsAtBottom)
+ y += spaceAroundImage;
+
+ if (owner->getOrientation() != TabbedButtonBar::TabsAtTop)
+ b -= spaceAroundImage;
+
+ w = r - x;
+ h = b - y;
+}
+
+class TabAreaBehindFrontButtonComponent : public Component
+{
+public:
+ TabAreaBehindFrontButtonComponent (TabbedButtonBar* const owner_)
+ : owner (owner_)
+ {
+ setInterceptsMouseClicks (false, false);
+ }
+
+ ~TabAreaBehindFrontButtonComponent()
+ {
+ }
+
+ void paint (Graphics& g)
+ {
+ getLookAndFeel()
+ .drawTabAreaBehindFrontButton (g, getWidth(), getHeight(),
+ *owner, owner->getOrientation());
+ }
+
+ void enablementChanged()
+ {
+ repaint();
+ }
+
+private:
+ TabbedButtonBar* const owner;
+
+ TabAreaBehindFrontButtonComponent (const TabAreaBehindFrontButtonComponent&);
+ const TabAreaBehindFrontButtonComponent& operator= (const TabAreaBehindFrontButtonComponent&);
+};
+
+TabbedButtonBar::TabbedButtonBar (const Orientation orientation_)
+ : orientation (orientation_),
+ currentTabIndex (-1),
+ extraTabsButton (0)
+{
+ setInterceptsMouseClicks (false, true);
+ addAndMakeVisible (behindFrontTab = new TabAreaBehindFrontButtonComponent (this));
+ setFocusContainer (true);
+}
+
+TabbedButtonBar::~TabbedButtonBar()
+{
+ deleteAllChildren();
+}
+
+void TabbedButtonBar::setOrientation (const Orientation newOrientation)
+{
+ orientation = newOrientation;
+
+ for (int i = getNumChildComponents(); --i >= 0;)
+ getChildComponent (i)->resized();
+
+ resized();
+}
+
+TabBarButton* TabbedButtonBar::createTabButton (const String& name, const int index)
+{
+ return new TabBarButton (name, this, index);
+}
+
+void TabbedButtonBar::clearTabs()
+{
+ tabs.clear();
+ tabColours.clear();
+ currentTabIndex = -1;
+
+ deleteAndZero (extraTabsButton);
+ removeChildComponent (behindFrontTab);
+ deleteAllChildren();
+ addChildComponent (behindFrontTab);
+
+ setCurrentTabIndex (-1);
+}
+
+void TabbedButtonBar::addTab (const String& tabName,
+ const Colour& tabBackgroundColour,
+ int insertIndex)
+{
+ jassert (tabName.isNotEmpty()); // you have to give them all a name..
+
+ if (tabName.isNotEmpty())
+ {
+ if (((unsigned int) insertIndex) > (unsigned int) tabs.size())
+ insertIndex = tabs.size();
+
+ for (int i = tabs.size(); --i >= insertIndex;)
+ {
+ TabBarButton* const tb = getTabButton (i);
+
+ if (tb != 0)
+ tb->tabIndex++;
+ }
+
+ tabs.insert (insertIndex, tabName);
+ tabColours.insert (insertIndex, tabBackgroundColour);
+
+ TabBarButton* const tb = createTabButton (tabName, insertIndex);
+ jassert (tb != 0); // your createTabButton() mustn't return zero!
+
+ addAndMakeVisible (tb, insertIndex);
+
+ resized();
+
+ if (currentTabIndex < 0)
+ setCurrentTabIndex (0);
+ }
+}
+
+void TabbedButtonBar::setTabName (const int tabIndex,
+ const String& newName)
+{
+ if (((unsigned int) tabIndex) < (unsigned int) tabs.size()
+ && tabs[tabIndex] != newName)
+ {
+ tabs.set (tabIndex, newName);
+
+ TabBarButton* const tb = getTabButton (tabIndex);
+
+ if (tb != 0)
+ tb->setButtonText (newName);
+
+ resized();
+ }
+}
+
+void TabbedButtonBar::removeTab (const int tabIndex)
+{
+ if (((unsigned int) tabIndex) < (unsigned int) tabs.size())
+ {
+ const int oldTabIndex = currentTabIndex;
+ if (currentTabIndex == tabIndex)
+ currentTabIndex = -1;
+
+ tabs.remove (tabIndex);
+ tabColours.remove (tabIndex);
+
+ TabBarButton* const tb = getTabButton (tabIndex);
+
+ if (tb != 0)
+ delete tb;
+
+ for (int i = tabIndex + 1; i <= tabs.size(); ++i)
+ {
+ TabBarButton* const tb = getTabButton (i);
+
+ if (tb != 0)
+ tb->tabIndex--;
+ }
+
+ resized();
+
+ setCurrentTabIndex (jlimit (0, jmax (0, tabs.size() - 1), oldTabIndex));
+ }
+}
+
+void TabbedButtonBar::moveTab (const int currentIndex,
+ const int newIndex)
+{
+ tabs.move (currentIndex, newIndex);
+ tabColours.move (currentIndex, newIndex);
+ resized();
+}
+
+int TabbedButtonBar::getNumTabs() const
+{
+ return tabs.size();
+}
+
+const StringArray TabbedButtonBar::getTabNames() const
+{
+ return tabs;
+}
+
+void TabbedButtonBar::setCurrentTabIndex (int newIndex)
+{
+ if (currentTabIndex != newIndex)
+ {
+ if (((unsigned int) newIndex) >= (unsigned int) tabs.size())
+ newIndex = -1;
+
+ currentTabIndex = newIndex;
+
+ for (int i = 0; i < getNumChildComponents(); ++i)
+ {
+ TabBarButton* const tb = dynamic_cast (getChildComponent (i));
+
+ if (tb != 0)
+ tb->setToggleState (tb->tabIndex == newIndex, false);
+ }
+
+ resized();
+ sendChangeMessage (this);
+
+ currentTabChanged (newIndex, newIndex >= 0 ? tabs [newIndex] : String::empty);
+ }
+}
+
+TabBarButton* TabbedButtonBar::getTabButton (const int index) const
+{
+ for (int i = getNumChildComponents(); --i >= 0;)
+ {
+ TabBarButton* const tb = dynamic_cast (getChildComponent (i));
+
+ if (tb != 0 && tb->tabIndex == index)
+ return tb;
+ }
+
+ return 0;
+}
+
+void TabbedButtonBar::lookAndFeelChanged()
+{
+ deleteAndZero (extraTabsButton);
+ resized();
+}
+
+void TabbedButtonBar::resized()
+{
+ const double minimumScale = 0.7;
+ int depth = getWidth();
+ int length = getHeight();
+
+ if (orientation == TabsAtTop || orientation == TabsAtBottom)
+ swapVariables (depth, length);
+
+ const int overlap = getLookAndFeel().getTabButtonOverlap (depth)
+ + getLookAndFeel().getTabButtonSpaceAroundImage() * 2;
+
+ int i, totalLength = overlap;
+ int numVisibleButtons = tabs.size();
+
+ for (i = 0; i < getNumChildComponents(); ++i)
+ {
+ TabBarButton* const tb = dynamic_cast (getChildComponent (i));
+
+ if (tb != 0)
+ {
+ totalLength += tb->getBestTabLength (depth) - overlap;
+ tb->overlapPixels = overlap / 2;
+ }
+ }
+
+ double scale = 1.0;
+
+ if (totalLength > length)
+ scale = jmax (minimumScale, length / (double) totalLength);
+
+ const bool isTooBig = totalLength * scale > length;
+ int tabsButtonPos = 0;
+
+ if (isTooBig)
+ {
+ if (extraTabsButton == 0)
+ {
+ addAndMakeVisible (extraTabsButton = getLookAndFeel().createTabBarExtrasButton());
+ extraTabsButton->addButtonListener (this);
+ extraTabsButton->setAlwaysOnTop (true);
+ extraTabsButton->setTriggeredOnMouseDown (true);
+ }
+
+ const int buttonSize = jmin (proportionOfWidth (0.7f), proportionOfHeight (0.7f));
+ extraTabsButton->setSize (buttonSize, buttonSize);
+
+ if (orientation == TabsAtTop || orientation == TabsAtBottom)
+ {
+ tabsButtonPos = getWidth() - buttonSize / 2 - 1;
+ extraTabsButton->setCentrePosition (tabsButtonPos, getHeight() / 2);
+ }
+ else
+ {
+ tabsButtonPos = getHeight() - buttonSize / 2 - 1;
+ extraTabsButton->setCentrePosition (getWidth() / 2, tabsButtonPos);
+ }
+
+ totalLength = 0;
+
+ for (i = 0; i < tabs.size(); ++i)
+ {
+ TabBarButton* const tb = getTabButton (i);
+
+ if (tb != 0)
+ {
+ const int newLength = totalLength + tb->getBestTabLength (depth);
+
+ if (i > 0 && newLength * minimumScale > tabsButtonPos)
+ {
+ totalLength += overlap;
+ break;
+ }
+
+ numVisibleButtons = i + 1;
+ totalLength = newLength - overlap;
+
+ }
+ }
+
+ scale = jmax (minimumScale, tabsButtonPos / (double) totalLength);
+ }
+ else
+ {
+ deleteAndZero (extraTabsButton);
+ }
+
+ int pos = 0;
+
+ TabBarButton* frontTab = 0;
+
+ for (i = 0; i < tabs.size(); ++i)
+ {
+ TabBarButton* const tb = getTabButton (i);
+
+ if (tb != 0)
+ {
+ const int bestLength = roundDoubleToInt (scale * tb->getBestTabLength (depth));
+
+ if (i < numVisibleButtons)
+ {
+ if (orientation == TabsAtTop || orientation == TabsAtBottom)
+ tb->setBounds (pos, 0, bestLength, getHeight());
+ else
+ tb->setBounds (0, pos, getWidth(), bestLength);
+
+ tb->toBack();
+
+ if (tb->tabIndex == currentTabIndex)
+ frontTab = tb;
+
+ tb->setVisible (true);
+ }
+ else
+ {
+ tb->setVisible (false);
+ }
+
+ pos += bestLength - overlap;
+ }
+ }
+
+ behindFrontTab->setBounds (0, 0, getWidth(), getHeight());
+
+ if (frontTab != 0)
+ {
+ frontTab->toFront (false);
+ behindFrontTab->toBehind (frontTab);
+ }
+}
+
+const Colour TabbedButtonBar::getTabBackgroundColour (const int tabIndex)
+{
+ return tabColours [tabIndex];
+}
+
+void TabbedButtonBar::setTabBackgroundColour (const int tabIndex, const Colour& newColour)
+{
+ if (((unsigned int) tabIndex) < (unsigned int) tabColours.size()
+ && tabColours [tabIndex] != newColour)
+ {
+ tabColours.set (tabIndex, newColour);
+ repaint();
+ }
+}
+
+void TabbedButtonBar::buttonClicked (Button* button)
+{
+ if (extraTabsButton == button)
+ {
+ PopupMenu m;
+
+ for (int i = 0; i < tabs.size(); ++i)
+ {
+ TabBarButton* const tb = getTabButton (i);
+
+ if (tb != 0 && ! tb->isVisible())
+ m.addItem (tb->tabIndex + 1, tabs[i], true, i == currentTabIndex);
+ }
+
+ const int res = m.showAt (extraTabsButton);
+
+ if (res != 0)
+ setCurrentTabIndex (res - 1);
+ }
+}
+
+void TabbedButtonBar::currentTabChanged (const int, const String&)
+{
+}
+
+void TabbedButtonBar::popupMenuClickOnTab (const int, const String&)
+{
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_TabbedButtonBar.cpp *********/
+
+/********* Start of inlined file: juce_TabbedComponent.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+class TabCompButtonBar : public TabbedButtonBar
+{
+public:
+ TabCompButtonBar (TabbedComponent* const owner_,
+ const TabbedButtonBar::Orientation orientation)
+ : TabbedButtonBar (orientation),
+ owner (owner_)
+ {
+ }
+
+ ~TabCompButtonBar()
+ {
+ }
+
+ void currentTabChanged (const int newCurrentTabIndex,
+ const String& newTabName)
+ {
+ owner->changeCallback (newCurrentTabIndex, newTabName);
+ }
+
+ void popupMenuClickOnTab (const int tabIndex,
+ const String& tabName)
+ {
+ owner->popupMenuClickOnTab (tabIndex, tabName);
+ }
+
+ const Colour getTabBackgroundColour (const int tabIndex)
+ {
+ return owner->tabs->getTabBackgroundColour (tabIndex);
+ }
+
+ TabBarButton* createTabButton (const String& tabName, const int tabIndex)
+ {
+ return owner->createTabButton (tabName, tabIndex);
+ }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ TabbedComponent* const owner;
+
+ TabCompButtonBar (const TabCompButtonBar&);
+ const TabCompButtonBar& operator= (const TabCompButtonBar&);
+};
+
+TabbedComponent::TabbedComponent (const TabbedButtonBar::Orientation orientation)
+ : panelComponent (0),
+ tabDepth (30),
+ outlineColour (Colours::grey),
+ outlineThickness (1),
+ edgeIndent (0)
+{
+ addAndMakeVisible (tabs = new TabCompButtonBar (this, orientation));
+}
+
+TabbedComponent::~TabbedComponent()
+{
+ clearTabs();
+ delete tabs;
+}
+
+void TabbedComponent::setOrientation (const TabbedButtonBar::Orientation orientation)
+{
+ tabs->setOrientation (orientation);
+ resized();
+}
+
+TabbedButtonBar::Orientation TabbedComponent::getOrientation() const throw()
+{
+ return tabs->getOrientation();
+}
+
+void TabbedComponent::setTabBarDepth (const int newDepth)
+{
+ if (tabDepth != newDepth)
+ {
+ tabDepth = newDepth;
+ resized();
+ }
+}
+
+TabBarButton* TabbedComponent::createTabButton (const String& tabName, const int tabIndex)
+{
+ return new TabBarButton (tabName, tabs, tabIndex);
+}
+
+void TabbedComponent::clearTabs()
+{
+ if (panelComponent != 0)
+ {
+ panelComponent->setVisible (false);
+ removeChildComponent (panelComponent);
+ panelComponent = 0;
+ }
+
+ tabs->clearTabs();
+
+ for (int i = contentComponents.size(); --i >= 0;)
+ {
+ Component* const c = contentComponents.getUnchecked(i);
+
+ // be careful not to delete these components until they've been removed from the tab component
+ jassert (c == 0 || c->isValidComponent());
+
+ if (c != 0 && c->getComponentPropertyBool (T("deleteByTabComp_"), false, false))
+ delete c;
+ }
+
+ contentComponents.clear();
+}
+
+void TabbedComponent::addTab (const String& tabName,
+ const Colour& tabBackgroundColour,
+ Component* const contentComponent,
+ const bool deleteComponentWhenNotNeeded,
+ const int insertIndex)
+{
+ contentComponents.insert (insertIndex, contentComponent);
+
+ if (contentComponent != 0)
+ contentComponent->setComponentProperty (T("deleteByTabComp_"), deleteComponentWhenNotNeeded);
+
+ tabs->addTab (tabName, tabBackgroundColour, insertIndex);
+}
+
+void TabbedComponent::setTabName (const int tabIndex,
+ const String& newName)
+{
+ tabs->setTabName (tabIndex, newName);
+}
+
+void TabbedComponent::removeTab (const int tabIndex)
+{
+ Component* const c = contentComponents [tabIndex];
+
+ if (c != 0 && c->getComponentPropertyBool (T("deleteByTabComp_"), false, false))
+ {
+ if (c == panelComponent)
+ panelComponent = 0;
+
+ delete c;
+ }
+
+ contentComponents.remove (tabIndex);
+
+ tabs->removeTab (tabIndex);
+}
+
+int TabbedComponent::getNumTabs() const
+{
+ return tabs->getNumTabs();
+}
+
+const StringArray TabbedComponent::getTabNames() const
+{
+ return tabs->getTabNames();
+}
+
+Component* TabbedComponent::getTabContentComponent (const int tabIndex) const throw()
+{
+ return contentComponents [tabIndex];
+}
+
+const Colour TabbedComponent::getTabBackgroundColour (const int tabIndex) const throw()
+{
+ return tabs->getTabBackgroundColour (tabIndex);
+}
+
+void TabbedComponent::setTabBackgroundColour (const int tabIndex, const Colour& newColour)
+{
+ tabs->setTabBackgroundColour (tabIndex, newColour);
+
+ if (getCurrentTabIndex() == tabIndex)
+ repaint();
+}
+
+void TabbedComponent::setCurrentTabIndex (const int newTabIndex)
+{
+ tabs->setCurrentTabIndex (newTabIndex);
+}
+
+int TabbedComponent::getCurrentTabIndex() const
+{
+ return tabs->getCurrentTabIndex();
+}
+
+const String& TabbedComponent::getCurrentTabName() const
+{
+ return tabs->getCurrentTabName();
+}
+
+void TabbedComponent::setOutline (const Colour& colour, int thickness)
+{
+ outlineColour = colour;
+ outlineThickness = thickness;
+ repaint();
+}
+
+void TabbedComponent::setIndent (const int indentThickness)
+{
+ edgeIndent = indentThickness;
+}
+
+void TabbedComponent::paint (Graphics& g)
+{
+ const TabbedButtonBar::Orientation o = getOrientation();
+
+ int x = 0;
+ int y = 0;
+ int r = getWidth();
+ int b = getHeight();
+
+ if (o == TabbedButtonBar::TabsAtTop)
+ y += tabDepth;
+ else if (o == TabbedButtonBar::TabsAtBottom)
+ b -= tabDepth;
+ else if (o == TabbedButtonBar::TabsAtLeft)
+ x += tabDepth;
+ else if (o == TabbedButtonBar::TabsAtRight)
+ r -= tabDepth;
+
+ g.reduceClipRegion (x, y, r - x, b - y);
+ g.fillAll (tabs->getTabBackgroundColour (getCurrentTabIndex()));
+
+ if (outlineThickness > 0)
+ {
+ if (o == TabbedButtonBar::TabsAtTop)
+ --y;
+ else if (o == TabbedButtonBar::TabsAtBottom)
+ ++b;
+ else if (o == TabbedButtonBar::TabsAtLeft)
+ --x;
+ else if (o == TabbedButtonBar::TabsAtRight)
+ ++r;
+
+ g.setColour (outlineColour);
+ g.drawRect (x, y, r - x, b - y, outlineThickness);
+ }
+}
+
+void TabbedComponent::resized()
+{
+ const TabbedButtonBar::Orientation o = getOrientation();
+ const int indent = edgeIndent + outlineThickness;
+ BorderSize indents (indent);
+
+ if (o == TabbedButtonBar::TabsAtTop)
+ {
+ tabs->setBounds (0, 0, getWidth(), tabDepth);
+ indents.setTop (tabDepth + edgeIndent);
+ }
+ else if (o == TabbedButtonBar::TabsAtBottom)
+ {
+ tabs->setBounds (0, getHeight() - tabDepth, getWidth(), tabDepth);
+ indents.setBottom (tabDepth + edgeIndent);
+ }
+ else if (o == TabbedButtonBar::TabsAtLeft)
+ {
+ tabs->setBounds (0, 0, tabDepth, getHeight());
+ indents.setLeft (tabDepth + edgeIndent);
+ }
+ else if (o == TabbedButtonBar::TabsAtRight)
+ {
+ tabs->setBounds (getWidth() - tabDepth, 0, tabDepth, getHeight());
+ indents.setRight (tabDepth + edgeIndent);
+ }
+
+ const Rectangle bounds (indents.subtractedFrom (Rectangle (0, 0, getWidth(), getHeight())));
+
+ for (int i = contentComponents.size(); --i >= 0;)
+ if (contentComponents.getUnchecked (i) != 0)
+ contentComponents.getUnchecked (i)->setBounds (bounds);
+}
+
+void TabbedComponent::changeCallback (const int newCurrentTabIndex,
+ const String& newTabName)
+{
+ if (panelComponent != 0)
+ {
+ panelComponent->setVisible (false);
+ removeChildComponent (panelComponent);
+ panelComponent = 0;
+ }
+
+ if (getCurrentTabIndex() >= 0)
+ {
+ panelComponent = contentComponents [getCurrentTabIndex()];
+
+ if (panelComponent != 0)
+ {
+ // 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 TabbedComponent::currentTabChanged (const int, const String&)
+{
+}
+
+void TabbedComponent::popupMenuClickOnTab (const int, const String&)
+{
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_TabbedComponent.cpp *********/
+
+/********* Start of inlined file: juce_Viewport.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+Viewport::Viewport (const String& componentName)
+ : Component (componentName),
+ contentComp (0),
+ lastVX (0),
+ lastVY (0),
+ lastVW (0),
+ lastVH (0),
+ scrollBarThickness (0),
+ singleStepX (16),
+ singleStepY (16),
+ showHScrollbar (true),
+ showVScrollbar (true)
+{
+ // content holder is used to clip the contents so they don't overlap the scrollbars
+ addAndMakeVisible (contentHolder = new Component());
+ contentHolder->setInterceptsMouseClicks (false, true);
+
+ verticalScrollBar = new ScrollBar (true);
+ horizontalScrollBar = new ScrollBar (false);
+
+ addChildComponent (verticalScrollBar);
+ addChildComponent (horizontalScrollBar);
+
+ verticalScrollBar->addListener (this);
+ horizontalScrollBar->addListener (this);
+
+ setInterceptsMouseClicks (false, true);
+ setWantsKeyboardFocus (true);
+}
+
+Viewport::~Viewport()
+{
+ contentHolder->deleteAllChildren();
+ deleteAllChildren();
+}
+
+void Viewport::visibleAreaChanged (int, int, int, int)
+{
+}
+
+void Viewport::setViewedComponent (Component* const newViewedComponent)
+{
+ if (contentComp != newViewedComponent)
+ {
+ if (contentComp->isValidComponent())
+ {
+ Component* const oldComp = contentComp;
+ contentComp = 0;
+ delete oldComp;
+ }
+
+ contentComp = newViewedComponent;
+
+ if (contentComp != 0)
+ {
+ contentComp->setTopLeftPosition (0, 0);
+ contentHolder->addAndMakeVisible (contentComp);
+ contentComp->addComponentListener (this);
+ }
+
+ updateVisibleRegion();
+ }
+}
+
+int Viewport::getMaximumVisibleWidth() const throw()
+{
+ return jmax (0, getWidth() - (verticalScrollBar->isVisible() ? getScrollBarThickness() : 0));
+}
+
+int Viewport::getMaximumVisibleHeight() const throw()
+{
+ return jmax (0, getHeight() - (horizontalScrollBar->isVisible() ? getScrollBarThickness() : 0));
+}
+
+void Viewport::setViewPosition (const int xPixelsOffset,
+ const int yPixelsOffset)
+{
+ if (contentComp != 0)
+ contentComp->setTopLeftPosition (-xPixelsOffset,
+ -yPixelsOffset);
+}
+
+void Viewport::setViewPositionProportionately (const double x,
+ const double y)
+{
+ if (contentComp != 0)
+ setViewPosition (jmax (0, roundDoubleToInt (x * (contentComp->getWidth() - getWidth()))),
+ jmax (0, roundDoubleToInt (y * (contentComp->getHeight() - getHeight()))));
+}
+
+void Viewport::componentMovedOrResized (Component&, bool, bool)
+{
+ updateVisibleRegion();
+}
+
+void Viewport::resized()
+{
+ updateVisibleRegion();
+}
+
+void Viewport::updateVisibleRegion()
+{
+ if (contentComp != 0)
+ {
+ const int newVX = -contentComp->getX();
+ const int newVY = -contentComp->getY();
+
+ if (newVX == 0 && newVY == 0
+ && contentComp->getWidth() <= getWidth()
+ && contentComp->getHeight() <= getHeight())
+ {
+ horizontalScrollBar->setVisible (false);
+ verticalScrollBar->setVisible (false);
+ }
+
+ if ((contentComp->getWidth() > 0) && showHScrollbar
+ && getHeight() > getScrollBarThickness())
+ {
+ horizontalScrollBar->setRangeLimits (0.0, contentComp->getWidth());
+ horizontalScrollBar->setCurrentRange (newVX, getMaximumVisibleWidth());
+ horizontalScrollBar->setSingleStepSize (singleStepX);
+ }
+ else
+ {
+ horizontalScrollBar->setVisible (false);
+ }
+
+ if ((contentComp->getHeight() > 0) && showVScrollbar
+ && getWidth() > getScrollBarThickness())
+ {
+ verticalScrollBar->setRangeLimits (0.0, contentComp->getHeight());
+ verticalScrollBar->setCurrentRange (newVY, getMaximumVisibleHeight());
+ verticalScrollBar->setSingleStepSize (singleStepY);
+ }
+ else
+ {
+ verticalScrollBar->setVisible (false);
+ }
+
+ if (verticalScrollBar->isVisible())
+ {
+ horizontalScrollBar->setCurrentRange (newVX, getMaximumVisibleWidth());
+ verticalScrollBar->setCurrentRange (newVY, getMaximumVisibleHeight());
+
+ verticalScrollBar
+ ->setBounds (getMaximumVisibleWidth(), 0,
+ getScrollBarThickness(), getMaximumVisibleHeight());
+ }
+
+ if (horizontalScrollBar->isVisible())
+ {
+ horizontalScrollBar->setCurrentRange (newVX, getMaximumVisibleWidth());
+
+ horizontalScrollBar
+ ->setBounds (0, getMaximumVisibleHeight(),
+ getMaximumVisibleWidth(), getScrollBarThickness());
+ }
+
+ contentHolder->setSize (getMaximumVisibleWidth(),
+ getMaximumVisibleHeight());
+
+ const int newVW = jmin (contentComp->getRight(), getMaximumVisibleWidth());
+ const int newVH = jmin (contentComp->getBottom(), getMaximumVisibleHeight());
+
+ if (newVX != lastVX
+ || newVY != lastVY
+ || newVW != lastVW
+ || newVH != lastVH)
+ {
+ lastVX = newVX;
+ lastVY = newVY;
+ lastVW = newVW;
+ lastVH = newVH;
+
+ visibleAreaChanged (newVX, newVY, newVW, newVH);
+ }
+
+ horizontalScrollBar->handleUpdateNowIfNeeded();
+ verticalScrollBar->handleUpdateNowIfNeeded();
+ }
+ else
+ {
+ horizontalScrollBar->setVisible (false);
+ verticalScrollBar->setVisible (false);
+ }
+}
+
+void Viewport::setSingleStepSizes (const int stepX,
+ const int stepY)
+{
+ singleStepX = stepX;
+ singleStepY = stepY;
+ updateVisibleRegion();
+}
+
+void Viewport::setScrollBarsShown (const bool showVerticalScrollbarIfNeeded,
+ const bool showHorizontalScrollbarIfNeeded)
+{
+ showVScrollbar = showVerticalScrollbarIfNeeded;
+ showHScrollbar = showHorizontalScrollbarIfNeeded;
+ updateVisibleRegion();
+}
+
+void Viewport::setScrollBarThickness (const int thickness)
+{
+ scrollBarThickness = thickness;
+ updateVisibleRegion();
+}
+
+int Viewport::getScrollBarThickness() const throw()
+{
+ return (scrollBarThickness > 0) ? scrollBarThickness
+ : getLookAndFeel().getDefaultScrollbarWidth();
+}
+
+void Viewport::setScrollBarButtonVisibility (const bool buttonsVisible)
+{
+ verticalScrollBar->setButtonVisibility (buttonsVisible);
+ horizontalScrollBar->setButtonVisibility (buttonsVisible);
+}
+
+void Viewport::scrollBarMoved (ScrollBar* scrollBarThatHasMoved, const double newRangeStart)
+{
+ if (scrollBarThatHasMoved == horizontalScrollBar)
+ {
+ setViewPosition (roundDoubleToInt (newRangeStart), getViewPositionY());
+ }
+ else if (scrollBarThatHasMoved == verticalScrollBar)
+ {
+ setViewPosition (getViewPositionX(), roundDoubleToInt (newRangeStart));
+ }
+}
+
+void Viewport::mouseWheelMove (const MouseEvent& e, float wheelIncrementX, float wheelIncrementY)
+{
+ if (! useMouseWheelMoveIfNeeded (e, wheelIncrementX, wheelIncrementY))
+ Component::mouseWheelMove (e, wheelIncrementX, wheelIncrementY);
+}
+
+bool Viewport::useMouseWheelMoveIfNeeded (const MouseEvent& e, float wheelIncrementX, float wheelIncrementY)
+{
+ if (! (e.mods.isAltDown() || e.mods.isCtrlDown()))
+ {
+ const bool hasVertBar = verticalScrollBar->isVisible();
+ const bool hasHorzBar = horizontalScrollBar->isVisible();
+
+ if (hasHorzBar && (wheelIncrementX != 0 || e.mods.isShiftDown() || ! hasVertBar))
+ {
+ horizontalScrollBar->mouseWheelMove (e.getEventRelativeTo (horizontalScrollBar),
+ wheelIncrementX, wheelIncrementY);
+ return true;
+ }
+ else if (hasVertBar && wheelIncrementY != 0)
+ {
+ verticalScrollBar->mouseWheelMove (e.getEventRelativeTo (verticalScrollBar),
+ wheelIncrementX, wheelIncrementY);
+ return true;
+ }
+ }
+
+ return false;
+}
+
+bool Viewport::keyPressed (const KeyPress& key)
+{
+ const bool isUpDownKey = key.isKeyCode (KeyPress::upKey)
+ || key.isKeyCode (KeyPress::downKey)
+ || key.isKeyCode (KeyPress::pageUpKey)
+ || key.isKeyCode (KeyPress::pageDownKey)
+ || key.isKeyCode (KeyPress::homeKey)
+ || key.isKeyCode (KeyPress::endKey);
+
+ if (verticalScrollBar->isVisible() && isUpDownKey)
+ return verticalScrollBar->keyPressed (key);
+
+ const bool isLeftRightKey = key.isKeyCode (KeyPress::leftKey)
+ || key.isKeyCode (KeyPress::rightKey);
+
+ if (horizontalScrollBar->isVisible() && (isUpDownKey || isLeftRightKey))
+ return horizontalScrollBar->keyPressed (key);
+
+ return false;
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_Viewport.cpp *********/
+
+/********* Start of inlined file: juce_LookAndFeel.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+static const Colour createBaseColour (const Colour& buttonColour,
+ const bool hasKeyboardFocus,
+ const bool isMouseOverButton,
+ const bool isButtonDown) throw()
+{
+ const float sat = hasKeyboardFocus ? 1.3f : 0.9f;
+ const Colour baseColour (buttonColour.withMultipliedSaturation (sat));
+
+ if (isButtonDown)
+ return baseColour.contrasting (0.2f);
+ else if (isMouseOverButton)
+ return baseColour.contrasting (0.1f);
+
+ return baseColour;
+}
+
+LookAndFeel::LookAndFeel()
+{
+ /* if this fails it means you're trying to create a LookAndFeel object before
+ the static Colours have been initialised. That ain't gonna work. It probably
+ means that you're using a static LookAndFeel object and that your compiler has
+ decided to intialise it before the Colours class.
+ */
+ jassert (Colours::white == Colour (0xffffffff));
+
+ // set up the standard set of colours..
+ #define textButtonColour 0xffbbbbff
+ #define textHighlightColour 0x401111ee
+ #define standardOutlineColour 0xb2808080
+
+ static const int standardColours[] =
+ {
+ TextButton::buttonColourId, textButtonColour,
+ TextButton::buttonOnColourId, 0xff4444ff,
+ TextButton::textColourId, 0xff000000,
+
+ ComboBox::buttonColourId, 0xffbbbbff,
+ ComboBox::outlineColourId, standardOutlineColour,
+
+ ToggleButton::textColourId, 0xff000000,
+
+ TextEditor::backgroundColourId, 0xffffffff,
+ TextEditor::textColourId, 0xff000000,
+ TextEditor::highlightColourId, textHighlightColour,
+ TextEditor::highlightedTextColourId, 0xff000000,
+ TextEditor::caretColourId, 0xff000000,
+ TextEditor::outlineColourId, 0x00000000,
+ TextEditor::focusedOutlineColourId, textButtonColour,
+ TextEditor::shadowColourId, 0x38000000,
+
+ Label::backgroundColourId, 0x00000000,
+ Label::textColourId, 0xff000000,
+ Label::outlineColourId, 0x00000000,
+
+ ScrollBar::backgroundColourId, 0x00000000,
+ ScrollBar::thumbColourId, 0xffffffff,
+ ScrollBar::trackColourId, 0xffffffff,
+
+ TreeView::linesColourId, 0x4c000000,
+ TreeView::backgroundColourId, 0x00000000,
+
+ PopupMenu::backgroundColourId, 0xffffffff,
+ PopupMenu::textColourId, 0xff000000,
+ PopupMenu::headerTextColourId, 0xff000000,
+ PopupMenu::highlightedTextColourId, 0xffffffff,
+ PopupMenu::highlightedBackgroundColourId, 0x991111aa,
+
+ ComboBox::textColourId, 0xff000000,
+ ComboBox::backgroundColourId, 0xffffffff,
+ ComboBox::arrowColourId, 0x99000000,
+
+ ListBox::backgroundColourId, 0xffffffff,
+ ListBox::outlineColourId, standardOutlineColour,
+ ListBox::textColourId, 0xff000000,
+
+ Slider::backgroundColourId, 0x00000000,
+ Slider::thumbColourId, textButtonColour,
+ Slider::trackColourId, 0x7fffffff,
+ Slider::rotarySliderFillColourId, 0x7f0000ff,
+ Slider::rotarySliderOutlineColourId, 0x66000000,
+ Slider::textBoxTextColourId, 0xff000000,
+ Slider::textBoxBackgroundColourId, 0xffffffff,
+ Slider::textBoxHighlightColourId, textHighlightColour,
+ Slider::textBoxOutlineColourId, standardOutlineColour,
+
+ AlertWindow::backgroundColourId, 0xffededed,
+ AlertWindow::textColourId, 0xff000000,
+ AlertWindow::outlineColourId, 0xff666666,
+
+ ProgressBar::backgroundColourId, 0xffeeeeee,
+ ProgressBar::foregroundColourId, 0xffaaaaee,
+
+ TooltipWindow::backgroundColourId, 0xffeeeebb,
+ TooltipWindow::textColourId, 0xff000000,
+ TooltipWindow::outlineColourId, 0x4c000000,
+
+ Toolbar::backgroundColourId, 0xfff6f8f9,
+ Toolbar::separatorColourId, 0x4c000000,
+ Toolbar::buttonMouseOverBackgroundColourId, 0x4c0000ff,
+ Toolbar::buttonMouseDownBackgroundColourId, 0x800000ff,
+ Toolbar::labelTextColourId, 0xff000000,
+ Toolbar::editingModeOutlineColourId, 0xffff0000,
+
+ HyperlinkButton::textColourId, 0xcc1111ee,
+
+ GroupComponent::outlineColourId, 0x66000000,
+ GroupComponent::textColourId, 0xff000000,
+
+ DirectoryContentsDisplayComponent::highlightColourId, textHighlightColour,
+ DirectoryContentsDisplayComponent::textColourId, 0xff000000,
+
+ 0x1000440, /*LassoComponent::lassoFillColourId*/ 0x66dddddd,
+ 0x1000441, /*LassoComponent::lassoOutlineColourId*/ 0x99111111,
+
+ MidiKeyboardComponent::whiteNoteColourId, 0xffffffff,
+ MidiKeyboardComponent::blackNoteColourId, 0xff000000,
+ MidiKeyboardComponent::keySeparatorLineColourId, 0x66000000,
+ MidiKeyboardComponent::mouseOverKeyOverlayColourId, 0x80ffff00,
+ MidiKeyboardComponent::keyDownOverlayColourId, 0xffb6b600,
+ MidiKeyboardComponent::textLabelColourId, 0xff000000,
+ MidiKeyboardComponent::upDownButtonBackgroundColourId, 0xffd3d3d3,
+ MidiKeyboardComponent::upDownButtonArrowColourId, 0xff000000,
+
+ ColourSelector::backgroundColourId, 0xffe5e5e5,
+ ColourSelector::labelTextColourId, 0xff000000,
+
+ FileSearchPathListComponent::backgroundColourId, 0xffffffff,
+ };
+
+ for (int i = 0; i < numElementsInArray (standardColours); i += 2)
+ setColour (standardColours [i], Colour (standardColours [i + 1]));
+}
+
+LookAndFeel::~LookAndFeel()
+{
+}
+
+const Colour LookAndFeel::findColour (const int colourId) const throw()
+{
+ const int index = colourIds.indexOf (colourId);
+
+ if (index >= 0)
+ return colours [index];
+
+ jassertfalse
+ return Colours::black;
+}
+
+void LookAndFeel::setColour (const int colourId, const Colour& colour) throw()
+{
+ const int index = colourIds.indexOf (colourId);
+
+ if (index >= 0)
+ colours.set (index, colour);
+
+ colourIds.add (colourId);
+ colours.add (colour);
+}
+
+static LookAndFeel* defaultLF = 0;
+static LookAndFeel* currentDefaultLF = 0;
+
+LookAndFeel& LookAndFeel::getDefaultLookAndFeel() throw()
+{
+ // if this happens, your app hasn't initialised itself properly.. if you're
+ // trying to hack your own main() function, have a look at
+ // JUCEApplication::initialiseForGUI()
+ jassert (currentDefaultLF != 0);
+
+ return *currentDefaultLF;
+}
+
+void LookAndFeel::setDefaultLookAndFeel (LookAndFeel* newDefaultLookAndFeel) throw()
+{
+ if (newDefaultLookAndFeel == 0)
+ {
+ if (defaultLF == 0)
+ defaultLF = new LookAndFeel();
+
+ newDefaultLookAndFeel = defaultLF;
+ }
+
+ currentDefaultLF = newDefaultLookAndFeel;
+
+ for (int i = Desktop::getInstance().getNumComponents(); --i >= 0;)
+ {
+ Component* const c = Desktop::getInstance().getComponent (i);
+
+ if (c != 0)
+ c->sendLookAndFeelChange();
+ }
+}
+
+void LookAndFeel::clearDefaultLookAndFeel() throw()
+{
+ if (currentDefaultLF == defaultLF)
+ currentDefaultLF = 0;
+
+ deleteAndZero (defaultLF);
+}
+
+void LookAndFeel::drawButtonBackground (Graphics& g,
+ Button& button,
+ const Colour& backgroundColour,
+ bool isMouseOverButton,
+ bool isButtonDown)
+{
+ const int width = button.getWidth();
+ const int height = button.getHeight();
+
+ const float outlineThickness = button.isEnabled() ? ((isButtonDown || isMouseOverButton) ? 1.2f : 0.7f) : 0.4f;
+ const float halfThickness = outlineThickness * 0.5f;
+
+ const float indentL = button.isConnectedOnLeft() ? 0.1f : halfThickness;
+ const float indentR = button.isConnectedOnRight() ? 0.1f : halfThickness;
+ const float indentT = button.isConnectedOnTop() ? 0.1f : halfThickness;
+ const float indentB = button.isConnectedOnBottom() ? 0.1f : halfThickness;
+
+ const Colour baseColour (createBaseColour (backgroundColour,
+ button.hasKeyboardFocus (true),
+ isMouseOverButton, isButtonDown)
+ .withMultipliedAlpha (button.isEnabled() ? 1.0f : 0.5f));
+
+ drawGlassLozenge (g,
+ indentL,
+ indentT,
+ width - indentL - indentR,
+ height - indentT - indentB,
+ baseColour, outlineThickness, -1.0f,
+ button.isConnectedOnLeft(),
+ button.isConnectedOnRight(),
+ button.isConnectedOnTop(),
+ button.isConnectedOnBottom());
+}
+
+void LookAndFeel::drawButtonText (Graphics& g, TextButton& button,
+ bool /*isMouseOverButton*/, bool /*isButtonDown*/)
+{
+ g.setFont (button.getFont());
+ g.setColour (button.findColour (TextButton::textColourId)
+ .withMultipliedAlpha (button.isEnabled() ? 1.0f : 0.5f));
+
+ const int yIndent = jmin (4, button.proportionOfHeight (0.3f));
+ const int cornerSize = jmin (button.getHeight(), button.getWidth()) / 2;
+
+ const int fontHeight = roundFloatToInt (g.getCurrentFont().getHeight() * 0.6f);
+ const int leftIndent = jmin (fontHeight, 2 + cornerSize / (button.isConnectedOnLeft() ? 4 : 2));
+ const int rightIndent = jmin (fontHeight, 2 + cornerSize / (button.isConnectedOnRight() ? 4 : 2));
+
+ g.drawFittedText (button.getButtonText(),
+ leftIndent,
+ yIndent,
+ button.getWidth() - leftIndent - rightIndent,
+ button.getHeight() - yIndent * 2,
+ Justification::centred, 2);
+}
+
+void LookAndFeel::drawTickBox (Graphics& g,
+ Component& component,
+ int x, int y, int w, int h,
+ const bool ticked,
+ const bool isEnabled,
+ const bool isMouseOverButton,
+ const bool isButtonDown)
+{
+ const float boxSize = w * 0.7f;
+
+ drawGlassSphere (g, (float) x, y + (h - boxSize) * 0.5f, boxSize,
+ createBaseColour (component.findColour (TextButton::buttonColourId)
+ .withMultipliedAlpha (isEnabled ? 1.0f : 0.5f),
+ true,
+ isMouseOverButton,
+ isButtonDown),
+ isEnabled ? ((isButtonDown || isMouseOverButton) ? 1.1f : 0.5f) : 0.3f);
+
+ if (ticked)
+ {
+ Path tick;
+ tick.startNewSubPath (1.5f, 3.0f);
+ tick.lineTo (3.0f, 6.0f);
+ tick.lineTo (6.0f, 0.0f);
+
+ g.setColour (isEnabled ? Colours::black : Colours::grey);
+
+ const AffineTransform trans (AffineTransform::scale (w / 9.0f, h / 9.0f)
+ .translated ((float) x, (float) y));
+
+ g.strokePath (tick, PathStrokeType (2.5f), trans);
+ }
+}
+
+void LookAndFeel::drawToggleButton (Graphics& g,
+ ToggleButton& button,
+ bool isMouseOverButton,
+ bool isButtonDown)
+{
+ if (button.hasKeyboardFocus (true))
+ {
+ g.setColour (button.findColour (TextEditor::focusedOutlineColourId));
+ g.drawRect (0, 0, button.getWidth(), button.getHeight());
+ }
+
+ const int tickWidth = jmin (20, button.getHeight() - 4);
+
+ drawTickBox (g, button, 4, (button.getHeight() - tickWidth) / 2,
+ tickWidth, tickWidth,
+ button.getToggleState(),
+ button.isEnabled(),
+ isMouseOverButton,
+ isButtonDown);
+
+ g.setColour (button.findColour (ToggleButton::textColourId));
+ g.setFont (jmin (15.0f, button.getHeight() * 0.6f));
+
+ if (! button.isEnabled())
+ g.setOpacity (0.5f);
+
+ const int textX = tickWidth + 5;
+
+ g.drawFittedText (button.getButtonText(),
+ textX, 4,
+ button.getWidth() - textX - 2, button.getHeight() - 8,
+ Justification::centredLeft, 10);
+}
+
+void LookAndFeel::changeToggleButtonWidthToFitText (ToggleButton& button)
+{
+ Font font (jmin (15.0f, button.getHeight() * 0.6f));
+
+ const int tickWidth = jmin (24, button.getHeight());
+
+ button.setSize (font.getStringWidth (button.getButtonText()) + tickWidth + 8,
+ button.getHeight());
+}
+
+void LookAndFeel::drawAlertBox (Graphics& g,
+ AlertWindow& alert,
+ const Rectangle& textArea,
+ TextLayout& textLayout)
+{
+ const int iconWidth = 80;
+
+ const Colour background (alert.findColour (AlertWindow::backgroundColourId));
+
+ g.fillAll (background);
+
+ int iconSpaceUsed = 0;
+ Justification alignment (Justification::horizontallyCentred);
+
+ int iconSize = jmin (iconWidth + 50, alert.getHeight() + 20);
+
+ if (alert.containsAnyExtraComponents() || alert.getNumButtons() > 2)
+ iconSize = jmin (iconSize, textArea.getHeight() + 50);
+
+ const Rectangle iconRect (iconSize / -10,
+ iconSize / -10,
+ iconSize,
+ iconSize);
+
+ if (alert.getAlertType() == AlertWindow::QuestionIcon
+ || alert.getAlertType() == AlertWindow::InfoIcon)
+ {
+ if (alert.getAlertType() == AlertWindow::InfoIcon)
+ g.setColour (background.overlaidWith (Colour (0x280000ff)));
+ else
+ g.setColour (background.overlaidWith (Colours::gold.darker().withAlpha (0.25f)));
+
+ g.fillEllipse ((float) iconRect.getX(),
+ (float) iconRect.getY(),
+ (float) iconRect.getWidth(),
+ (float) iconRect.getHeight());
+
+ g.setColour (background);
+ g.setFont (iconRect.getHeight() * 0.9f, Font::bold);
+ g.drawText ((alert.getAlertType() == AlertWindow::InfoIcon) ? "i"
+ : "?",
+ iconRect.getX(),
+ iconRect.getY(),
+ iconRect.getWidth(),
+ iconRect.getHeight(),
+ Justification::centred, false);
+
+ iconSpaceUsed = iconWidth;
+ alignment = Justification::left;
+ }
+ else if (alert.getAlertType() == AlertWindow::WarningIcon)
+ {
+ Path p;
+ p.addTriangle (iconRect.getX() + iconRect.getWidth() * 0.5f,
+ (float) iconRect.getY(),
+ (float) iconRect.getRight(),
+ (float) iconRect.getBottom(),
+ (float) iconRect.getX(),
+ (float) iconRect.getBottom());
+
+ g.setColour (background.overlaidWith (Colour (0x33ff0000)));
+ g.fillPath (p.createPathWithRoundedCorners (5.0f));
+
+ g.setColour (background);
+ g.setFont (iconRect.getHeight() * 0.9f, Font::bold);
+
+ g.drawText (T("!"),
+ iconRect.getX(),
+ iconRect.getY(),
+ iconRect.getWidth(),
+ iconRect.getHeight() + iconRect.getHeight() / 8,
+ Justification::centred, false);
+
+ iconSpaceUsed = iconWidth;
+ alignment = Justification::left;
+ }
+
+ g.setColour (alert.findColour (AlertWindow::textColourId));
+
+ textLayout.drawWithin (g,
+ textArea.getX() + iconSpaceUsed,
+ textArea.getY(),
+ textArea.getWidth() - iconSpaceUsed,
+ textArea.getHeight(),
+ alignment.getFlags() | Justification::top);
+
+ g.setColour (alert.findColour (AlertWindow::outlineColourId));
+ g.drawRect (0, 0, alert.getWidth(), alert.getHeight());
+}
+
+int LookAndFeel::getAlertBoxWindowFlags()
+{
+ return ComponentPeer::windowAppearsOnTaskbar
+ | ComponentPeer::windowHasDropShadow;
+}
+
+void LookAndFeel::drawProgressBar (Graphics& g, ProgressBar& progressBar,
+ int width, int height,
+ double progress, const String& textToShow)
+{
+ const Colour background (progressBar.findColour (ProgressBar::backgroundColourId));
+ const Colour foreground (progressBar.findColour (ProgressBar::foregroundColourId));
+
+ g.fillAll (background);
+
+ if (progress >= 0.0f && progress < 1.0f)
+ {
+ drawGlassLozenge (g, 1.0f, 1.0f,
+ (float) jlimit (0.0, width - 2.0, progress * (width - 2.0)),
+ (float) (height - 2),
+ foreground,
+ 0.5f, 0.0f,
+ true, true, true, true);
+ }
+ else
+ {
+ // spinning bar..
+ g.setColour (foreground);
+
+ const int stripeWidth = height * 2;
+ const int position = (Time::getMillisecondCounter() / 15) % stripeWidth;
+
+ Path p;
+
+ for (float x = (float) (stripeWidth - position); x < width + stripeWidth; x += stripeWidth)
+ p.addQuadrilateral (x, 0.0f,
+ x + stripeWidth * 0.5f, 0.0f,
+ x, (float) height,
+ x - stripeWidth * 0.5f, (float) height);
+
+ Image im (Image::ARGB, width, height, true);
+
+ {
+ Graphics g (im);
+ drawGlassLozenge (g, 1.0f, 1.0f,
+ (float) (width - 2),
+ (float) (height - 2),
+ foreground,
+ 0.5f, 0.0f,
+ true, true, true, true);
+ }
+
+ ImageBrush ib (&im, 0, 0, 0.85f);
+ g.setBrush (&ib);
+
+ g.fillPath (p);
+ }
+
+ if (textToShow.isNotEmpty())
+ {
+ g.setColour (Colour::contrasting (background, foreground));
+ g.setFont (height * 0.6f);
+
+ g.drawText (textToShow, 0, 0, width, height, Justification::centred, false);
+ }
+}
+
+void LookAndFeel::drawScrollbarButton (Graphics& g,
+ ScrollBar& scrollbar,
+ int width, int height,
+ int buttonDirection,
+ bool /*isScrollbarVertical*/,
+ bool /*isMouseOverButton*/,
+ bool isButtonDown)
+{
+ Path p;
+
+ if (buttonDirection == 0)
+ p.addTriangle (width * 0.5f, height * 0.2f,
+ width * 0.1f, height * 0.7f,
+ width * 0.9f, height * 0.7f);
+ else if (buttonDirection == 1)
+ p.addTriangle (width * 0.8f, height * 0.5f,
+ width * 0.3f, height * 0.1f,
+ width * 0.3f, height * 0.9f);
+ else if (buttonDirection == 2)
+ p.addTriangle (width * 0.5f, height * 0.8f,
+ width * 0.1f, height * 0.3f,
+ width * 0.9f, height * 0.3f);
+ else if (buttonDirection == 3)
+ p.addTriangle (width * 0.2f, height * 0.5f,
+ width * 0.7f, height * 0.1f,
+ width * 0.7f, height * 0.9f);
+
+ if (isButtonDown)
+ g.setColour (scrollbar.findColour (ScrollBar::thumbColourId).contrasting (0.2f));
+ else
+ g.setColour (scrollbar.findColour (ScrollBar::thumbColourId));
+
+ g.fillPath (p);
+
+ g.setColour (Colour (0x80000000));
+ g.strokePath (p, PathStrokeType (0.5f));
+}
+
+void LookAndFeel::drawScrollbar (Graphics& g,
+ ScrollBar& scrollbar,
+ int x, int y,
+ int width, int height,
+ bool isScrollbarVertical,
+ int thumbStartPosition,
+ int thumbSize,
+ bool /*isMouseOver*/,
+ bool /*isMouseDown*/)
+{
+ g.fillAll (scrollbar.findColour (ScrollBar::backgroundColourId));
+
+ Path slotPath, thumbPath;
+
+ const float slotIndent = jmin (width, height) > 15 ? 1.0f : 0.0f;
+ const float slotIndentx2 = slotIndent * 2.0f;
+ const float thumbIndent = slotIndent + 1.0f;
+ const float thumbIndentx2 = thumbIndent * 2.0f;
+
+ float gx1 = 0.0f, gy1 = 0.0f, gx2 = 0.0f, gy2 = 0.0f;
+
+ if (isScrollbarVertical)
+ {
+ slotPath.addRoundedRectangle (x + slotIndent,
+ y + slotIndent,
+ width - slotIndentx2,
+ height - slotIndentx2,
+ (width - slotIndentx2) * 0.5f);
+
+ if (thumbSize > 0)
+ thumbPath.addRoundedRectangle (x + thumbIndent,
+ thumbStartPosition + thumbIndent,
+ width - thumbIndentx2,
+ thumbSize - thumbIndentx2,
+ (width - thumbIndentx2) * 0.5f);
+ gx1 = (float) x;
+ gx2 = x + width * 0.7f;
+ }
+ else
+ {
+ slotPath.addRoundedRectangle (x + slotIndent,
+ y + slotIndent,
+ width - slotIndentx2,
+ height - slotIndentx2,
+ (height - slotIndentx2) * 0.5f);
+
+ if (thumbSize > 0)
+ thumbPath.addRoundedRectangle (thumbStartPosition + thumbIndent,
+ y + thumbIndent,
+ thumbSize - thumbIndentx2,
+ height - thumbIndentx2,
+ (height - thumbIndentx2) * 0.5f);
+ gy1 = (float) y;
+ gy2 = y + height * 0.7f;
+ }
+
+ const Colour thumbColour (scrollbar.findColour (ScrollBar::trackColourId));
+
+ GradientBrush gb (thumbColour.overlaidWith (Colour (0x44000000)),
+ gx1, gy1,
+ thumbColour.overlaidWith (Colour (0x19000000)),
+ gx2, gy2, false);
+
+ g.setBrush (&gb);
+ g.fillPath (slotPath);
+
+ if (isScrollbarVertical)
+ {
+ gx1 = x + width * 0.6f;
+ gx2 = (float) x + width;
+ }
+ else
+ {
+ gy1 = y + height * 0.6f;
+ gy2 = (float) y + height;
+ }
+
+ GradientBrush gb2 (Colours::transparentBlack,
+ gx1, gy1,
+ Colour (0x19000000),
+ gx2, gy2, false);
+
+ g.setBrush (&gb2);
+ g.fillPath (slotPath);
+
+ g.setColour (thumbColour);
+ g.fillPath (thumbPath);
+
+ GradientBrush gb3 (Colour (0x10000000),
+ gx1, gy1,
+ Colours::transparentBlack,
+ gx2, gy2, false);
+
+ g.saveState();
+ g.setBrush (&gb3);
+
+ if (isScrollbarVertical)
+ g.reduceClipRegion (x + width / 2, y, width, height);
+ else
+ g.reduceClipRegion (x, y + height / 2, width, height);
+
+ g.fillPath (thumbPath);
+ g.restoreState();
+
+ g.setColour (Colour (0x4c000000));
+ g.strokePath (thumbPath, PathStrokeType (0.4f));
+}
+
+ImageEffectFilter* LookAndFeel::getScrollbarEffect()
+{
+ return 0;
+}
+
+int LookAndFeel::getMinimumScrollbarThumbSize (ScrollBar& scrollbar)
+{
+ return jmin (scrollbar.getWidth(), scrollbar.getHeight()) * 2;
+}
+
+int LookAndFeel::getDefaultScrollbarWidth()
+{
+ return 18;
+}
+
+int LookAndFeel::getScrollbarButtonSize (ScrollBar& scrollbar)
+{
+ return 2 + (scrollbar.isVertical() ? scrollbar.getWidth()
+ : scrollbar.getHeight());
+}
+
+const Path LookAndFeel::getTickShape (const float height)
+{
+ static const unsigned char tickShapeData[] =
+ {
+ 109,0,224,168,68,0,0,119,67,108,0,224,172,68,0,128,146,67,113,0,192,148,68,0,0,219,67,0,96,110,68,0,224,56,68,113,0,64,51,68,0,32,130,68,0,64,20,68,0,224,
+ 162,68,108,0,128,3,68,0,128,168,68,113,0,128,221,67,0,192,175,68,0,0,207,67,0,32,179,68,113,0,0,201,67,0,224,173,68,0,0,181,67,0,224,161,68,108,0,128,168,67,
+ 0,128,154,68,113,0,128,141,67,0,192,138,68,0,128,108,67,0,64,131,68,113,0,0,62,67,0,128,119,68,0,0,5,67,0,128,114,68,113,0,0,102,67,0,192,88,68,0,128,155,
+ 67,0,192,88,68,113,0,0,190,67,0,192,88,68,0,128,232,67,0,224,131,68,108,0,128,246,67,0,192,139,68,113,0,64,33,68,0,128,87,68,0,0,93,68,0,224,26,68,113,0,
+ 96,140,68,0,128,188,67,0,224,168,68,0,0,119,67,99,101
+ };
+
+ Path p;
+ p.loadPathFromData (tickShapeData, sizeof (tickShapeData));
+ p.scaleToFit (0, 0, height * 2.0f, height, true);
+ return p;
+}
+
+const Path LookAndFeel::getCrossShape (const float height)
+{
+ static const unsigned char crossShapeData[] =
+ {
+ 109,0,0,17,68,0,96,145,68,108,0,192,13,68,0,192,147,68,113,0,0,213,67,0,64,174,68,0,0,168,67,0,64,174,68,113,0,0,104,67,0,64,174,68,0,0,5,67,0,64,
+ 153,68,113,0,0,18,67,0,64,153,68,0,0,24,67,0,64,153,68,113,0,0,135,67,0,64,153,68,0,128,207,67,0,224,130,68,108,0,0,220,67,0,0,126,68,108,0,0,204,67,
+ 0,128,117,68,113,0,0,138,67,0,64,82,68,0,0,138,67,0,192,57,68,113,0,0,138,67,0,192,37,68,0,128,210,67,0,64,10,68,113,0,128,220,67,0,64,45,68,0,0,8,
+ 68,0,128,78,68,108,0,192,14,68,0,0,87,68,108,0,64,20,68,0,0,80,68,113,0,192,57,68,0,0,32,68,0,128,88,68,0,0,32,68,113,0,64,112,68,0,0,32,68,0,
+ 128,124,68,0,64,68,68,113,0,0,121,68,0,192,67,68,0,128,119,68,0,192,67,68,113,0,192,108,68,0,192,67,68,0,32,89,68,0,96,82,68,113,0,128,69,68,0,0,97,68,
+ 0,0,56,68,0,64,115,68,108,0,64,49,68,0,128,124,68,108,0,192,55,68,0,96,129,68,113,0,0,92,68,0,224,146,68,0,192,129,68,0,224,146,68,113,0,64,110,68,0,64,
+ 168,68,0,64,87,68,0,64,168,68,113,0,128,66,68,0,64,168,68,0,64,27,68,0,32,150,68,99,101
+ };
+
+ Path p;
+ p.loadPathFromData (crossShapeData, sizeof (crossShapeData));
+ p.scaleToFit (0, 0, height * 2.0f, height, true);
+ return p;
+}
+
+void LookAndFeel::drawTreeviewPlusMinusBox (Graphics& g, int x, int y, int w, int h, bool isPlus)
+{
+ const int boxSize = ((jmin (16, w, h) << 1) / 3) | 1;
+
+ x += (w - boxSize) >> 1;
+ y += (h - boxSize) >> 1;
+ w = boxSize;
+ h = boxSize;
+
+ g.setColour (Colour (0xe5ffffff));
+ g.fillRect (x, y, w, h);
+
+ g.setColour (Colour (0x80000000));
+ g.drawRect (x, y, w, h);
+
+ const float size = boxSize / 2 + 1.0f;
+ const float centre = (float) (boxSize / 2);
+
+ g.fillRect (x + (w - size) * 0.5f, y + centre, size, 1.0f);
+
+ if (isPlus)
+ g.fillRect (x + centre, y + (h - size) * 0.5f, 1.0f, size);
+}
+
+void LookAndFeel::drawBubble (Graphics& g,
+ float tipX, float tipY,
+ float boxX, float boxY,
+ float boxW, float boxH)
+{
+ int side = 0;
+
+ if (tipX < boxX)
+ side = 1;
+ else if (tipX > boxX + boxW)
+ side = 3;
+ else if (tipY > boxY + boxH)
+ side = 2;
+
+ const float indent = 2.0f;
+ Path p;
+ p.addBubble (boxX + indent,
+ boxY + indent,
+ boxW - indent * 2.0f,
+ boxH - indent * 2.0f,
+ 5.0f,
+ tipX, tipY,
+ side,
+ 0.5f,
+ jmin (15.0f, boxW * 0.3f, boxH * 0.3f));
+
+ //xxx need to take comp as param for colour
+ g.setColour (findColour (TooltipWindow::backgroundColourId).withAlpha (0.9f));
+ g.fillPath (p);
+
+ //xxx as above
+ g.setColour (findColour (TooltipWindow::textColourId).withAlpha (0.4f));
+ g.strokePath (p, PathStrokeType (1.33f));
+}
+
+const Font LookAndFeel::getPopupMenuFont()
+{
+ return Font (17.0f);
+}
+
+void LookAndFeel::getIdealPopupMenuItemSize (const String& text,
+ const bool isSeparator,
+ int standardMenuItemHeight,
+ int& idealWidth,
+ int& idealHeight)
+{
+ if (isSeparator)
+ {
+ idealWidth = 50;
+ idealHeight = standardMenuItemHeight > 0 ? standardMenuItemHeight / 2 : 10;
+ }
+ else
+ {
+ Font font (getPopupMenuFont());
+
+ if (standardMenuItemHeight > 0 && font.getHeight() > standardMenuItemHeight / 1.3f)
+ font.setHeight (standardMenuItemHeight / 1.3f);
+
+ idealHeight = standardMenuItemHeight > 0 ? standardMenuItemHeight : roundFloatToInt (font.getHeight() * 1.3f);
+ idealWidth = font.getStringWidth (text) + idealHeight * 2;
+ }
+}
+
+void LookAndFeel::drawPopupMenuBackground (Graphics& g, int width, int height)
+{
+ const Colour background (findColour (PopupMenu::backgroundColourId));
+
+ g.fillAll (background);
+ g.setColour (background.overlaidWith (Colour (0x2badd8e6)));
+
+ for (int i = 0; i < height; i += 3)
+ g.fillRect (0, i, width, 1);
+
+ g.setColour (findColour (PopupMenu::textColourId).withAlpha (0.6f));
+ g.drawRect (0, 0, width, height);
+}
+
+void LookAndFeel::drawPopupMenuUpDownArrow (Graphics& g,
+ int width, int height,
+ bool isScrollUpArrow)
+{
+ const Colour background (findColour (PopupMenu::backgroundColourId));
+
+ GradientBrush gb (background,
+ 0.0f, height * 0.5f,
+ background.withAlpha (0.0f),
+ 0.0f, isScrollUpArrow ? ((float) height) : 0.0f,
+ false);
+
+ g.setBrush (&gb);
+ g.fillRect (1, 1, width - 2, height - 2);
+
+ const float hw = width * 0.5f;
+ const float arrowW = height * 0.3f;
+ const float y1 = height * (isScrollUpArrow ? 0.6f : 0.3f);
+ const float y2 = height * (isScrollUpArrow ? 0.3f : 0.6f);
+
+ Path p;
+ p.addTriangle (hw - arrowW, y1,
+ hw + arrowW, y1,
+ hw, y2);
+
+ g.setColour (findColour (PopupMenu::textColourId).withAlpha (0.5f));
+ g.fillPath (p);
+}
+
+void LookAndFeel::drawPopupMenuItem (Graphics& g,
+ int width, int height,
+ const bool isSeparator,
+ const bool isActive,
+ const bool isHighlighted,
+ const bool isTicked,
+ const bool hasSubMenu,
+ const String& text,
+ const String& shortcutKeyText,
+ Image* image,
+ const Colour* const textColourToUse)
+{
+ const float halfH = height * 0.5f;
+
+ if (isSeparator)
+ {
+ const float separatorIndent = 5.5f;
+
+ g.setColour (Colour (0x33000000));
+ g.drawLine (separatorIndent, halfH, width - separatorIndent, halfH);
+
+ g.setColour (Colour (0x66ffffff));
+ g.drawLine (separatorIndent, halfH + 1.0f, width - separatorIndent, halfH + 1.0f);
+ }
+ else
+ {
+ Colour textColour (findColour (PopupMenu::textColourId));
+
+ if (textColourToUse != 0)
+ textColour = *textColourToUse;
+
+ if (isHighlighted)
+ {
+ g.setColour (findColour (PopupMenu::highlightedBackgroundColourId));
+ g.fillRect (1, 1, width - 2, height - 2);
+
+ g.setColour (findColour (PopupMenu::highlightedTextColourId));
+ }
+ else
+ {
+ g.setColour (textColour);
+ }
+
+ if (! isActive)
+ g.setOpacity (0.3f);
+
+ Font font (getPopupMenuFont());
+
+ if (font.getHeight() > height / 1.3f)
+ font.setHeight (height / 1.3f);
+
+ g.setFont (font);
+
+ const int leftBorder = (height * 5) / 4;
+ const int rightBorder = 4;
+
+ if (image != 0)
+ {
+ g.drawImageWithin (image,
+ 2, 1, leftBorder - 4, height - 2,
+ RectanglePlacement::centred | RectanglePlacement::onlyReduceInSize, false);
+ }
+ else if (isTicked)
+ {
+ const Path tick (getTickShape (1.0f));
+ const float th = font.getAscent();
+ const float ty = halfH - th * 0.5f;
+
+ g.fillPath (tick, tick.getTransformToScaleToFit (2.0f, ty, (float) (leftBorder - 4),
+ th, true));
+ }
+
+ g.drawFittedText (text,
+ leftBorder, 0,
+ width - (leftBorder + rightBorder), height,
+ Justification::centredLeft, 1);
+
+ if (shortcutKeyText.isNotEmpty())
+ {
+ Font f2 (g.getCurrentFont());
+ f2.setHeight (f2.getHeight() * 0.75f);
+ f2.setHorizontalScale (0.95f);
+ g.setFont (f2);
+
+ g.drawText (shortcutKeyText,
+ leftBorder,
+ 0,
+ width - (leftBorder + rightBorder + 4),
+ height,
+ Justification::centredRight,
+ true);
+ }
+
+ if (hasSubMenu)
+ {
+ const float arrowH = 0.6f * getPopupMenuFont().getAscent();
+ const float x = width - height * 0.6f;
+
+ Path p;
+ p.addTriangle (x, halfH - arrowH * 0.5f,
+ x, halfH + arrowH * 0.5f,
+ x + arrowH * 0.6f, halfH);
+
+ g.fillPath (p);
+ }
+ }
+}
+
+int LookAndFeel::getMenuWindowFlags()
+{
+ return ComponentPeer::windowHasDropShadow;
+}
+
+void LookAndFeel::drawMenuBarBackground (Graphics& g, int width, int height,
+ bool, MenuBarComponent& menuBar)
+{
+ const Colour baseColour (createBaseColour (menuBar.findColour (PopupMenu::backgroundColourId), false, false, false));
+
+ if (menuBar.isEnabled())
+ {
+ drawShinyButtonShape (g,
+ -4.0f, 0.0f,
+ width + 8.0f, (float) height,
+ 0.0f,
+ baseColour,
+ 0.4f,
+ true, true, true, true);
+ }
+ else
+ {
+ g.fillAll (baseColour);
+ }
+}
+
+const Font LookAndFeel::getMenuBarFont (MenuBarComponent& menuBar, int /*itemIndex*/, const String& /*itemText*/)
+{
+ return Font (menuBar.getHeight() * 0.7f);
+}
+
+int LookAndFeel::getMenuBarItemWidth (MenuBarComponent& menuBar, int itemIndex, const String& itemText)
+{
+ return getMenuBarFont (menuBar, itemIndex, itemText)
+ .getStringWidth (itemText) + menuBar.getHeight();
+}
+
+void LookAndFeel::drawMenuBarItem (Graphics& g,
+ int width, int height,
+ int itemIndex,
+ const String& itemText,
+ bool isMouseOverItem,
+ bool isMenuOpen,
+ bool /*isMouseOverBar*/,
+ MenuBarComponent& menuBar)
+{
+ if (! menuBar.isEnabled())
+ {
+ g.setColour (menuBar.findColour (PopupMenu::textColourId)
+ .withMultipliedAlpha (0.5f));
+ }
+ else if (isMenuOpen || isMouseOverItem)
+ {
+ g.fillAll (menuBar.findColour (PopupMenu::highlightedBackgroundColourId));
+ g.setColour (menuBar.findColour (PopupMenu::highlightedTextColourId));
+ }
+ else
+ {
+ g.setColour (menuBar.findColour (PopupMenu::textColourId));
+ }
+
+ g.setFont (getMenuBarFont (menuBar, itemIndex, itemText));
+ g.drawFittedText (itemText, 0, 0, width, height, Justification::centred, 1);
+}
+
+void LookAndFeel::fillTextEditorBackground (Graphics& g, int /*width*/, int /*height*/,
+ TextEditor& textEditor)
+{
+ g.fillAll (textEditor.findColour (TextEditor::backgroundColourId));
+}
+
+void LookAndFeel::drawTextEditorOutline (Graphics& g, int width, int height, TextEditor& textEditor)
+{
+ if (textEditor.isEnabled())
+ {
+ if (textEditor.hasKeyboardFocus (true) && ! textEditor.isReadOnly())
+ {
+ const int border = 2;
+
+ g.setColour (textEditor.findColour (TextEditor::focusedOutlineColourId));
+ g.drawRect (0, 0, width, height, border);
+
+ g.setOpacity (1.0f);
+ const Colour shadowColour (textEditor.findColour (TextEditor::shadowColourId).withMultipliedAlpha (0.75f));
+ g.drawBevel (0, 0, width, height + 2, border + 2, shadowColour, shadowColour);
+ }
+ else
+ {
+ g.setColour (textEditor.findColour (TextEditor::outlineColourId));
+ g.drawRect (0, 0, width, height);
+
+ g.setOpacity (1.0f);
+ const Colour shadowColour (textEditor.findColour (TextEditor::shadowColourId));
+ g.drawBevel (0, 0, width, height + 2, 3, shadowColour, shadowColour);
+ }
+ }
+}
+
+void LookAndFeel::drawComboBox (Graphics& g, int width, int height,
+ const bool isButtonDown,
+ int buttonX, int buttonY,
+ int buttonW, int buttonH,
+ ComboBox& box)
+{
+ g.fillAll (box.findColour (ComboBox::backgroundColourId));
+
+ if (box.isEnabled() && box.hasKeyboardFocus (false))
+ {
+ g.setColour (box.findColour (TextButton::buttonColourId));
+ g.drawRect (0, 0, width, height, 2);
+ }
+ else
+ {
+ g.setColour (box.findColour (ComboBox::outlineColourId));
+ g.drawRect (0, 0, width, height);
+ }
+
+ const float outlineThickness = box.isEnabled() ? (isButtonDown ? 1.2f : 0.5f) : 0.3f;
+
+ const Colour baseColour (createBaseColour (box.findColour (ComboBox::buttonColourId),
+ box.hasKeyboardFocus (true),
+ false, isButtonDown)
+ .withMultipliedAlpha (box.isEnabled() ? 1.0f : 0.5f));
+
+ drawGlassLozenge (g,
+ buttonX + outlineThickness, buttonY + outlineThickness,
+ buttonW - outlineThickness * 2.0f, buttonH - outlineThickness * 2.0f,
+ baseColour, outlineThickness, -1.0f,
+ true, true, true, true);
+
+ if (box.isEnabled())
+ {
+ const float arrowX = 0.3f;
+ const float arrowH = 0.2f;
+
+ Path p;
+ p.addTriangle (buttonX + buttonW * 0.5f, buttonY + buttonH * (0.45f - arrowH),
+ buttonX + buttonW * (1.0f - arrowX), buttonY + buttonH * 0.45f,
+ buttonX + buttonW * arrowX, buttonY + buttonH * 0.45f);
+
+ p.addTriangle (buttonX + buttonW * 0.5f, buttonY + buttonH * (0.55f + arrowH),
+ buttonX + buttonW * (1.0f - arrowX), buttonY + buttonH * 0.55f,
+ buttonX + buttonW * arrowX, buttonY + buttonH * 0.55f);
+
+ g.setColour (box.findColour (ComboBox::arrowColourId));
+ g.fillPath (p);
+ }
+}
+
+const Font LookAndFeel::getComboBoxFont (ComboBox& box)
+{
+ return Font (jmin (15.0f, box.getHeight() * 0.85f));
+}
+
+Label* LookAndFeel::createComboBoxTextBox (ComboBox&)
+{
+ return new Label (String::empty, String::empty);
+}
+
+void LookAndFeel::drawLinearSliderBackground (Graphics& g,
+ int x, int y,
+ int width, int height,
+ float /*sliderPos*/,
+ float /*minSliderPos*/,
+ float /*maxSliderPos*/,
+ const Slider::SliderStyle /*style*/,
+ Slider& slider)
+{
+ const float sliderRadius = (float) (getSliderThumbRadius (slider) - 2);
+
+ const Colour trackColour (slider.findColour (Slider::trackColourId));
+ const Colour gradCol1 (trackColour.overlaidWith (Colours::black.withAlpha (slider.isEnabled() ? 0.25f : 0.13f)));
+ const Colour gradCol2 (trackColour.overlaidWith (Colour (0x14000000)));
+ Path indent;
+
+ if (slider.isHorizontal())
+ {
+ const float iy = y + height * 0.5f - sliderRadius * 0.5f;
+ const float ih = sliderRadius;
+
+ GradientBrush gb (gradCol1, 0.0f, iy,
+ gradCol2, 0.0f, iy + ih, false);
+ g.setBrush (&gb);
+
+ indent.addRoundedRectangle (x - sliderRadius * 0.5f, iy,
+ width + sliderRadius, ih,
+ 5.0f);
+ g.fillPath (indent);
+ }
+ else
+ {
+ const float ix = x + width * 0.5f - sliderRadius * 0.5f;
+ const float iw = sliderRadius;
+
+ GradientBrush gb (gradCol1, ix, 0.0f,
+ gradCol2, ix + iw, 0.0f, false);
+ g.setBrush (&gb);
+
+ indent.addRoundedRectangle (ix, y - sliderRadius * 0.5f,
+ iw, height + sliderRadius,
+ 5.0f);
+ g.fillPath (indent);
+ }
+
+ g.setColour (Colour (0x4c000000));
+ g.strokePath (indent, PathStrokeType (0.5f));
+}
+
+void LookAndFeel::drawLinearSliderThumb (Graphics& g,
+ int x, int y,
+ int width, int height,
+ float sliderPos,
+ float minSliderPos,
+ float maxSliderPos,
+ const Slider::SliderStyle style,
+ Slider& slider)
+{
+ const float sliderRadius = (float) (getSliderThumbRadius (slider) - 2);
+
+ Colour knobColour (createBaseColour (slider.findColour (Slider::thumbColourId),
+ slider.hasKeyboardFocus (false) && slider.isEnabled(),
+ slider.isMouseOverOrDragging() && slider.isEnabled(),
+ slider.isMouseButtonDown() && slider.isEnabled()));
+
+ const float outlineThickness = slider.isEnabled() ? 0.8f : 0.3f;
+
+ if (style == Slider::LinearHorizontal || style == Slider::LinearVertical)
+ {
+ float kx, ky;
+
+ if (style == Slider::LinearVertical)
+ {
+ kx = x + width * 0.5f;
+ ky = sliderPos;
+ }
+ else
+ {
+ kx = sliderPos;
+ ky = y + height * 0.5f;
+ }
+
+ drawGlassSphere (g,
+ kx - sliderRadius,
+ ky - sliderRadius,
+ sliderRadius * 2.0f,
+ knobColour, outlineThickness);
+ }
+ else
+ {
+ if (style == Slider::ThreeValueVertical)
+ {
+ drawGlassSphere (g, x + width * 0.5f - sliderRadius,
+ sliderPos - sliderRadius,
+ sliderRadius * 2.0f,
+ knobColour, outlineThickness);
+ }
+ else if (style == Slider::ThreeValueHorizontal)
+ {
+ drawGlassSphere (g,sliderPos - sliderRadius,
+ y + height * 0.5f - sliderRadius,
+ sliderRadius * 2.0f,
+ knobColour, outlineThickness);
+ }
+
+ if (style == Slider::TwoValueVertical || style == Slider::ThreeValueVertical)
+ {
+ const float sr = jmin (sliderRadius, width * 0.4f);
+
+ drawGlassPointer (g, jmax (0.0f, x + width * 0.5f - sliderRadius * 2.0f),
+ minSliderPos - sliderRadius,
+ sliderRadius * 2.0f, knobColour, outlineThickness, 1);
+
+ drawGlassPointer (g, jmin (x + width - sliderRadius * 2.0f, x + width * 0.5f), maxSliderPos - sr,
+ sliderRadius * 2.0f, knobColour, outlineThickness, 3);
+ }
+ else if (style == Slider::TwoValueHorizontal || style == Slider::ThreeValueHorizontal)
+ {
+ const float sr = jmin (sliderRadius, height * 0.4f);
+
+ drawGlassPointer (g, minSliderPos - sr,
+ jmax (0.0f, y + height * 0.5f - sliderRadius * 2.0f),
+ sliderRadius * 2.0f, knobColour, outlineThickness, 2);
+
+ drawGlassPointer (g, maxSliderPos - sliderRadius,
+ jmin (y + height - sliderRadius * 2.0f, y + height * 0.5f),
+ sliderRadius * 2.0f, knobColour, outlineThickness, 4);
+ }
+ }
+}
+
+void LookAndFeel::drawLinearSlider (Graphics& g,
+ int x, int y,
+ int width, int height,
+ float sliderPos,
+ float minSliderPos,
+ float maxSliderPos,
+ const Slider::SliderStyle style,
+ Slider& slider)
+{
+ g.fillAll (slider.findColour (Slider::backgroundColourId));
+
+ if (style == Slider::LinearBar)
+ {
+ const bool isMouseOver = slider.isMouseOverOrDragging() && slider.isEnabled();
+
+ Colour baseColour (createBaseColour (slider.findColour (Slider::thumbColourId)
+ .withMultipliedSaturation (slider.isEnabled() ? 1.0f : 0.5f),
+ false,
+ isMouseOver,
+ isMouseOver || slider.isMouseButtonDown()));
+
+ drawShinyButtonShape (g,
+ (float) x, (float) y, sliderPos - (float) x, (float) height, 0.0f,
+ baseColour,
+ slider.isEnabled() ? 0.9f : 0.3f,
+ true, true, true, true);
+ }
+ else
+ {
+ drawLinearSliderBackground (g, x, y, width, height, sliderPos, minSliderPos, maxSliderPos, style, slider);
+ drawLinearSliderThumb (g, x, y, width, height, sliderPos, minSliderPos, maxSliderPos, style, slider);
+ }
+}
+
+int LookAndFeel::getSliderThumbRadius (Slider& slider)
+{
+ return jmin (7,
+ slider.getHeight() / 2,
+ slider.getWidth() / 2) + 2;
+}
+
+void LookAndFeel::drawRotarySlider (Graphics& g,
+ int x, int y,
+ int width, int height,
+ float sliderPos,
+ const float rotaryStartAngle,
+ const float rotaryEndAngle,
+ Slider& slider)
+{
+ const float radius = jmin (width / 2, height / 2) - 2.0f;
+ const float centreX = x + width * 0.5f;
+ const float centreY = y + height * 0.5f;
+ const float rx = centreX - radius;
+ const float ry = centreY - radius;
+ const float rw = radius * 2.0f;
+ const float angle = rotaryStartAngle + sliderPos * (rotaryEndAngle - rotaryStartAngle);
+ const bool isMouseOver = slider.isMouseOverOrDragging() && slider.isEnabled();
+
+ if (radius > 12.0f)
+ {
+ if (slider.isEnabled())
+ g.setColour (slider.findColour (Slider::rotarySliderFillColourId).withAlpha (isMouseOver ? 1.0f : 0.7f));
+ else
+ g.setColour (Colour (0x80808080));
+
+ const float thickness = 0.7f;
+
+ {
+ Path filledArc;
+ filledArc.addPieSegment (rx, ry, rw, rw,
+ rotaryStartAngle,
+ angle,
+ thickness);
+
+ g.fillPath (filledArc);
+ }
+
+ if (thickness > 0)
+ {
+ const float innerRadius = radius * 0.2f;
+ Path p;
+ p.addTriangle (-innerRadius, 0.0f,
+ 0.0f, -radius * thickness * 1.1f,
+ innerRadius, 0.0f);
+
+ p.addEllipse (-innerRadius, -innerRadius, innerRadius * 2.0f, innerRadius * 2.0f);
+
+ g.fillPath (p, AffineTransform::rotation (angle).translated (centreX, centreY));
+ }
+
+ if (slider.isEnabled())
+ {
+ g.setColour (slider.findColour (Slider::rotarySliderOutlineColourId));
+ Path outlineArc;
+ outlineArc.addPieSegment (rx, ry, rw, rw, rotaryStartAngle, rotaryEndAngle, thickness);
+ outlineArc.closeSubPath();
+
+ g.strokePath (outlineArc, PathStrokeType (slider.isEnabled() ? (isMouseOver ? 2.0f : 1.2f) : 0.3f));
+ }
+ }
+ else
+ {
+ if (slider.isEnabled())
+ g.setColour (slider.findColour (Slider::rotarySliderFillColourId).withAlpha (isMouseOver ? 1.0f : 0.7f));
+ else
+ g.setColour (Colour (0x80808080));
+
+ Path p;
+ p.addEllipse (-0.4f * rw, -0.4f * rw, rw * 0.8f, rw * 0.8f);
+ PathStrokeType (rw * 0.1f).createStrokedPath (p, p);
+
+ p.addLineSegment (0.0f, 0.0f, 0.0f, -radius, rw * 0.2f);
+
+ g.fillPath (p, AffineTransform::rotation (angle).translated (centreX, centreY));
+ }
+}
+
+Button* LookAndFeel::createSliderButton (const bool isIncrement)
+{
+ return new TextButton (isIncrement ? "+" : "-", String::empty);
+}
+
+Label* LookAndFeel::createSliderTextBox (Slider& slider)
+{
+ Label* const l = new Label (T("n"), String::empty);
+
+ l->setJustificationType (Justification::centred);
+
+ l->setColour (Label::textColourId, slider.findColour (Slider::textBoxTextColourId));
+
+ l->setColour (Label::backgroundColourId,
+ (slider.getSliderStyle() == Slider::LinearBar) ? Colours::transparentBlack
+ : slider.findColour (Slider::textBoxBackgroundColourId));
+ l->setColour (Label::outlineColourId, slider.findColour (Slider::textBoxOutlineColourId));
+
+ l->setColour (TextEditor::textColourId, slider.findColour (Slider::textBoxTextColourId));
+
+ l->setColour (TextEditor::backgroundColourId,
+ slider.findColour (Slider::textBoxBackgroundColourId)
+ .withAlpha (slider.getSliderStyle() == Slider::LinearBar ? 0.7f : 1.0f));
+
+ l->setColour (TextEditor::outlineColourId, slider.findColour (Slider::textBoxOutlineColourId));
+
+ return l;
+}
+
+ImageEffectFilter* LookAndFeel::getSliderEffect()
+{
+ return 0;
+}
+
+static const TextLayout layoutTooltipText (const String& text) throw()
+{
+ const float tooltipFontSize = 15.0f;
+ const int maxToolTipWidth = 400;
+
+ const Font f (tooltipFontSize, Font::bold);
+ TextLayout tl (text, f);
+ tl.layout (maxToolTipWidth, Justification::left, true);
+
+ return tl;
+}
+
+void LookAndFeel::getTooltipSize (const String& tipText, int& width, int& height)
+{
+ const TextLayout tl (layoutTooltipText (tipText));
+
+ width = tl.getWidth() + 14;
+ height = tl.getHeight() + 10;
+}
+
+void LookAndFeel::drawTooltip (Graphics& g, const String& text, int width, int height)
+{
+ g.fillAll (findColour (TooltipWindow::backgroundColourId));
+
+ const Colour textCol (findColour (TooltipWindow::textColourId));
+
+ g.setColour (findColour (TooltipWindow::outlineColourId));
+ g.drawRect (0, 0, width, height);
+
+ const TextLayout tl (layoutTooltipText (text));
+
+ g.setColour (findColour (TooltipWindow::textColourId));
+ tl.drawWithin (g, 0, 0, width, height, Justification::centred);
+}
+
+Button* LookAndFeel::createFilenameComponentBrowseButton (const String& text)
+{
+ return new TextButton (text, TRANS("click to browse for a different file"));
+}
+
+void LookAndFeel::layoutFilenameComponent (FilenameComponent& filenameComp,
+ ComboBox* filenameBox,
+ Button* browseButton)
+{
+ browseButton->setSize (80, filenameComp.getHeight());
+
+ TextButton* const tb = dynamic_cast (browseButton);
+
+ if (tb != 0)
+ tb->changeWidthToFitText();
+
+ browseButton->setTopRightPosition (filenameComp.getWidth(), 0);
+
+ filenameBox->setBounds (0, 0, browseButton->getX(), filenameComp.getHeight());
+}
+
+void LookAndFeel::drawCornerResizer (Graphics& g,
+ int w, int h,
+ bool /*isMouseOver*/,
+ bool /*isMouseDragging*/)
+{
+ const float lineThickness = jmin (w, h) * 0.075f;
+
+ for (float i = 0.0f; i < 1.0f; i += 0.3f)
+ {
+ g.setColour (Colours::lightgrey);
+
+ g.drawLine (w * i,
+ h + 1.0f,
+ w + 1.0f,
+ h * i,
+ lineThickness);
+
+ g.setColour (Colours::darkgrey);
+
+ g.drawLine (w * i + lineThickness,
+ h + 1.0f,
+ w + 1.0f,
+ h * i + lineThickness,
+ lineThickness);
+ }
+}
+
+void LookAndFeel::drawResizableFrame (Graphics&, int /*w*/, int /*h*/,
+ const BorderSize& /*borders*/)
+{
+}
+
+void LookAndFeel::drawResizableWindowBorder (Graphics& g, int w, int h,
+ const BorderSize& border, ResizableWindow&)
+{
+ g.setColour (Colour (0x80000000));
+ g.drawRect (0, 0, w, h);
+
+ g.setColour (Colour (0x19000000));
+ g.drawRect (border.getLeft() - 1,
+ border.getTop() - 1,
+ w + 2 - border.getLeftAndRight(),
+ h + 2 - border.getTopAndBottom());
+}
+
+void LookAndFeel::drawDocumentWindowTitleBar (DocumentWindow& window,
+ Graphics& g, int w, int h,
+ int titleSpaceX, int titleSpaceW,
+ const Image* icon,
+ bool drawTitleTextOnLeft)
+{
+ const bool isActive = window.isActiveWindow();
+
+ GradientBrush gb (window.getBackgroundColour(),
+ 0.0f, 0.0f,
+ window.getBackgroundColour().contrasting (isActive ? 0.15f : 0.05f),
+ 0.0f, (float) h, false);
+ g.setBrush (&gb);
+ g.fillAll();
+
+ g.setFont (h * 0.65f, Font::bold);
+
+ int textW = g.getCurrentFont().getStringWidth (window.getName());
+ int iconW = 0;
+ int iconH = 0;
+
+ if (icon != 0)
+ {
+ iconH = (int) g.getCurrentFont().getHeight();
+ iconW = icon->getWidth() * iconH / icon->getHeight() + 4;
+ }
+
+ textW = jmin (titleSpaceW, textW + iconW);
+ int textX = drawTitleTextOnLeft ? titleSpaceX
+ : jmax (titleSpaceX, (w - textW) / 2);
+
+ if (textX + textW > titleSpaceX + titleSpaceW)
+ textX = titleSpaceX + titleSpaceW - textW;
+
+ if (icon != 0)
+ {
+ g.setOpacity (isActive ? 1.0f : 0.6f);
+ g.drawImageWithin (icon, textX, (h - iconH) / 2, iconW, iconH,
+ RectanglePlacement::centred, false);
+ textX += iconW;
+ textW -= iconW;
+ }
+
+ g.setColour (window.getBackgroundColour().contrasting (isActive ? 0.7f : 0.4f));
+ g.drawText (window.getName(), textX, 0, textW, h, Justification::centredLeft, true);
+}
+
+class GlassWindowButton : public Button
+{
+public:
+
+ GlassWindowButton (const String& name, const Colour& col,
+ const Path& normalShape_,
+ const Path& toggledShape_) throw()
+ : Button (name),
+ colour (col),
+ normalShape (normalShape_),
+ toggledShape (toggledShape_)
+ {
+ }
+
+ ~GlassWindowButton()
+ {
+ }
+
+ void paintButton (Graphics& g, bool isMouseOverButton, bool isButtonDown)
+ {
+ float alpha = isMouseOverButton ? (isButtonDown ? 1.0f : 0.8f) : 0.55f;
+
+ if (! isEnabled())
+ alpha *= 0.5f;
+
+ float x = 0, y = 0, diam;
+
+ if (getWidth() < getHeight())
+ {
+ diam = (float) getWidth();
+ y = (getHeight() - getWidth()) * 0.5f;
+ }
+ else
+ {
+ diam = (float) getHeight();
+ y = (getWidth() - getHeight()) * 0.5f;
+ }
+
+ x += diam * 0.05f;
+ y += diam * 0.05f;
+ diam *= 0.9f;
+
+ GradientBrush gb1 (Colour::greyLevel (0.9f).withAlpha (alpha), 0, y + diam,
+ Colour::greyLevel (0.6f).withAlpha (alpha), 0, y, false);
+
+ g.setBrush (&gb1);
+ g.fillEllipse (x, y, diam, diam);
+
+ x += 2.0f;
+ y += 2.0f;
+ diam -= 4.0f;
+
+ LookAndFeel::drawGlassSphere (g, x, y, diam, colour.withAlpha (alpha), 1.0f);
+
+ Path& p = getToggleState() ? toggledShape : normalShape;
+
+ const AffineTransform t (p.getTransformToScaleToFit (x + diam * 0.3f, y + diam * 0.3f,
+ diam * 0.4f, diam * 0.4f, true));
+
+ g.setColour (Colours::black.withAlpha (alpha * 0.6f));
+ g.fillPath (p, t);
+ }
+
+ juce_UseDebuggingNewOperator
+
+private:
+ Colour colour;
+ Path normalShape, toggledShape;
+
+ GlassWindowButton (const GlassWindowButton&);
+ const GlassWindowButton& operator= (const GlassWindowButton&);
+};
+
+Button* LookAndFeel::createDocumentWindowButton (int buttonType)
+{
+ Path shape;
+ const float crossThickness = 0.25f;
+
+ if (buttonType == DocumentWindow::closeButton)
+ {
+ shape.addLineSegment (0.0f, 0.0f, 1.0f, 1.0f, crossThickness * 1.4f);
+ shape.addLineSegment (1.0f, 0.0f, 0.0f, 1.0f, crossThickness * 1.4f);
+
+ return new GlassWindowButton ("close", Colour (0xffdd1100), shape, shape);
+ }
+ else if (buttonType == DocumentWindow::minimiseButton)
+ {
+ shape.addLineSegment (0.0f, 0.5f, 1.0f, 0.5f, crossThickness);
+
+ return new GlassWindowButton ("minimise", Colour (0xffaa8811), shape, shape);
+ }
+ else if (buttonType == DocumentWindow::maximiseButton)
+ {
+ shape.addLineSegment (0.5f, 0.0f, 0.5f, 1.0f, crossThickness);
+ shape.addLineSegment (0.0f, 0.5f, 1.0f, 0.5f, crossThickness);
+
+ Path fullscreenShape;
+ fullscreenShape.startNewSubPath (45.0f, 100.0f);
+ fullscreenShape.lineTo (0.0f, 100.0f);
+ fullscreenShape.lineTo (0.0f, 0.0f);
+ fullscreenShape.lineTo (100.0f, 0.0f);
+ fullscreenShape.lineTo (100.0f, 45.0f);
+ fullscreenShape.addRectangle (45.0f, 45.0f, 100.0f, 100.0f);
+ PathStrokeType (30.0f).createStrokedPath (fullscreenShape, fullscreenShape);
+
+ return new GlassWindowButton ("maximise", Colour (0xff119911), shape, fullscreenShape);
+ }
+
+ jassertfalse
+ return 0;
+}
+
+void LookAndFeel::positionDocumentWindowButtons (DocumentWindow&,
+ int titleBarX,
+ int titleBarY,
+ int titleBarW,
+ int titleBarH,
+ Button* minimiseButton,
+ Button* maximiseButton,
+ Button* closeButton,
+ bool positionTitleBarButtonsOnLeft)
+{
+ const int buttonW = titleBarH - titleBarH / 8;
+
+ int x = positionTitleBarButtonsOnLeft ? titleBarX + 4
+ : titleBarX + titleBarW - buttonW - buttonW / 4;
+
+ if (closeButton != 0)
+ {
+ closeButton->setBounds (x, titleBarY, buttonW, titleBarH);
+ x += positionTitleBarButtonsOnLeft ? buttonW : -(buttonW + buttonW / 4);
+ }
+
+ if (positionTitleBarButtonsOnLeft)
+ swapVariables (minimiseButton, maximiseButton);
+
+ if (maximiseButton != 0)
+ {
+ maximiseButton->setBounds (x, titleBarY, buttonW, titleBarH);
+ x += positionTitleBarButtonsOnLeft ? buttonW : -buttonW;
+ }
+
+ if (minimiseButton != 0)
+ minimiseButton->setBounds (x, titleBarY, buttonW, titleBarH);
+}
+
+int LookAndFeel::getDefaultMenuBarHeight()
+{
+ return 24;
+}
+
+DropShadower* LookAndFeel::createDropShadowerForComponent (Component*)
+{
+ return new DropShadower (0.4f, 1, 5, 10);
+}
+
+void LookAndFeel::drawStretchableLayoutResizerBar (Graphics& g,
+ int w, int h,
+ bool /*isVerticalBar*/,
+ bool isMouseOver,
+ bool isMouseDragging)
+{
+ float alpha = 0.5f;
+
+ if (isMouseOver || isMouseDragging)
+ {
+ g.fillAll (Colour (0x190000ff));
+ alpha = 1.0f;
+ }
+
+ const float cx = w * 0.5f;
+ const float cy = h * 0.5f;
+ const float cr = jmin (w, h) * 0.4f;
+
+ GradientBrush gb (Colours::white.withAlpha (alpha), cx + cr * 0.1f, cy + cr,
+ Colours::black.withAlpha (alpha), cx, cy - cr * 4.0f,
+ true);
+
+ g.setBrush (&gb);
+ g.fillEllipse (cx - cr, cy - cr, cr * 2.0f, cr * 2.0f);
+}
+
+void LookAndFeel::drawGroupComponentOutline (Graphics& g, int width, int height,
+ const String& text,
+ const Justification& position,
+ GroupComponent& group)
+{
+ const float textH = 15.0f;
+ const float indent = 3.0f;
+ const float textEdgeGap = 4.0f;
+ float cs = 5.0f;
+
+ Font f (textH);
+
+ Path p;
+ float x = indent;
+ float y = f.getAscent() - 3.0f;
+ float w = jmax (0.0f, width - x * 2.0f);
+ float h = jmax (0.0f, height - y - indent);
+ cs = jmin (cs, w * 0.5f, h * 0.5f);
+ const float cs2 = 2.0f * cs;
+
+ float textW = text.isEmpty() ? 0 : jlimit (0.0f, jmax (0.0f, w - cs2 - textEdgeGap * 2), f.getStringWidth (text) + textEdgeGap * 2.0f);
+ float textX = cs + textEdgeGap;
+
+ if (position.testFlags (Justification::horizontallyCentred))
+ textX = cs + (w - cs2 - textW) * 0.5f;
+ else if (position.testFlags (Justification::right))
+ textX = w - cs - textW - textEdgeGap;
+
+ p.startNewSubPath (x + textX + textW, y);
+ p.lineTo (x + w - cs, y);
+
+ p.addArc (x + w - cs2, y, cs2, cs2, 0, float_Pi * 0.5f);
+ p.lineTo (x + w, y + h - cs);
+
+ p.addArc (x + w - cs2, y + h - cs2, cs2, cs2, float_Pi * 0.5f, float_Pi);
+ p.lineTo (x + cs, y + h);
+
+ p.addArc (x, y + h - cs2, cs2, cs2, float_Pi, float_Pi * 1.5f);
+ p.lineTo (x, y + cs);
+
+ p.addArc (x, y, cs2, cs2, float_Pi * 1.5f, float_Pi * 2.0f);
+ p.lineTo (x + textX, y);
+
+ const float alpha = group.isEnabled() ? 1.0f : 0.5f;
+
+ g.setColour (group.findColour (GroupComponent::outlineColourId)
+ .withMultipliedAlpha (alpha));
+
+ g.strokePath (p, PathStrokeType (2.0f));
+
+ g.setColour (group.findColour (GroupComponent::textColourId)
+ .withMultipliedAlpha (alpha));
+ g.setFont (f);
+ g.drawText (text,
+ roundFloatToInt (x + textX), 0,
+ roundFloatToInt (textW),
+ roundFloatToInt (textH),
+ Justification::centred, true);
+}
+
+int LookAndFeel::getTabButtonOverlap (int tabDepth)
+{
+ return 1 + tabDepth / 3;
+}
+
+int LookAndFeel::getTabButtonSpaceAroundImage()
+{
+ return 4;
+}
+
+void LookAndFeel::createTabButtonShape (Path& p,
+ int width, int height,
+ int /*tabIndex*/,
+ const String& /*text*/,
+ Button& /*button*/,
+ TabbedButtonBar::Orientation orientation,
+ const bool /*isMouseOver*/,
+ const bool /*isMouseDown*/,
+ const bool /*isFrontTab*/)
+{
+ const float w = (float) width;
+ const float h = (float) height;
+
+ float length = w;
+ float depth = h;
+
+ if (orientation == TabbedButtonBar::TabsAtLeft
+ || orientation == TabbedButtonBar::TabsAtRight)
+ {
+ swapVariables (length, depth);
+ }
+
+ const float indent = (float) getTabButtonOverlap ((int) depth);
+ const float overhang = 4.0f;
+
+ if (orientation == TabbedButtonBar::TabsAtLeft)
+ {
+ p.startNewSubPath (w, 0.0f);
+ p.lineTo (0.0f, indent);
+ p.lineTo (0.0f, h - indent);
+ p.lineTo (w, h);
+ p.lineTo (w + overhang, h + overhang);
+ p.lineTo (w + overhang, -overhang);
+ }
+ else if (orientation == TabbedButtonBar::TabsAtRight)
+ {
+ p.startNewSubPath (0.0f, 0.0f);
+ p.lineTo (w, indent);
+ p.lineTo (w, h - indent);
+ p.lineTo (0.0f, h);
+ p.lineTo (-overhang, h + overhang);
+ p.lineTo (-overhang, -overhang);
+ }
+ else if (orientation == TabbedButtonBar::TabsAtBottom)
+ {
+ p.startNewSubPath (0.0f, 0.0f);
+ p.lineTo (indent, h);
+ p.lineTo (w - indent, h);
+ p.lineTo (w, 0.0f);
+ p.lineTo (w + overhang, -overhang);
+ p.lineTo (-overhang, -overhang);
+ }
+ else
+ {
+ p.startNewSubPath (0.0f, h);
+ p.lineTo (indent, 0.0f);
+ p.lineTo (w - indent, 0.0f);
+ p.lineTo (w, h);
+ p.lineTo (w + overhang, h + overhang);
+ p.lineTo (-overhang, h + overhang);
+ }
+
+ p.closeSubPath();
+
+ p = p.createPathWithRoundedCorners (3.0f);
+}
+
+void LookAndFeel::fillTabButtonShape (Graphics& g,
+ const Path& path,
+ const Colour& preferredColour,
+ int /*tabIndex*/,
+ const String& /*text*/,
+ Button& button,
+ TabbedButtonBar::Orientation /*orientation*/,
+ const bool /*isMouseOver*/,
+ const bool /*isMouseDown*/,
+ const bool isFrontTab)
+{
+ g.setColour (isFrontTab ? preferredColour
+ : preferredColour.withMultipliedAlpha (0.9f));
+
+ g.fillPath (path);
+
+ g.setColour (Colours::black.withAlpha (button.isEnabled() ? 0.5f : 0.25f));
+ g.strokePath (path, PathStrokeType (isFrontTab ? 1.0f : 0.5f));
+}
+
+void LookAndFeel::drawTabButtonText (Graphics& g,
+ int x, int y, int w, int h,
+ const Colour& preferredBackgroundColour,
+ int /*tabIndex*/,
+ const String& text,
+ Button& button,
+ TabbedButtonBar::Orientation orientation,
+ const bool isMouseOver,
+ const bool isMouseDown,
+ const bool /*isFrontTab*/)
+{
+ int length = w;
+ int depth = h;
+
+ if (orientation == TabbedButtonBar::TabsAtLeft
+ || orientation == TabbedButtonBar::TabsAtRight)
+ {
+ swapVariables (length, depth);
+ }
+
+ Font font (depth * 0.6f);
+ font.setUnderline (button.hasKeyboardFocus (false));
+
+ GlyphArrangement textLayout;
+ textLayout.addFittedText (font, text.trim(),
+ 0.0f, 0.0f, (float) length, (float) depth,
+ Justification::centred,
+ jmax (1, depth / 12));
+
+ AffineTransform transform;
+
+ if (orientation == TabbedButtonBar::TabsAtLeft)
+ {
+ transform = transform.rotated (float_Pi * -0.5f)
+ .translated ((float) x, (float) (y + h));
+ }
+ else if (orientation == TabbedButtonBar::TabsAtRight)
+ {
+ transform = transform.rotated (float_Pi * 0.5f)
+ .translated ((float) (x + w), (float) y);
+ }
+ else
+ {
+ transform = transform.translated ((float) x, (float) y);
+ }
+
+ g.setColour (preferredBackgroundColour.contrasting());
+
+ if (! (isMouseOver || isMouseDown))
+ g.setOpacity (0.8f);
+
+ if (! button.isEnabled())
+ g.setOpacity (0.3f);
+
+ textLayout.draw (g, transform);
+}
+
+int LookAndFeel::getTabButtonBestWidth (int /*tabIndex*/,
+ const String& text,
+ int tabDepth,
+ Button&)
+{
+ Font f (tabDepth * 0.6f);
+ return f.getStringWidth (text.trim()) + getTabButtonOverlap (tabDepth) * 2;
+}
+
+void LookAndFeel::drawTabButton (Graphics& g,
+ int w, int h,
+ const Colour& preferredColour,
+ int tabIndex,
+ const String& text,
+ Button& button,
+ TabbedButtonBar::Orientation orientation,
+ const bool isMouseOver,
+ const bool isMouseDown,
+ const bool isFrontTab)
+{
+ int length = w;
+ int depth = h;
+
+ if (orientation == TabbedButtonBar::TabsAtLeft
+ || orientation == TabbedButtonBar::TabsAtRight)
+ {
+ swapVariables (length, depth);
+ }
+
+ Path tabShape;
+
+ createTabButtonShape (tabShape, w, h,
+ tabIndex, text, button, orientation,
+ isMouseOver, isMouseDown, isFrontTab);
+
+ fillTabButtonShape (g, tabShape, preferredColour,
+ tabIndex, text, button, orientation,
+ isMouseOver, isMouseDown, isFrontTab);
+
+ const int indent = getTabButtonOverlap (depth);
+ int x = 0, y = 0;
+
+ if (orientation == TabbedButtonBar::TabsAtLeft
+ || orientation == TabbedButtonBar::TabsAtRight)
+ {
+ y += indent;
+ h -= indent * 2;
+ }
+ else
+ {
+ x += indent;
+ w -= indent * 2;
+ }
+
+ drawTabButtonText (g, x, y, w, h, preferredColour,
+ tabIndex, text, button, orientation,
+ isMouseOver, isMouseDown, isFrontTab);
+}
+
+void LookAndFeel::drawTabAreaBehindFrontButton (Graphics& g,
+ int w, int h,
+ TabbedButtonBar& tabBar,
+ TabbedButtonBar::Orientation orientation)
+{
+ const float shadowSize = 0.2f;
+
+ float x1 = 0.0f, y1 = 0.0f, x2 = 0.0f, y2 = 0.0f;
+ Rectangle shadowRect;
+
+ if (orientation == TabbedButtonBar::TabsAtLeft)
+ {
+ x1 = (float) w;
+ x2 = w * (1.0f - shadowSize);
+ shadowRect.setBounds ((int) x2, 0, w - (int) x2, h);
+ }
+ else if (orientation == TabbedButtonBar::TabsAtRight)
+ {
+ x2 = w * shadowSize;
+ shadowRect.setBounds (0, 0, (int) x2, h);
+ }
+ else if (orientation == TabbedButtonBar::TabsAtBottom)
+ {
+ y2 = h * shadowSize;
+ shadowRect.setBounds (0, 0, w, (int) y2);
+ }
+ else
+ {
+ y1 = (float) h;
+ y2 = h * (1.0f - shadowSize);
+ shadowRect.setBounds (0, (int) y2, w, h - (int) y2);
+ }
+
+ GradientBrush gb (Colours::black.withAlpha (tabBar.isEnabled() ? 0.3f : 0.15f), x1, y1,
+ Colours::transparentBlack, x2, y2,
+ false);
+
+ g.setBrush (&gb);
+ shadowRect.expand (2, 2);
+ g.fillRect (shadowRect);
+
+ g.setColour (Colour (0x80000000));
+
+ if (orientation == TabbedButtonBar::TabsAtLeft)
+ {
+ g.fillRect (w - 1, 0, 1, h);
+ }
+ else if (orientation == TabbedButtonBar::TabsAtRight)
+ {
+ g.fillRect (0, 0, 1, h);
+ }
+ else if (orientation == TabbedButtonBar::TabsAtBottom)
+ {
+ g.fillRect (0, 0, w, 1);
+ }
+ else
+ {
+ g.fillRect (0, h - 1, w, 1);
+ }
+}
+
+Button* LookAndFeel::createTabBarExtrasButton()
+{
+ const float thickness = 7.0f;
+ const float indent = 22.0f;
+
+ Path p;
+ p.addEllipse (-10.0f, -10.0f, 120.0f, 120.0f);
+
+ DrawablePath ellipse;
+ ellipse.setPath (p);
+ ellipse.setSolidFill (Colour (0x99ffffff));
+
+ p.clear();
+ p.addEllipse (0.0f, 0.0f, 100.0f, 100.0f);
+ p.addRectangle (indent, 50.0f - thickness, 100.0f - indent * 2.0f, thickness * 2.0f);
+ p.addRectangle (50.0f - thickness, indent, thickness * 2.0f, 50.0f - indent - thickness);
+ p.addRectangle (50.0f - thickness, 50.0f + thickness, thickness * 2.0f, 50.0f - indent - thickness);
+ p.setUsingNonZeroWinding (false);
+
+ DrawablePath dp;
+ dp.setPath (p);
+ dp.setSolidFill (Colour (0x59000000));
+
+ DrawableComposite normalImage;
+ normalImage.insertDrawable (ellipse);
+ normalImage.insertDrawable (dp);
+
+ dp.setSolidFill (Colour (0xcc000000));
+
+ DrawableComposite overImage;
+ overImage.insertDrawable (ellipse);
+ overImage.insertDrawable (dp);
+
+ DrawableButton* db = new DrawableButton (T("tabs"), DrawableButton::ImageFitted);
+ db->setImages (&normalImage, &overImage, 0);
+ return db;
+}
+
+void LookAndFeel::drawTableHeaderBackground (Graphics& g, TableHeaderComponent& header)
+{
+ g.fillAll (Colours::white);
+
+ const int w = header.getWidth();
+ const int h = header.getHeight();
+
+ GradientBrush gb (Colour (0xffe8ebf9), 0.0f, h * 0.5f,
+ Colour (0xfff6f8f9), 0.0f, h - 1.0f,
+ false);
+
+ g.setBrush (&gb);
+ g.fillRect (0, h / 2, w, h);
+
+ g.setColour (Colour (0x33000000));
+ g.fillRect (0, h - 1, w, 1);
+
+ for (int i = header.getNumColumns (true); --i >= 0;)
+ g.fillRect (header.getColumnPosition (i).getRight() - 1, 0, 1, h - 1);
+}
+
+void LookAndFeel::drawTableHeaderColumn (Graphics& g, const String& columnName, int /*columnId*/,
+ int width, int height,
+ bool isMouseOver, bool isMouseDown,
+ int columnFlags)
+{
+ if (isMouseDown)
+ g.fillAll (Colour (0x8899aadd));
+ else if (isMouseOver)
+ g.fillAll (Colour (0x5599aadd));
+
+ int rightOfText = width - 4;
+
+ if ((columnFlags & (TableHeaderComponent::sortedForwards | TableHeaderComponent::sortedBackwards)) != 0)
+ {
+ const float top = height * ((columnFlags & TableHeaderComponent::sortedForwards) != 0 ? 0.35f : (1.0f - 0.35f));
+ const float bottom = height - top;
+
+ const float w = height * 0.5f;
+ const float x = rightOfText - (w * 1.25f);
+ rightOfText = (int) x;
+
+ Path sortArrow;
+ sortArrow.addTriangle (x, bottom, x + w * 0.5f, top, x + w, bottom);
+
+ g.setColour (Colour (0x99000000));
+ g.fillPath (sortArrow);
+ }
+
+ g.setColour (Colours::black);
+ g.setFont (height * 0.5f, Font::bold);
+ const int textX = 4;
+ g.drawFittedText (columnName, textX, 0, rightOfText - textX, height, Justification::centredLeft, 1);
+}
+
+void LookAndFeel::paintToolbarBackground (Graphics& g, int w, int h, Toolbar& toolbar)
+{
+ const Colour background (toolbar.findColour (Toolbar::backgroundColourId));
+
+ GradientBrush gb (background, 0.0f, 0.0f,
+ background.darker (0.1f),
+ toolbar.isVertical() ? w - 1.0f : 0.0f,
+ toolbar.isVertical() ? 0.0f : h - 1.0f,
+ false);
+
+ g.setBrush (&gb);
+ g.fillAll();
+}
+
+Button* LookAndFeel::createToolbarMissingItemsButton (Toolbar& /*toolbar*/)
+{
+ return createTabBarExtrasButton();
+}
+
+void LookAndFeel::paintToolbarButtonBackground (Graphics& g, int /*width*/, int /*height*/,
+ bool isMouseOver, bool isMouseDown,
+ ToolbarItemComponent& component)
+{
+ if (isMouseDown)
+ g.fillAll (component.findColour (Toolbar::buttonMouseDownBackgroundColourId, true));
+ else if (isMouseOver)
+ g.fillAll (component.findColour (Toolbar::buttonMouseOverBackgroundColourId, true));
+}
+
+void LookAndFeel::paintToolbarButtonLabel (Graphics& g, int x, int y, int width, int height,
+ const String& text, ToolbarItemComponent& component)
+{
+ g.setColour (component.findColour (Toolbar::labelTextColourId, true)
+ .withAlpha (component.isEnabled() ? 1.0f : 0.25f));
+
+ const float fontHeight = jmin (14.0f, height * 0.85f);
+ g.setFont (fontHeight);
+
+ g.drawFittedText (text,
+ x, y, width, height,
+ Justification::centred,
+ jmax (1, height / (int) fontHeight));
+}
+
+void LookAndFeel::drawPropertyPanelSectionHeader (Graphics& g, const String& name,
+ bool isOpen, int width, int height)
+{
+ const int buttonSize = (height * 3) / 4;
+ const int buttonIndent = (height - buttonSize) / 2;
+
+ drawTreeviewPlusMinusBox (g, buttonIndent, buttonIndent, buttonSize, buttonSize, ! isOpen);
+
+ const int textX = buttonIndent * 2 + buttonSize + 2;
+
+ g.setColour (Colours::black);
+ g.setFont (height * 0.7f, Font::bold);
+ g.drawText (name, textX, 0, width - textX - 4, height, Justification::centredLeft, true);
+}
+
+void LookAndFeel::drawPropertyComponentBackground (Graphics& g, int width, int height,
+ PropertyComponent&)
+{
+ g.setColour (Colour (0x66ffffff));
+ g.fillRect (0, 0, width, height - 1);
+}
+
+void LookAndFeel::drawPropertyComponentLabel (Graphics& g, int, int height,
+ PropertyComponent& component)
+{
+ g.setColour (Colours::black);
+
+ if (! component.isEnabled())
+ g.setOpacity (g.getCurrentColour().getAlpha() * 0.6f);
+
+ g.setFont (jmin (height, 24) * 0.65f);
+
+ const Rectangle r (getPropertyComponentContentPosition (component));
+
+ g.drawFittedText (component.getName(),
+ 3, r.getY(), r.getX() - 5, r.getHeight(),
+ Justification::centredLeft, 2);
+}
+
+const Rectangle LookAndFeel::getPropertyComponentContentPosition (PropertyComponent& component)
+{
+ return Rectangle (component.getWidth() / 3, 1,
+ component.getWidth() - component.getWidth() / 3 - 1, component.getHeight() - 3);
+}
+
+void LookAndFeel::createFileChooserHeaderText (const String& title,
+ const String& instructions,
+ GlyphArrangement& text,
+ int width)
+{
+ text.clear();
+
+ text.addJustifiedText (Font (17.0f, Font::bold), title,
+ 8.0f, 22.0f, width - 16.0f,
+ Justification::centred);
+
+ text.addJustifiedText (Font (14.0f), instructions,
+ 8.0f, 24.0f + 16.0f, width - 16.0f,
+ Justification::centred);
+}
+
+void LookAndFeel::drawFileBrowserRow (Graphics& g, int width, int height,
+ const String& filename, Image* icon,
+ const String& fileSizeDescription,
+ const String& fileTimeDescription,
+ const bool isDirectory,
+ const bool isItemSelected)
+{
+ if (isItemSelected)
+ g.fillAll (findColour (DirectoryContentsDisplayComponent::highlightColourId));
+
+ g.setColour (findColour (DirectoryContentsDisplayComponent::textColourId));
+ g.setFont (height * 0.7f);
+
+ Image* im = icon;
+ Image* toRelease = 0;
+
+ if (im == 0)
+ {
+ toRelease = im = (isDirectory ? getDefaultFolderImage()
+ : getDefaultDocumentFileImage());
+ }
+
+ const int x = 32;
+
+ if (im != 0)
+ {
+ g.drawImageWithin (im, 2, 2, x - 4, height - 4,
+ RectanglePlacement::centred | RectanglePlacement::onlyReduceInSize,
+ false);
+
+ ImageCache::release (toRelease);
+ }
+
+ if (width > 450 && ! isDirectory)
+ {
+ const int sizeX = roundFloatToInt (width * 0.7f);
+ const int dateX = roundFloatToInt (width * 0.8f);
+
+ g.drawFittedText (filename,
+ x, 0, sizeX - x, height,
+ Justification::centredLeft, 1);
+
+ g.setFont (height * 0.5f);
+ g.setColour (Colours::darkgrey);
+
+ if (! isDirectory)
+ {
+ g.drawFittedText (fileSizeDescription,
+ sizeX, 0, dateX - sizeX - 8, height,
+ Justification::centredRight, 1);
+
+ g.drawFittedText (fileTimeDescription,
+ dateX, 0, width - 8 - dateX, height,
+ Justification::centredRight, 1);
+ }
+ }
+ else
+ {
+ g.drawFittedText (filename,
+ x, 0, width - x, height,
+ Justification::centredLeft, 1);
+
+ }
+}
+
+Button* LookAndFeel::createFileBrowserGoUpButton()
+{
+ DrawableButton* goUpButton = new DrawableButton ("up", DrawableButton::ImageOnButtonBackground);
+
+ Path arrowPath;
+ arrowPath.addArrow (50.0f, 100.0f, 50.0f, 0.0, 40.0f, 100.0f, 50.0f);
+
+ DrawablePath arrowImage;
+ arrowImage.setSolidFill (Colours::black.withAlpha (0.4f));
+ arrowImage.setPath (arrowPath);
+
+ goUpButton->setImages (&arrowImage);
+
+ return goUpButton;
+}
+
+void LookAndFeel::layoutFileBrowserComponent (FileBrowserComponent& browserComp,
+ DirectoryContentsDisplayComponent* fileListComponent,
+ FilePreviewComponent* previewComp,
+ ComboBox* currentPathBox,
+ TextEditor* filenameBox,
+ Button* goUpButton)
+{
+ const int x = 8;
+ int w = browserComp.getWidth() - x - x;
+
+ if (previewComp != 0)
+ {
+ const int previewWidth = w / 3;
+ previewComp->setBounds (x + w - previewWidth, 0, previewWidth, browserComp.getHeight());
+
+ w -= previewWidth + 4;
+ }
+
+ int y = 4;
+
+ const int controlsHeight = 22;
+ const int bottomSectionHeight = controlsHeight + 8;
+ const int upButtonWidth = 50;
+
+ currentPathBox->setBounds (x, y, w - upButtonWidth - 6, controlsHeight);
+ goUpButton->setBounds (x + w - upButtonWidth, y, upButtonWidth, controlsHeight);
+
+ y += controlsHeight + 4;
+
+ Component* const listAsComp = dynamic_cast (fileListComponent);
+ listAsComp->setBounds (x, y, w, browserComp.getHeight() - y - bottomSectionHeight);
+
+ y = listAsComp->getBottom() + 4;
+ filenameBox->setBounds (x + 50, y, w - 50, controlsHeight);
+}
+
+Image* LookAndFeel::getDefaultFolderImage()
+{
+ static const unsigned char foldericon_png[] = { 137,80,78,71,13,10,26,10,0,0,0,13,73,72,68,82,0,0,0,32,0,0,0,28,8,6,0,0,0,0,194,189,34,0,0,0,4,103,65,77,65,0,0,175,200,55,5,
+ 138,233,0,0,0,25,116,69,88,116,83,111,102,116,119,97,114,101,0,65,100,111,98,101,32,73,109,97,103,101,82,101,97,100,121,113,201,101,60,0,0,9,46,73,68,65,84,120,218,98,252,255,255,63,3,50,240,41,95,192,
+ 197,205,198,32,202,204,202,33,241,254,235,47,133,47,191,24,180,213,164,133,152,69,24,222,44,234,42,77,188,245,31,170,129,145,145,145,1,29,128,164,226,91,86,113,252,248,207,200,171,37,39,204,239,170,43,
+ 254,206,218,88,231,61,62,61,0,1,196,2,149,96,116,200,158,102,194,202,201,227,197,193,206,166,194,204,193,33,195,202,204,38,42,197,197,42,196,193,202,33,240,241,231,15,134,151,95,127,9,2,149,22,0,241,47,
+ 152,230,128,134,245,204,63,191,188,103,83,144,16,16,228,229,102,151,76,239,217,32,199,204,198,169,205,254,159,65,245,203,79,6,169,131,151,30,47,1,42,91,10,196,127,208,236,101,76,235,90,43,101,160,40,242,
+ 19,32,128,64,78,98,52,12,41,149,145,215,52,89,162,38,35,107,39,196,203,203,192,206,194,206,192,197,198,202,192,203,197,198,192,205,193,206,240,252,227,103,134,139,55,175,191,127,243,242,78,219,187,207,
+ 63,215,255,98,23,48,228,227,96,83,98,102,102,85,225,224,228,80,20,224,230,86,226,225,228,150,103,101,97,101,230,227,228,96,224,0,234,191,243,252,5,195,222,19,199,38,191,127,112,161,83,66,199,86,141,131,
+ 149,69,146,133,153,69,137,149,133,89,157,141,131,77,83,140,143,243,219,255,31,159,123,0,2,136,69,90,207,129,157,71,68,42,66,71,73,209,210,81,91,27,24,142,140,12,127,255,253,103,0,185,236,31,3,144,6,50,
+ 148,68,216,25,216,24,117,4,239,11,243,214,49,50,51,84,178,48,114,240,112,177,114,177,240,115,113,49,241,112,112,48,176,179,178,51,176,48,49,3,85,255,99,248,253,247,15,195,247,159,191,25,30,191,126,253,
+ 71,74,76,200,66,75,197,119,138,168,144,160,150,168,0,183,160,152,32,15,175,188,184,32,199,175,191,127,25,214,31,184,120,247,236,209,253,159,0,2,136,133,95,70,93,74,88,80,196,83,69,66,130,149,9,104,219,
+ 151,31,191,193,150,194,146,6,136,102,102,98,100,16,227,231,103,16,23,210,230,101,101,102,100,248,255,143,137,225,223,63,6,6,22,102,38,134,239,191,126,49,220,123,241,134,225,227,247,175,64,7,252,101,96,
+ 97,249,207,192,193,198,200,160,171,34,192,108,165,235,104,42,204,207,101,42,194,199,197,192,199,201,198,192,197,193,202,192,198,202,194,176,247,194,3,134,155,183,110,61,188,127,124,221,19,128,0,92,146,
+ 49,14,64,64,16,69,63,153,85,16,52,18,74,71,112,6,87,119,0,165,160,86,138,32,172,216,29,49,182,84,253,169,94,94,230,127,17,87,133,34,146,174,3,88,126,240,219,164,147,113,31,145,244,152,112,179,211,130,
+ 34,31,203,113,162,233,6,36,49,163,174,74,124,140,60,141,144,165,161,220,228,25,3,24,105,255,17,168,101,1,139,245,188,93,104,251,73,239,235,50,90,189,111,175,0,98,249,254,254,249,175,239,223,190,126,6,
+ 5,27,19,47,90,170,102,0,249,158,129,129,141,133,25,228,20,6,38,38,72,74,7,185,243,243,247,239,12,23,31,60,98,228,231,253,207,144,227,107,206,32,202,199,193,240,249,251,127,134,95,191,255,49,124,249,250,
+ 159,225,237,239,95,12,63,127,1,35,229,31,194,71,32,71,63,123,251,245,223,197,27,183,159,189,187,178,103,61,80,232,59,64,0,177,48,252,5,134,225,255,191,223,126,254,250,13,182,132,1,41,167,176,3,53,128,
+ 188,254,226,253,103,96,212,252,96,120,247,249,203,255,79,223,191,254,255,250,235,199,191,239,63,191,255,87,145,17,100,73,116,181,100,252,249,243,63,195,149,123,223,193,14,132,101,55,96,52,3,125,255,15,
+ 204,254,15,132,160,232,253,13,20,124,248,226,227,223,23,207,30,221,120,119,255,226,109,160,210,31,0,1,196,242,231,219,135,175,140,255,126,190,7,197,37,35,19,34,216,65,248,211,143,111,255,79,223,121,240,
+ 255,211,183,79,76,220,156,172,12,236,204,140,140,252,124,28,140,250,226,82,140,106,82,34,140,124,156,156,12,175,222,253,1,90,4,137,162,63,127,33,161,6,178,242,215,239,255,224,160,255,15,198,12,64,7,48,
+ 128,211,200,253,151,111,254,254,248,240,236,44,80,217,71,80,246,4,8,32,160,31,255,255,100,102,248,243,238,199,159,63,16,221,16,19,128,248,31,195,181,199,207,254,255,253,247,133,49,212,78,27,104,8,11,40,
+ 94,25,184,216,89,129,108,38,70,144,242,183,31,17,105,230,63,148,248,15,97,49,252,248,249,15,20,85,72,105,9,148,187,254,49,220,127,254,242,207,243,75,135,14,128,130,31,84,64,1,4,16,203,247,143,175,127,
+ 48,253,254,246,234,7,48,206,96,137,13,4,64,65,248,234,195,7,6,7,3,57,70,33,46,97,134,111,63,254,50,252,5,250,244,51,216,103,255,192,185,0,150,91,80,44,135,242,127,253,129,164,23,24,96,102,250,207,112,
+ 255,213,219,255,247,31,63,188,251,246,201,173,199,176,2,13,32,128,88,62,188,121,241,243,211,231,207,31,126,2,147,236,63,168,6,144,193,223,190,255,254,207,198,198,192,40,35,44,206,240,252,205,79,6,132,
+ 223,24,224,150,32,251,28,25,128,211,29,19,170,24,51,48,88,111,61,127,206,248,254,245,179,139,192,18,247,219,239,239,95,192,249,9,32,128,88,126,124,249,248,231,203,183,111,159,128,33,240,15,24,68,160,180,
+ 2,204,223,140,12,111,63,127,102,16,228,229,4,6,53,35,195,31,176,119,25,112,3,70,84,55,0,203,50,112,33,134,108,249,103,160,7,159,189,126,253,235,235,227,203,7,255,255,251,247,13,86,63,0,4,16,168,46,248,
+ 199,250,231,243,235,159,191,126,254,248,245,251,47,23,11,51,51,48,184,152,24,94,127,250,248,95,68,136,151,241,243,55,96,208,51,160,218,255,31,139,27,144,197,254,98,201,202,79,223,124,96,120,245,232,250,
+ 185,119,143,174,95,250,243,243,219,119,152,60,64,0,129,2,234,223,183,215,15,95,48,254,255,253,3,146,109,192,229,5,195,135,47,159,25,248,184,121,24,126,0,227,29,88,240,49,252,101,36,14,255,1,90,249,7,156,
+ 222,17,24,24,164,12,207,223,189,99,248,250,252,230,97,96,229,245,2,104,231,111,152,3,0,2,8,228,128,191,15,239,220,120,255,255,223,159,47,160,116,0,42,44,222,124,250,244,239,207,255,63,12,236,108,236,64,
+ 67,65,81,0,52,244,63,113,248,47,52,10,96,14,98,2,230,191,119,223,127,48,60,121,254,248,235,151,55,207,46,1,163,252,35,114,128,1,4,16,40,10,254,191,121,249,252,199,175,159,63,191,254,2,230,45,118,22,22,
+ 134,219,207,94,252,231,224,100,103,250,247,15,148,32,64,85,12,34,14,254,227,72,6,255,225,9,240,63,138,26,46,96,214,189,249,244,37,195,139,167,143,30,124,253,246,253,9,40,245,255,71,202,30,0,1,196,2,226,
+ 0,243,232,159,239,63,127,124,253,11,202,94,64,169,23,31,62,50,138,137,242,49,50,0,211,195,223,255,80,7,252,199,159,6,224,137,145,9,146,231,153,160,165,218,23,96,29,240,244,237,59,134,111,175,31,95,250,
+ 252,230,241,83,244,182,1,64,0,177,192,28,14,76,132,31,128,169,19,88,220,126,253,207,206,198,196,32,38,36,0,244,61,11,176,148,251,139,145,3,208,29,0,178,16,82,228,66,42,174,223,192,26,8,152,162,25,222,
+ 125,248,200,240,242,253,39,134,151,79,238,126,254,242,242,238,177,15,47,30,190,5,215,242,72,0,32,128,224,14,96,254,255,231,61,168,92,123,241,254,253,127,1,62,78,6,78,110,78,134,223,64,195,254,50,98,183,
+ 24,36,12,202,179,224,202,9,88,228,253,132,90,250,246,211,71,134,55,175,94,254,122,255,250,249,247,15,175,159,126,249,251,237,195,135,95,175,110,31,122,117,251,244,49,160,150,111,255,209,218,128,0,1,152,
+ 44,183,21,0,65,32,136,110,247,254,255,243,122,9,187,64,105,174,74,22,138,25,173,80,208,194,188,238,156,151,217,217,15,32,182,197,37,83,201,4,31,243,178,169,232,242,214,224,223,252,103,175,35,85,1,41,129,
+ 228,148,142,8,214,30,32,149,6,161,204,109,182,53,236,184,156,78,142,147,195,153,89,35,198,3,87,166,249,220,227,198,59,218,48,252,223,185,111,30,1,132,228,128,127,31,222,124,248,248,27,24,152,28,60,220,
+ 220,12,44,172,172,224,224,103,5,102,98,144,133,160,236,244,229,231,47,134,239,223,127,49,188,121,251,158,225,241,179,103,12,31,223,189,254,251,227,221,139,55,191,62,188,120,246,235,205,189,59,207,238,
+ 94,58,241,228,254,109,144,101,159,128,248,51,40,9,32,97,80,217,255,15,221,1,0,1,4,143,130,207,159,191,126,252,246,234,213,111,94,126,94,118,73,94,9,198,127,64,223,126,252,246,147,225,243,215,239,12,223,
+ 128,229,198,251,15,239,24,62,189,126,249,227,203,171,135,47,63,189,122,252,228,235,155,199,247,95,63,188,118,227,197,227,123,247,127,255,250,249,30,104,198,7,32,126,11,181,252,7,212,183,160,4,247,7,155,
+ 197,48,0,16,64,112,7,60,121,241,238,189,16,207,15,134,63,63,216,25,95,125,248,198,112,227,241,27,134,15,239,223,50,124,126,245,228,253,143,55,143,158,191,123,116,237,226,171,135,55,175,126,253,252,225,
+ 229,183,47,159,95,254,253,245,227,253,175,159,223,223,193,124,7,181,20,84,105,252,70,143,103,124,0,32,128,224,14,224,102,253,251,81,144,253,223,235,167,207,30,254,124,127,231,252,155,143,175,159,188,250,
+ 246,254,249,125,96,60,62,248,250,233,253,147,119,207,238,221,6,150,214,175,129,106,191,130,18,19,146,133,120,125,72,8,0,4,16,34,27,190,121,112,251,3,211,159,69,143,110,223,229,120,255,232,230,221,215,
+ 79,239,62,4,102,203,207,72,241,9,11,218,63,72,89,137,20,207,98,100,93,16,0,8,32,70,144,1,64,14,168,209,199,7,196,194,160,166,27,212,135,95,96,65,10,173,95,254,34,219,6,51,128,88,7,96,235,21,129,0,64,0,
+ 193,28,192,8,174,53,33,152,1,155,133,184,12,196,165,4,151,133,232,0,32,192,0,151,97,210,163,246,134,208,52,0,0,0,0,73,69,78,68,174,66,96,130,0,0};
+
+ return ImageCache::getFromMemory (foldericon_png, sizeof (foldericon_png));
+}
+
+Image* LookAndFeel::getDefaultDocumentFileImage()
+{
+ static const unsigned char fileicon_png[] = { 137,80,78,71,13,10,26,10,0,0,0,13,73,72,68,82,0,0,0,32,0,0,0,32,8,6,0,0,0,115,122,122,244,0,0,0,4,103,65,77,65,0,0,175,200,55,5,
+ 138,233,0,0,0,25,116,69,88,116,83,111,102,116,119,97,114,101,0,65,100,111,98,101,32,73,109,97,103,101,82,101,97,100,121,113,201,101,60,0,0,4,99,73,68,65,84,120,218,98,252,255,255,63,3,12,48,50,50,50,1,
+ 169,127,200,98,148,2,160,153,204,64,243,254,226,146,7,8,32,22,52,203,255,107,233,233,91,76,93,176,184,232,239,239,95,127,24,40,112,8,19,51,203,255,179,23,175,108,1,90,190,28,104,54,43,80,232,207,127,44,
+ 62,3,8,32,6,144,24,84,156,25,132,189,252,3,146,255,83,9,220,127,254,242,134,162,138,170,10,208,92,144,3,152,97,118,33,99,128,0,98,66,114,11,200,1,92,255,254,252,225,32,215,215,32,127,64,240,127,80,60,
+ 50,40,72,136,169,47,95,179,118,130,136,148,140,0,40,80,128,33,193,136,174,7,32,128,144,29,192,8,117,41,59,209,22,66,241,191,255,16,12,244,19,195,63,48,134,240,255,0,9,115,125,93,239,252,130,130,108,168,
+ 249,44,232,102,0,4,16,19,22,62,51,33,11,255,195,44,4,211,255,25,96,16,33,6,117,24,56,226,25,24,202,139,10,75,226,51,115,66,160,105,13,197,17,0,1,196,68,172,79,255,33,91,206,192,192,128,176,22,17,10,200,
+ 234,32,161,240,31,24,10,255,24,152,153,153,184,39,244,247,117,107,234,234,105,131,66,1,154,224,193,0,32,128,240,58,0,22,180,255,144,18,13,40,136,33,113,140,36,255,15,17,26,48,12,81,15,145,255,254,251,
+ 31,131,0,59,171,84,81,73,105,33,208,216,191,200,161,12,16,64,44,248,131,251,63,10,31,198,253,143,38,6,83,7,11,33,228,232,2,123,4,202,226,228,96,151,132,166,49,144,35,126,131,196,0,2,136,5,103,60,51,252,
+ 71,49,12,213,130,255,168,226,232,150,254,255,15,143,6,80,202,3,133,16,200,198,63,127,193,229,17,39,16,127,135,217,7,16,64,88,67,0,28,143,255,25,225,46,135,249,18,155,133,240,178,4,205,145,8,62,52,186,
+ 32,234,152,160,118,194,179,35,64,0,177,96,11,123,144,236,95,104,92,162,228,113,36,11,81,125,140,112,56,186,131,96,226,176,172,137,148,229,193,0,32,128,88,112,167,248,255,112,223,48,34,165,110,6,124,190,
+ 253,143,61,106,192,9,19,73,28,25,0,4,16,206,40,248,251,15,45,104,209,130,21,51,222,145,18,238,127,180,68,8,244,250,95,164,16,66,6,0,1,196,130,45,253,195,12,250,135,53,206,255,195,131,18,213,98,236,81,
+ 243,31,154,11,144,115,8,50,0,8,32,156,81,0,203,227,12,80,223,98,230,4,68,72,96,38,78,84,11,65,9,250,47,146,3,145,1,64,0,97,117,192,95,112,34,68,138,130,255,176,224,251,143,226,51,6,6,68,29,192,136,20,
+ 77,200,69,54,35,3,36,49,255,69,77,132,112,0,16,64,44,56,139,94,36,7,96,102,59,164,108,249,31,181,82,98,64,203,174,255,144,234,142,127,88,146,33,64,0,97,205,134,240,120,67,75,76,136,224,198,140,22,6,44,
+ 142,66,201,41,255,177,231,2,128,0,194,25,5,255,254,161,134,192,127,6,28,229,0,129,242,1,150,56,33,81,138,209,28,96,0,8,32,172,81,0,78,3,104,190,68,182,224,31,146,197,224,56,6,146,140,176,202,135,17,169,
+ 96,130,40,64,56,0,139,93,0,1,132,61,10,64,248,31,106,156,162,199,55,204,65,255,144,178,38,74,84,252,71,51,239,63,246,68,8,16,64,44,216,74,1,88,217,13,203,191,32,1,80,58,7,133,224,127,6,68,114,6,241,65,
+ 81,197,8,101,255,71,114,33,92,237,127,228,52,128,233,2,128,0,98,193,149,3,64,117,193,255,127,255,81,75,191,127,168,5,18,136,255,31,45,161,49,32,151,134,72,252,127,12,216,203,98,128,0,98,193,210,144,135,
+ 248,30,201,242,127,208,252,140,145,27,160,113,206,136,148,197,192,121,159,17,53,184,225,149,17,22,23,0,4,16,11,182,150,237,63,168,207,96,142,248,143,163,72,6,203,253,67,13,61,6,104,14,66,46,17,254,65,
+ 19,40,182,16,0,8,32,22,108,109,235,255,176,234,24,35,79,255,199,222,30,64,81,135,90,35,194,211,4,142,92,0,16,64,88,29,0,107,7,254,251,247,31,53,78,241,54,207,80,29,135,209,96,249,143,189,46,0,8,32,116,
+ 7,252,101,102,103,103,228,103,99,96,248,193,198,137,53,248,49,125,204,128,225,227,255,88,18,54,47,176,25,202,205,195,205,6,109,11,194,149,0,4,16,35,204,85,208,254,27,159,128,176,176,142,166,182,142,21,
+ 48,4,248,129,41,143,13,217,16,70,52,95,147,0,254,0,187,69,95,223,188,122,125,235,206,141,107,7,129,252,247,64,123,193,237,66,128,0,66,118,0,168,189,198,3,196,252,32,135,64,105,54,228,230,19,185,29,100,
+ 168,175,191,0,241,7,32,254,4,196,159,129,246,254,2,73,2,4,16,11,90,72,125,135,210,63,161,138,153,169,212,75,255,15,117,196,15,40,134,119,215,1,2,12,0,187,0,132,247,216,161,197,124,0,0,0,0,73,69,78,68,
+ 174,66,96,130,0,0};
+
+ return ImageCache::getFromMemory (fileicon_png, sizeof (fileicon_png));
+}
+
+void LookAndFeel::playAlertSound()
+{
+ PlatformUtilities::beep();
+}
+
+static void createRoundedPath (Path& p,
+ const float x, const float y,
+ const float w, const float h,
+ const float cs,
+ const bool curveTopLeft, const bool curveTopRight,
+ const bool curveBottomLeft, const bool curveBottomRight) throw()
+{
+ const float cs2 = 2.0f * cs;
+
+ if (curveTopLeft)
+ {
+ p.startNewSubPath (x, y + cs);
+ p.addArc (x, y, cs2, cs2, float_Pi * 1.5f, float_Pi * 2.0f);
+ }
+ else
+ {
+ p.startNewSubPath (x, y);
+ }
+
+ if (curveTopRight)
+ {
+ p.lineTo (x + w - cs, y);
+ p.addArc (x + w - cs2, y, cs2, cs2, 0.0f, float_Pi * 0.5f);
+ }
+ else
+ {
+ p.lineTo (x + w, y);
+ }
+
+ if (curveBottomRight)
+ {
+ p.lineTo (x + w, y + h - cs);
+ p.addArc (x + w - cs2, y + h - cs2, cs2, cs2, float_Pi * 0.5f, float_Pi);
+ }
+ else
+ {
+ p.lineTo (x + w, y + h);
+ }
+
+ if (curveBottomLeft)
+ {
+ p.lineTo (x + cs, y + h);
+ p.addArc (x, y + h - cs2, cs2, cs2, float_Pi, float_Pi * 1.5f);
+ }
+ else
+ {
+ p.lineTo (x, y + h);
+ }
+
+ p.closeSubPath();
+}
+
+void LookAndFeel::drawShinyButtonShape (Graphics& g,
+ float x, float y, float w, float h,
+ float maxCornerSize,
+ const Colour& baseColour,
+ const float strokeWidth,
+ const bool flatOnLeft,
+ const bool flatOnRight,
+ const bool flatOnTop,
+ const bool flatOnBottom) throw()
+{
+ if (w <= strokeWidth * 1.1f || h <= strokeWidth * 1.1f)
+ return;
+
+ const float cs = jmin (maxCornerSize, w * 0.5f, h * 0.5f);
+
+ Path outline;
+ createRoundedPath (outline, x, y, w, h, cs,
+ ! (flatOnLeft || flatOnTop),
+ ! (flatOnRight || flatOnTop),
+ ! (flatOnLeft || flatOnBottom),
+ ! (flatOnRight || flatOnBottom));
+
+ ColourGradient cg (baseColour, 0.0f, y,
+ baseColour.overlaidWith (Colour (0x070000ff)), 0.0f, y + h,
+ false);
+
+ cg.addColour (0.5, baseColour.overlaidWith (Colour (0x33ffffff)));
+ cg.addColour (0.51, baseColour.overlaidWith (Colour (0x110000ff)));
+
+ GradientBrush gb (cg);
+ g.setBrush (&gb);
+ g.fillPath (outline);
+
+ g.setColour (Colour (0x80000000));
+ g.strokePath (outline, PathStrokeType (strokeWidth));
+}
+
+void LookAndFeel::drawGlassSphere (Graphics& g,
+ const float x, const float y,
+ const float diameter,
+ const Colour& colour,
+ const float outlineThickness) throw()
+{
+ if (diameter <= outlineThickness)
+ return;
+
+ Path p;
+ p.addEllipse (x, y, diameter, diameter);
+
+ {
+ ColourGradient cg (Colours::white.overlaidWith (colour.withMultipliedAlpha (0.3f)), 0, y,
+ Colours::white.overlaidWith (colour.withMultipliedAlpha (0.3f)), 0, y + diameter, false);
+
+ cg.addColour (0.4, Colours::white.overlaidWith (colour));
+
+ GradientBrush gb (cg);
+ g.setBrush (&gb);
+ g.fillPath (p);
+ }
+
+ {
+ GradientBrush gb (Colours::white, 0, y + diameter * 0.06f,
+ Colours::transparentWhite, 0, y + diameter * 0.3f, false);
+
+ g.setBrush (&gb);
+ g.fillEllipse (x + diameter * 0.2f, y + diameter * 0.05f, diameter * 0.6f, diameter * 0.4f);
+ }
+
+ {
+ ColourGradient cg (Colours::transparentBlack,
+ x + diameter * 0.5f, y + diameter * 0.5f,
+ Colours::black.withAlpha (0.5f * outlineThickness * colour.getFloatAlpha()),
+ x, y + diameter * 0.5f, true);
+
+ cg.addColour (0.7, Colours::transparentBlack);
+ cg.addColour (0.8, Colours::black.withAlpha (0.1f * outlineThickness));
+
+ GradientBrush gb (cg);
+ g.setBrush (&gb);
+ g.fillPath (p);
+ }
+
+ g.setColour (Colours::black.withAlpha (0.5f * colour.getFloatAlpha()));
+ g.drawEllipse (x, y, diameter, diameter, outlineThickness);
+}
+
+void LookAndFeel::drawGlassPointer (Graphics& g,
+ const float x, const float y,
+ const float diameter,
+ const Colour& colour, const float outlineThickness,
+ const int direction) throw()
+{
+ if (diameter <= outlineThickness)
+ return;
+
+ Path p;
+ p.startNewSubPath (x + diameter * 0.5f, y);
+ p.lineTo (x + diameter, y + diameter * 0.6f);
+ p.lineTo (x + diameter, y + diameter);
+ p.lineTo (x, y + diameter);
+ p.lineTo (x, y + diameter * 0.6f);
+ p.closeSubPath();
+
+ p.applyTransform (AffineTransform::rotation (direction * (float_Pi * 0.5f), x + diameter * 0.5f, y + diameter * 0.5f));
+
+ {
+ ColourGradient cg (Colours::white.overlaidWith (colour.withMultipliedAlpha (0.3f)), 0, y,
+ Colours::white.overlaidWith (colour.withMultipliedAlpha (0.3f)), 0, y + diameter, false);
+
+ cg.addColour (0.4, Colours::white.overlaidWith (colour));
+
+ GradientBrush gb (cg);
+ g.setBrush (&gb);
+ g.fillPath (p);
+ }
+
+ {
+ ColourGradient cg (Colours::transparentBlack,
+ x + diameter * 0.5f, y + diameter * 0.5f,
+ Colours::black.withAlpha (0.5f * outlineThickness * colour.getFloatAlpha()),
+ x - diameter * 0.2f, y + diameter * 0.5f, true);
+
+ cg.addColour (0.5, Colours::transparentBlack);
+ cg.addColour (0.7, Colours::black.withAlpha (0.07f * outlineThickness));
+
+ GradientBrush gb (cg);
+ g.setBrush (&gb);
+ g.fillPath (p);
+ }
+
+ g.setColour (Colours::black.withAlpha (0.5f * colour.getFloatAlpha()));
+ g.strokePath (p, PathStrokeType (outlineThickness));
+}
+
+void LookAndFeel::drawGlassLozenge (Graphics& g,
+ const float x, const float y,
+ const float width, const float height,
+ const Colour& colour,
+ const float outlineThickness,
+ const float cornerSize,
+ const bool flatOnLeft,
+ const bool flatOnRight,
+ const bool flatOnTop,
+ const bool flatOnBottom) throw()
+{
+ if (width <= outlineThickness || height <= outlineThickness)
+ return;
+
+ const int intX = (int) x;
+ const int intY = (int) y;
+ const int intW = (int) width;
+ const int intH = (int) height;
+
+ const float cs = cornerSize < 0 ? jmin (width * 0.5f, height * 0.5f) : cornerSize;
+ const float edgeBlurRadius = height * 0.75f + (height - cs * 2.0f);
+ const int intEdge = (int) edgeBlurRadius;
+
+ Path outline;
+ createRoundedPath (outline, x, y, width, height, cs,
+ ! (flatOnLeft || flatOnTop),
+ ! (flatOnRight || flatOnTop),
+ ! (flatOnLeft || flatOnBottom),
+ ! (flatOnRight || flatOnBottom));
+
+ {
+ ColourGradient cg (colour.darker (0.2f), 0, y,
+ colour.darker (0.2f), 0, y + height, false);
+
+ cg.addColour (0.03, colour.withMultipliedAlpha (0.3f));
+ cg.addColour (0.4, colour);
+ cg.addColour (0.97, colour.withMultipliedAlpha (0.3f));
+
+ GradientBrush gb (cg);
+ g.setBrush (&gb);
+ g.fillPath (outline);
+ }
+
+ ColourGradient cg (Colours::transparentBlack, x + edgeBlurRadius, y + height * 0.5f,
+ colour.darker (0.2f), x, y + height * 0.5f, true);
+
+ cg.addColour (jlimit (0.0, 1.0, 1.0 - (cs * 0.5f) / edgeBlurRadius), Colours::transparentBlack);
+ cg.addColour (jlimit (0.0, 1.0, 1.0 - (cs * 0.25f) / edgeBlurRadius), colour.darker (0.2f).withMultipliedAlpha (0.3f));
+
+ if (! (flatOnLeft || flatOnTop || flatOnBottom))
+ {
+ GradientBrush gb (cg);
+
+ g.saveState();
+ g.setBrush (&gb);
+ g.reduceClipRegion (intX, intY, intEdge, intH);
+ g.fillPath (outline);
+ g.restoreState();
+ }
+
+ if (! (flatOnRight || flatOnTop || flatOnBottom))
+ {
+ cg.x1 = x + width - edgeBlurRadius;
+ cg.x2 = x + width;
+ GradientBrush gb (cg);
+
+ g.saveState();
+ g.setBrush (&gb);
+ g.reduceClipRegion (intX + intW - intEdge, intY, 2 + intEdge, intH);
+ g.fillPath (outline);
+ g.restoreState();
+ }
+
+ {
+ const float leftIndent = flatOnLeft ? 0.0f : cs * 0.4f;
+ const float rightIndent = flatOnRight ? 0.0f : cs * 0.4f;
+
+ Path highlight;
+ createRoundedPath (highlight,
+ x + leftIndent,
+ y + cs * 0.1f,
+ width - (leftIndent + rightIndent),
+ height * 0.4f, cs * 0.4f,
+ ! (flatOnLeft || flatOnTop),
+ ! (flatOnRight || flatOnTop),
+ ! (flatOnLeft || flatOnBottom),
+ ! (flatOnRight || flatOnBottom));
+
+ GradientBrush gb (colour.brighter (10.0f), 0, y + height * 0.06f,
+ Colours::transparentWhite, 0, y + height * 0.4f, false);
+
+ g.setBrush (&gb);
+ g.fillPath (highlight);
+ }
+
+ g.setColour (colour.darker().withMultipliedAlpha (1.5f));
+ g.strokePath (outline, PathStrokeType (outlineThickness));
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_LookAndFeel.cpp *********/
+
+/********* Start of inlined file: juce_OldSchoolLookAndFeel.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+OldSchoolLookAndFeel::OldSchoolLookAndFeel()
+{
+ setColour (TextButton::buttonColourId, Colour (0xffbbbbff));
+ setColour (ListBox::outlineColourId, findColour (ComboBox::outlineColourId));
+ setColour (ScrollBar::thumbColourId, Colour (0xffbbbbdd));
+ setColour (ScrollBar::backgroundColourId, Colours::transparentBlack);
+ setColour (Slider::thumbColourId, Colours::white);
+ setColour (Slider::trackColourId, Colour (0x7f000000));
+ setColour (Slider::textBoxOutlineColourId, Colours::grey);
+ setColour (ProgressBar::backgroundColourId, Colours::white.withAlpha (0.6f));
+ setColour (ProgressBar::foregroundColourId, Colours::green.withAlpha (0.7f));
+ setColour (PopupMenu::backgroundColourId, Colour (0xffeef5f8));
+ setColour (PopupMenu::highlightedBackgroundColourId, Colour (0xbfa4c2ce));
+ setColour (PopupMenu::highlightedTextColourId, Colours::black);
+ setColour (TextEditor::focusedOutlineColourId, findColour (TextButton::buttonColourId));
+
+ scrollbarShadow.setShadowProperties (2.2f, 0.5f, 0, 0);
+}
+
+OldSchoolLookAndFeel::~OldSchoolLookAndFeel()
+{
+}
+
+void OldSchoolLookAndFeel::drawButtonBackground (Graphics& g,
+ Button& button,
+ const Colour& backgroundColour,
+ bool isMouseOverButton,
+ bool isButtonDown)
+{
+ const int width = button.getWidth();
+ const int height = button.getHeight();
+
+ const float indent = 2.0f;
+ const int cornerSize = jmin (roundFloatToInt (width * 0.4f),
+ roundFloatToInt (height * 0.4f));
+
+ Path p;
+ p.addRoundedRectangle (indent, indent,
+ width - indent * 2.0f,
+ height - indent * 2.0f,
+ (float) cornerSize);
+
+ Colour bc (backgroundColour.withMultipliedSaturation (0.3f));
+
+ if (isMouseOverButton)
+ {
+ if (isButtonDown)
+ bc = bc.brighter();
+ else if (bc.getBrightness() > 0.5f)
+ bc = bc.darker (0.1f);
+ else
+ bc = bc.brighter (0.1f);
+ }
+
+ g.setColour (bc);
+ g.fillPath (p);
+
+ g.setColour (bc.contrasting().withAlpha ((isMouseOverButton) ? 0.6f : 0.4f));
+ g.strokePath (p, PathStrokeType ((isMouseOverButton) ? 2.0f : 1.4f));
+}
+
+void OldSchoolLookAndFeel::drawTickBox (Graphics& g,
+ Component& /*component*/,
+ int x, int y, int w, int h,
+ const bool ticked,
+ const bool isEnabled,
+ const bool /*isMouseOverButton*/,
+ const bool isButtonDown)
+{
+ Path box;
+ box.addRoundedRectangle (0.0f, 2.0f, 6.0f, 6.0f, 1.0f);
+
+ g.setColour (isEnabled ? Colours::blue.withAlpha (isButtonDown ? 0.3f : 0.1f)
+ : Colours::lightgrey.withAlpha (0.1f));
+
+ AffineTransform trans (AffineTransform::scale (w / 9.0f, h / 9.0f)
+ .translated ((float) x, (float) y));
+
+ g.fillPath (box, trans);
+
+ g.setColour (Colours::black.withAlpha (0.6f));
+ g.strokePath (box, PathStrokeType (0.9f), trans);
+
+ if (ticked)
+ {
+ Path tick;
+ tick.startNewSubPath (1.5f, 3.0f);
+ tick.lineTo (3.0f, 6.0f);
+ tick.lineTo (6.0f, 0.0f);
+
+ g.setColour (isEnabled ? Colours::black : Colours::grey);
+ g.strokePath (tick, PathStrokeType (2.5f), trans);
+ }
+}
+
+void OldSchoolLookAndFeel::drawToggleButton (Graphics& g,
+ ToggleButton& button,
+ bool isMouseOverButton,
+ bool isButtonDown)
+{
+ if (button.hasKeyboardFocus (true))
+ {
+ g.setColour (button.findColour (TextEditor::focusedOutlineColourId));
+ g.drawRect (0, 0, button.getWidth(), button.getHeight());
+ }
+
+ const int tickWidth = jmin (20, button.getHeight() - 4);
+
+ drawTickBox (g, button, 4, (button.getHeight() - tickWidth) / 2,
+ tickWidth, tickWidth,
+ button.getToggleState(),
+ button.isEnabled(),
+ isMouseOverButton,
+ isButtonDown);
+
+ g.setColour (button.findColour (ToggleButton::textColourId));
+ g.setFont (jmin (15.0f, button.getHeight() * 0.6f));
+
+ if (! button.isEnabled())
+ g.setOpacity (0.5f);
+
+ const int textX = tickWidth + 5;
+
+ g.drawFittedText (button.getButtonText(),
+ textX, 4,
+ button.getWidth() - textX - 2, button.getHeight() - 8,
+ Justification::centredLeft, 10);
+}
+
+void OldSchoolLookAndFeel::drawProgressBar (Graphics& g, ProgressBar& progressBar,
+ int width, int height,
+ double progress, const String& textToShow)
+{
+ if (progress < 0 || progress >= 1.0)
+ {
+ LookAndFeel::drawProgressBar (g, progressBar, width, height, progress, textToShow);
+ }
+ else
+ {
+ const Colour background (progressBar.findColour (ProgressBar::backgroundColourId));
+ const Colour foreground (progressBar.findColour (ProgressBar::foregroundColourId));
+
+ g.fillAll (background);
+ g.setColour (foreground);
+
+ g.fillRect (1, 1,
+ jlimit (0, width - 2, roundDoubleToInt (progress * (width - 2))),
+ height - 2);
+
+ if (textToShow.isNotEmpty())
+ {
+ g.setColour (Colour::contrasting (background, foreground));
+ g.setFont (height * 0.6f);
+
+ g.drawText (textToShow, 0, 0, width, height, Justification::centred, false);
+ }
+ }
+}
+
+void OldSchoolLookAndFeel::drawScrollbarButton (Graphics& g,
+ ScrollBar& bar,
+ int width, int height,
+ int buttonDirection,
+ bool isScrollbarVertical,
+ bool isMouseOverButton,
+ bool isButtonDown)
+{
+ if (isScrollbarVertical)
+ width -= 2;
+ else
+ height -= 2;
+
+ Path p;
+
+ if (buttonDirection == 0)
+ p.addTriangle (width * 0.5f, height * 0.2f,
+ width * 0.1f, height * 0.7f,
+ width * 0.9f, height * 0.7f);
+ else if (buttonDirection == 1)
+ p.addTriangle (width * 0.8f, height * 0.5f,
+ width * 0.3f, height * 0.1f,
+ width * 0.3f, height * 0.9f);
+ else if (buttonDirection == 2)
+ p.addTriangle (width * 0.5f, height * 0.8f,
+ width * 0.1f, height * 0.3f,
+ width * 0.9f, height * 0.3f);
+ else if (buttonDirection == 3)
+ p.addTriangle (width * 0.2f, height * 0.5f,
+ width * 0.7f, height * 0.1f,
+ width * 0.7f, height * 0.9f);
+
+ if (isButtonDown)
+ g.setColour (Colours::white);
+ else if (isMouseOverButton)
+ g.setColour (Colours::white.withAlpha (0.7f));
+ else
+ g.setColour (bar.findColour (ScrollBar::thumbColourId).withAlpha (0.5f));
+
+ g.fillPath (p);
+
+ g.setColour (Colours::black.withAlpha (0.5f));
+ g.strokePath (p, PathStrokeType (0.5f));
+}
+
+void OldSchoolLookAndFeel::drawScrollbar (Graphics& g,
+ ScrollBar& bar,
+ int x, int y,
+ int width, int height,
+ bool isScrollbarVertical,
+ int thumbStartPosition,
+ int thumbSize,
+ bool isMouseOver,
+ bool isMouseDown)
+{
+ g.fillAll (bar.findColour (ScrollBar::backgroundColourId));
+
+ g.setColour (bar.findColour (ScrollBar::thumbColourId)
+ .withAlpha ((isMouseOver || isMouseDown) ? 0.4f : 0.15f));
+
+ if (thumbSize > 0.0f)
+ {
+ Rectangle thumb;
+
+ if (isScrollbarVertical)
+ {
+ width -= 2;
+ g.fillRect (x + roundFloatToInt (width * 0.35f), y,
+ roundFloatToInt (width * 0.3f), height);
+
+ thumb.setBounds (x + 1, thumbStartPosition,
+ width - 2, thumbSize);
+ }
+ else
+ {
+ height -= 2;
+ g.fillRect (x, y + roundFloatToInt (height * 0.35f),
+ width, roundFloatToInt (height * 0.3f));
+
+ thumb.setBounds (thumbStartPosition, y + 1,
+ thumbSize, height - 2);
+ }
+
+ g.setColour (bar.findColour (ScrollBar::thumbColourId)
+ .withAlpha ((isMouseOver || isMouseDown) ? 0.95f : 0.7f));
+
+ g.fillRect (thumb);
+
+ g.setColour (Colours::black.withAlpha ((isMouseOver || isMouseDown) ? 0.4f : 0.25f));
+ g.drawRect (thumb.getX(), thumb.getY(), thumb.getWidth(), thumb.getHeight());
+
+ if (thumbSize > 16)
+ {
+ for (int i = 3; --i >= 0;)
+ {
+ const float linePos = thumbStartPosition + thumbSize / 2 + (i - 1) * 4.0f;
+ g.setColour (Colours::black.withAlpha (0.15f));
+
+ if (isScrollbarVertical)
+ {
+ g.drawLine (x + width * 0.2f, linePos, width * 0.8f, linePos);
+ g.setColour (Colours::white.withAlpha (0.15f));
+ g.drawLine (width * 0.2f, linePos - 1, width * 0.8f, linePos - 1);
+ }
+ else
+ {
+ g.drawLine (linePos, height * 0.2f, linePos, height * 0.8f);
+ g.setColour (Colours::white.withAlpha (0.15f));
+ g.drawLine (linePos - 1, height * 0.2f, linePos - 1, height * 0.8f);
+ }
+ }
+ }
+ }
+}
+
+ImageEffectFilter* OldSchoolLookAndFeel::getScrollbarEffect()
+{
+ return &scrollbarShadow;
+}
+
+void OldSchoolLookAndFeel::drawPopupMenuBackground (Graphics& g, int width, int height)
+{
+ g.fillAll (findColour (PopupMenu::backgroundColourId));
+
+ g.setColour (Colours::black.withAlpha (0.6f));
+ g.drawRect (0, 0, width, height);
+}
+
+void OldSchoolLookAndFeel::drawMenuBarBackground (Graphics& g, int /*width*/, int /*height*/,
+ bool, MenuBarComponent& menuBar)
+{
+ g.fillAll (menuBar.findColour (PopupMenu::backgroundColourId));
+}
+
+void OldSchoolLookAndFeel::drawTextEditorOutline (Graphics& g, int width, int height, TextEditor& textEditor)
+{
+ if (textEditor.isEnabled())
+ {
+ g.setColour (textEditor.findColour (TextEditor::outlineColourId));
+ g.drawRect (0, 0, width, height);
+ }
+}
+
+void OldSchoolLookAndFeel::drawComboBox (Graphics& g, int width, int height,
+ const bool isButtonDown,
+ int buttonX, int buttonY,
+ int buttonW, int buttonH,
+ ComboBox& box)
+{
+ g.fillAll (box.findColour (ComboBox::backgroundColourId));
+
+ g.setColour (box.findColour ((isButtonDown) ? ComboBox::buttonColourId
+ : ComboBox::backgroundColourId));
+ g.fillRect (buttonX, buttonY, buttonW, buttonH);
+
+ g.setColour (box.findColour (ComboBox::outlineColourId));
+ g.drawRect (0, 0, width, height);
+
+ const float arrowX = 0.2f;
+ const float arrowH = 0.3f;
+
+ if (box.isEnabled())
+ {
+ Path p;
+ p.addTriangle (buttonX + buttonW * 0.5f, buttonY + buttonH * (0.45f - arrowH),
+ buttonX + buttonW * (1.0f - arrowX), buttonY + buttonH * 0.45f,
+ buttonX + buttonW * arrowX, buttonY + buttonH * 0.45f);
+
+ p.addTriangle (buttonX + buttonW * 0.5f, buttonY + buttonH * (0.55f + arrowH),
+ buttonX + buttonW * (1.0f - arrowX), buttonY + buttonH * 0.55f,
+ buttonX + buttonW * arrowX, buttonY + buttonH * 0.55f);
+
+ g.setColour (box.findColour ((isButtonDown) ? ComboBox::backgroundColourId
+ : ComboBox::buttonColourId));
+ g.fillPath (p);
+ }
+}
+
+const Font OldSchoolLookAndFeel::getComboBoxFont (ComboBox& box)
+{
+ Font f (jmin (15.0f, box.getHeight() * 0.85f));
+ f.setHorizontalScale (0.9f);
+ return f;
+}
+
+static void drawTriangle (Graphics& g, float x1, float y1, float x2, float y2, float x3, float y3, const Colour& fill, const Colour& outline) throw()
+{
+ Path p;
+ p.addTriangle (x1, y1, x2, y2, x3, y3);
+ g.setColour (fill);
+ g.fillPath (p);
+
+ g.setColour (outline);
+ g.strokePath (p, PathStrokeType (0.3f));
+}
+
+void OldSchoolLookAndFeel::drawLinearSlider (Graphics& g,
+ int x, int y,
+ int w, int h,
+ float sliderPos,
+ float minSliderPos,
+ float maxSliderPos,
+ const Slider::SliderStyle style,
+ Slider& slider)
+{
+ g.fillAll (slider.findColour (Slider::backgroundColourId));
+
+ if (style == Slider::LinearBar)
+ {
+ g.setColour (slider.findColour (Slider::thumbColourId));
+ g.fillRect (x, y, (int) sliderPos - x, h);
+
+ g.setColour (slider.findColour (Slider::textBoxTextColourId).withMultipliedAlpha (0.5f));
+ g.drawRect (x, y, (int) sliderPos - x, h);
+ }
+ else
+ {
+ g.setColour (slider.findColour (Slider::trackColourId)
+ .withMultipliedAlpha (slider.isEnabled() ? 1.0f : 0.3f));
+
+ if (slider.isHorizontal())
+ {
+ g.fillRect (x, y + roundFloatToInt (h * 0.6f),
+ w, roundFloatToInt (h * 0.2f));
+ }
+ else
+ {
+ g.fillRect (x + roundFloatToInt (w * 0.5f - jmin (3.0f, w * 0.1f)), y,
+ jmin (4, roundFloatToInt (w * 0.2f)), h);
+ }
+
+ float alpha = 0.35f;
+
+ if (slider.isEnabled())
+ alpha = slider.isMouseOverOrDragging() ? 1.0f : 0.7f;
+
+ const Colour fill (slider.findColour (Slider::thumbColourId).withAlpha (alpha));
+ const Colour outline (Colours::black.withAlpha (slider.isEnabled() ? 0.7f : 0.35f));
+
+ if (style == Slider::TwoValueVertical || style == Slider::ThreeValueVertical)
+ {
+ drawTriangle (g, x + w * 0.5f + jmin (4.0f, w * 0.3f), minSliderPos,
+ x + w * 0.5f - jmin (8.0f, w * 0.4f), minSliderPos - 7.0f,
+ x + w * 0.5f - jmin (8.0f, w * 0.4f), minSliderPos,
+ fill, outline);
+
+ drawTriangle (g, x + w * 0.5f + jmin (4.0f, w * 0.3f), maxSliderPos,
+ x + w * 0.5f - jmin (8.0f, w * 0.4f), maxSliderPos,
+ x + w * 0.5f - jmin (8.0f, w * 0.4f), maxSliderPos + 7.0f,
+ fill, outline);
+ }
+ else if (style == Slider::TwoValueHorizontal || style == Slider::ThreeValueHorizontal)
+ {
+ drawTriangle (g, minSliderPos, y + h * 0.6f - jmin (4.0f, h * 0.3f),
+ minSliderPos - 7.0f, y + h * 0.9f ,
+ minSliderPos, y + h * 0.9f,
+ fill, outline);
+
+ drawTriangle (g, maxSliderPos, y + h * 0.6f - jmin (4.0f, h * 0.3f),
+ maxSliderPos, y + h * 0.9f,
+ maxSliderPos + 7.0f, y + h * 0.9f,
+ fill, outline);
+ }
+
+ if (style == Slider::LinearHorizontal || style == Slider::ThreeValueHorizontal)
+ {
+ drawTriangle (g, sliderPos, y + h * 0.9f,
+ sliderPos - 7.0f, y + h * 0.2f,
+ sliderPos + 7.0f, y + h * 0.2f,
+ fill, outline);
+ }
+ else if (style == Slider::LinearVertical || style == Slider::ThreeValueVertical)
+ {
+ drawTriangle (g, x + w * 0.5f - jmin (4.0f, w * 0.3f), sliderPos,
+ x + w * 0.5f + jmin (8.0f, w * 0.4f), sliderPos - 7.0f,
+ x + w * 0.5f + jmin (8.0f, w * 0.4f), sliderPos + 7.0f,
+ fill, outline);
+ }
+ }
+}
+
+Button* OldSchoolLookAndFeel::createSliderButton (const bool isIncrement)
+{
+ if (isIncrement)
+ return new ArrowButton ("u", 0.75f, Colours::white.withAlpha (0.8f));
+ else
+ return new ArrowButton ("d", 0.25f, Colours::white.withAlpha (0.8f));
+}
+
+ImageEffectFilter* OldSchoolLookAndFeel::getSliderEffect()
+{
+ return &scrollbarShadow;
+}
+
+int OldSchoolLookAndFeel::getSliderThumbRadius (Slider&)
+{
+ return 8;
+}
+
+void OldSchoolLookAndFeel::drawCornerResizer (Graphics& g,
+ int w, int h,
+ bool isMouseOver,
+ bool isMouseDragging)
+{
+ g.setColour ((isMouseOver || isMouseDragging) ? Colours::lightgrey
+ : Colours::darkgrey);
+
+ const float lineThickness = jmin (w, h) * 0.1f;
+
+ for (float i = 0.0f; i < 1.0f; i += 0.3f)
+ {
+ g.drawLine (w * i,
+ h + 1.0f,
+ w + 1.0f,
+ h * i,
+ lineThickness);
+ }
+}
+
+Button* OldSchoolLookAndFeel::createDocumentWindowButton (int buttonType)
+{
+ Path shape;
+
+ if (buttonType == DocumentWindow::closeButton)
+ {
+ shape.addLineSegment (0.0f, 0.0f, 1.0f, 1.0f, 0.35f);
+ shape.addLineSegment (1.0f, 0.0f, 0.0f, 1.0f, 0.35f);
+
+ ShapeButton* const b = new ShapeButton ("close",
+ Colour (0x7fff3333),
+ Colour (0xd7ff3333),
+ Colour (0xf7ff3333));
+
+ b->setShape (shape, true, true, true);
+ return b;
+ }
+ else if (buttonType == DocumentWindow::minimiseButton)
+ {
+ shape.addLineSegment (0.0f, 0.5f, 1.0f, 0.5f, 0.25f);
+
+ DrawableButton* b = new DrawableButton ("minimise", DrawableButton::ImageFitted);
+ DrawablePath dp;
+ dp.setPath (shape);
+ dp.setSolidFill (Colours::black.withAlpha (0.3f));
+ b->setImages (&dp);
+ return b;
+ }
+ else if (buttonType == DocumentWindow::maximiseButton)
+ {
+ shape.addLineSegment (0.5f, 0.0f, 0.5f, 1.0f, 0.25f);
+ shape.addLineSegment (0.0f, 0.5f, 1.0f, 0.5f, 0.25f);
+
+ DrawableButton* b = new DrawableButton ("maximise", DrawableButton::ImageFitted);
+ DrawablePath dp;
+ dp.setPath (shape);
+ dp.setSolidFill (Colours::black.withAlpha (0.3f));
+ b->setImages (&dp);
+ return b;
+ }
+
+ jassertfalse
+ return 0;
+}
+
+void OldSchoolLookAndFeel::positionDocumentWindowButtons (DocumentWindow&,
+ int titleBarX,
+ int titleBarY,
+ int titleBarW,
+ int titleBarH,
+ Button* minimiseButton,
+ Button* maximiseButton,
+ Button* closeButton,
+ bool positionTitleBarButtonsOnLeft)
+{
+ titleBarY += titleBarH / 8;
+ titleBarH -= titleBarH / 4;
+
+ const int buttonW = titleBarH;
+
+ int x = positionTitleBarButtonsOnLeft ? titleBarX + 4
+ : titleBarX + titleBarW - buttonW - 4;
+
+ if (closeButton != 0)
+ {
+ closeButton->setBounds (x, titleBarY, buttonW, titleBarH);
+ x += positionTitleBarButtonsOnLeft ? buttonW + buttonW / 5
+ : -(buttonW + buttonW / 5);
+ }
+
+ if (positionTitleBarButtonsOnLeft)
+ swapVariables (minimiseButton, maximiseButton);
+
+ if (maximiseButton != 0)
+ {
+ maximiseButton->setBounds (x, titleBarY - 2, buttonW, titleBarH);
+ x += positionTitleBarButtonsOnLeft ? buttonW : -buttonW;
+ }
+
+ if (minimiseButton != 0)
+ minimiseButton->setBounds (x, titleBarY - 2, buttonW, titleBarH);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_OldSchoolLookAndFeel.cpp *********/
+
+/********* Start of inlined file: juce_MenuBarComponent.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+class DummyMenuComponent : public Component
+{
+ DummyMenuComponent (const DummyMenuComponent&);
+ const DummyMenuComponent& operator= (const DummyMenuComponent&);
+
+public:
+ DummyMenuComponent() {}
+ ~DummyMenuComponent() {}
+
+ void inputAttemptWhenModal()
+ {
+ exitModalState (0);
+ }
+};
+
+MenuBarComponent::MenuBarComponent (MenuBarModel* model_)
+ : model (0),
+ itemUnderMouse (-1),
+ currentPopupIndex (-1),
+ indexToShowAgain (-1),
+ lastMouseX (0),
+ lastMouseY (0),
+ inModalState (false),
+ currentPopup (0)
+{
+ setRepaintsOnMouseActivity (true);
+ setWantsKeyboardFocus (false);
+ setMouseClickGrabsKeyboardFocus (false);
+
+ setModel (model_);
+}
+
+MenuBarComponent::~MenuBarComponent()
+{
+ setModel (0);
+
+ Desktop::getInstance().removeGlobalMouseListener (this);
+ deleteAndZero (currentPopup);
+}
+
+void MenuBarComponent::setModel (MenuBarModel* const newModel)
+{
+ if (model != newModel)
+ {
+ if (model != 0)
+ model->removeListener (this);
+
+ model = newModel;
+
+ if (model != 0)
+ model->addListener (this);
+
+ repaint();
+ menuBarItemsChanged (0);
+ }
+}
+
+void MenuBarComponent::paint (Graphics& g)
+{
+ const bool isMouseOverBar = currentPopupIndex >= 0 || itemUnderMouse >= 0 || isMouseOver();
+
+ getLookAndFeel().drawMenuBarBackground (g,
+ getWidth(),
+ getHeight(),
+ isMouseOverBar,
+ *this);
+
+ if (model != 0)
+ {
+ for (int i = 0; i < menuNames.size(); ++i)
+ {
+ g.saveState();
+ g.setOrigin (xPositions [i], 0);
+ g.reduceClipRegion (0, 0, xPositions[i + 1] - xPositions[i], getHeight());
+
+ getLookAndFeel().drawMenuBarItem (g,
+ xPositions[i + 1] - xPositions[i],
+ getHeight(),
+ i,
+ menuNames[i],
+ i == itemUnderMouse,
+ i == currentPopupIndex,
+ isMouseOverBar,
+ *this);
+
+ g.restoreState();
+ }
+ }
+}
+
+void MenuBarComponent::resized()
+{
+ xPositions.clear();
+ int x = 2;
+ xPositions.add (x);
+
+ for (int i = 0; i < menuNames.size(); ++i)
+ {
+ x += getLookAndFeel().getMenuBarItemWidth (*this, i, menuNames[i]);
+
+ xPositions.add (x);
+ }
+}
+
+int MenuBarComponent::getItemAt (const int x, const int y)
+{
+ for (int i = 0; i < xPositions.size(); ++i)
+ if (x >= xPositions[i] && x < xPositions[i + 1])
+ return reallyContains (x, y, true) ? i : -1;
+
+ return -1;
+}
+
+void MenuBarComponent::repaintMenuItem (int index)
+{
+ if (((unsigned int) index) < (unsigned int) xPositions.size())
+ {
+ const int x1 = xPositions [index];
+ const int x2 = xPositions [index + 1];
+
+ repaint (x1 - 2, 0, x2 - x1 + 4, getHeight());
+ }
+}
+
+void MenuBarComponent::updateItemUnderMouse (int x, int y)
+{
+ const int newItem = getItemAt (x, y);
+
+ if (itemUnderMouse != newItem)
+ {
+ repaintMenuItem (itemUnderMouse);
+ itemUnderMouse = newItem;
+ repaintMenuItem (itemUnderMouse);
+ }
+}
+
+void MenuBarComponent::hideCurrentMenu()
+{
+ deleteAndZero (currentPopup);
+ repaint();
+}
+
+void MenuBarComponent::showMenu (int index)
+{
+ if (index != currentPopupIndex)
+ {
+ if (inModalState)
+ {
+ hideCurrentMenu();
+ indexToShowAgain = index;
+ return;
+ }
+
+ indexToShowAgain = -1;
+ currentPopupIndex = -1;
+ deleteAndZero (currentPopup);
+ menuBarItemsChanged (0);
+
+ Component* const prevFocused = getCurrentlyFocusedComponent();
+
+ ComponentDeletionWatcher* prevCompDeletionChecker = 0;
+ if (prevFocused != 0)
+ prevCompDeletionChecker = new ComponentDeletionWatcher (prevFocused);
+
+ ComponentDeletionWatcher deletionChecker (this);
+
+ enterModalState (false);
+ inModalState = true;
+ int result = 0;
+ ApplicationCommandManager* managerOfChosenCommand = 0;
+
+ Desktop::getInstance().addGlobalMouseListener (this);
+
+ for (;;)
+ {
+ const int x = getScreenX() + xPositions [itemUnderMouse];
+ const int w = xPositions [itemUnderMouse + 1] - xPositions [itemUnderMouse];
+
+ currentPopupIndex = itemUnderMouse;
+ indexToShowAgain = -1;
+ repaint();
+
+ if (((unsigned int) itemUnderMouse) < (unsigned int) menuNames.size())
+ {
+ PopupMenu m (model->getMenuForIndex (itemUnderMouse,
+ menuNames [itemUnderMouse]));
+
+ currentPopup = m.createMenuComponent (x, getScreenY(),
+ w, getHeight(),
+ 0, w, 0, 0,
+ true, this,
+ &managerOfChosenCommand,
+ this);
+ }
+
+ if (currentPopup == 0)
+ {
+ currentPopup = new DummyMenuComponent();
+ addAndMakeVisible (currentPopup);
+ }
+
+ currentPopup->enterModalState (false);
+ currentPopup->toFront (false); // need to do this after making it modal, or it could
+ // be stuck behind other comps that are already modal..
+ result = currentPopup->runModalLoop();
+
+ if (deletionChecker.hasBeenDeleted())
+ {
+ delete prevCompDeletionChecker;
+ return;
+ }
+
+ const int lastPopupIndex = currentPopupIndex;
+ deleteAndZero (currentPopup);
+ currentPopupIndex = -1;
+
+ if (result != 0)
+ {
+ topLevelIndexClicked = lastPopupIndex;
+ break;
+ }
+ else if (indexToShowAgain >= 0)
+ {
+ menuBarItemsChanged (0);
+ repaint();
+ itemUnderMouse = indexToShowAgain;
+
+ if (((unsigned int) itemUnderMouse) >= (unsigned int) menuNames.size())
+ break;
+ }
+ else
+ {
+ break;
+ }
+ }
+
+ Desktop::getInstance().removeGlobalMouseListener (this);
+
+ inModalState = false;
+ exitModalState (0);
+
+ if (prevCompDeletionChecker != 0)
+ {
+ if (! prevCompDeletionChecker->hasBeenDeleted())
+ prevFocused->grabKeyboardFocus();
+
+ delete prevCompDeletionChecker;
+ }
+
+ int mx, my;
+ getMouseXYRelative (mx, my);
+ updateItemUnderMouse (mx, my);
+ repaint();
+
+ if (result != 0)
+ {
+ if (managerOfChosenCommand != 0)
+ {
+ ApplicationCommandTarget::InvocationInfo info (result);
+ info.invocationMethod = ApplicationCommandTarget::InvocationInfo::fromMenu;
+
+ managerOfChosenCommand->invoke (info, true);
+ }
+
+ postCommandMessage (result);
+ }
+ }
+}
+
+void MenuBarComponent::handleCommandMessage (int commandId)
+{
+ if (model != 0)
+ model->menuItemSelected (commandId, topLevelIndexClicked);
+}
+
+void MenuBarComponent::mouseEnter (const MouseEvent& e)
+{
+ if (e.eventComponent == this)
+ updateItemUnderMouse (e.x, e.y);
+}
+
+void MenuBarComponent::mouseExit (const MouseEvent& e)
+{
+ if (e.eventComponent == this)
+ updateItemUnderMouse (e.x, e.y);
+}
+
+void MenuBarComponent::mouseDown (const MouseEvent& e)
+{
+ const MouseEvent e2 (e.getEventRelativeTo (this));
+
+ if (currentPopupIndex < 0)
+ {
+ updateItemUnderMouse (e2.x, e2.y);
+
+ currentPopupIndex = -2;
+ showMenu (itemUnderMouse);
+ }
+}
+
+void MenuBarComponent::mouseDrag (const MouseEvent& e)
+{
+ const MouseEvent e2 (e.getEventRelativeTo (this));
+
+ const int item = getItemAt (e2.x, e2.y);
+
+ if (item >= 0)
+ showMenu (item);
+}
+
+void MenuBarComponent::mouseUp (const MouseEvent& e)
+{
+ const MouseEvent e2 (e.getEventRelativeTo (this));
+
+ updateItemUnderMouse (e2.x, e2.y);
+
+ if (itemUnderMouse < 0 && dynamic_cast (currentPopup) != 0)
+ hideCurrentMenu();
+}
+
+void MenuBarComponent::mouseMove (const MouseEvent& e)
+{
+ const MouseEvent e2 (e.getEventRelativeTo (this));
+
+ if (lastMouseX != e2.x || lastMouseY != e2.y)
+ {
+ if (currentPopupIndex >= 0)
+ {
+ const int item = getItemAt (e2.x, e2.y);
+
+ if (item >= 0)
+ showMenu (item);
+ }
+ else
+ {
+ updateItemUnderMouse (e2.x, e2.y);
+ }
+
+ lastMouseX = e2.x;
+ lastMouseY = e2.y;
+ }
+}
+
+bool MenuBarComponent::keyPressed (const KeyPress& key)
+{
+ bool used = false;
+ const int numMenus = menuNames.size();
+ const int currentIndex = jlimit (0, menuNames.size() - 1, currentPopupIndex);
+
+ if (key.isKeyCode (KeyPress::leftKey))
+ {
+ showMenu ((currentIndex + numMenus - 1) % numMenus);
+ used = true;
+ }
+ else if (key.isKeyCode (KeyPress::rightKey))
+ {
+ showMenu ((currentIndex + 1) % numMenus);
+ used = true;
+ }
+
+ return used;
+}
+
+void MenuBarComponent::inputAttemptWhenModal()
+{
+ hideCurrentMenu();
+}
+
+void MenuBarComponent::menuBarItemsChanged (MenuBarModel* /*menuBarModel*/)
+{
+ StringArray newNames;
+
+ if (model != 0)
+ newNames = model->getMenuBarNames();
+
+ if (newNames != menuNames)
+ {
+ menuNames = newNames;
+ repaint();
+ resized();
+ }
+}
+
+void MenuBarComponent::menuCommandInvoked (MenuBarModel* /*menuBarModel*/,
+ const ApplicationCommandTarget::InvocationInfo& info)
+{
+ if (model == 0
+ || (info.commandFlags & ApplicationCommandInfo::dontTriggerVisualFeedback) != 0)
+ return;
+
+ for (int i = 0; i < menuNames.size(); ++i)
+ {
+ const PopupMenu menu (model->getMenuForIndex (i, menuNames [i]));
+
+ if (menu.containsCommandItem (info.commandID))
+ {
+ itemUnderMouse = i;
+ repaintMenuItem (i);
+ startTimer (200);
+
+ break;
+ }
+ }
+}
+
+void MenuBarComponent::timerCallback()
+{
+ stopTimer();
+
+ int mx, my;
+ getMouseXYRelative (mx, my);
+ updateItemUnderMouse (mx, my);
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_MenuBarComponent.cpp *********/
+
+/********* Start of inlined file: juce_MenuBarModel.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+MenuBarModel::MenuBarModel() throw()
+ : manager (0)
+{
+}
+
+MenuBarModel::~MenuBarModel()
+{
+ setApplicationCommandManagerToWatch (0);
+}
+
+void MenuBarModel::menuItemsChanged()
+{
+ triggerAsyncUpdate();
+}
+
+void MenuBarModel::setApplicationCommandManagerToWatch (ApplicationCommandManager* const newManager) throw()
+{
+ if (manager != newManager)
+ {
+ if (manager != 0)
+ manager->removeListener (this);
+
+ manager = newManager;
+
+ if (manager != 0)
+ manager->addListener (this);
+ }
+}
+
+void MenuBarModel::addListener (MenuBarModelListener* const newListener) throw()
+{
+ jassert (newListener != 0);
+ jassert (! listeners.contains (newListener)); // trying to add a listener to the list twice!
+
+ if (newListener != 0)
+ listeners.add (newListener);
+}
+
+void MenuBarModel::removeListener (MenuBarModelListener* const listenerToRemove) throw()
+{
+ // Trying to remove a listener that isn't on the list!
+ // If this assertion happens because this object is a dangling pointer, make sure you've not
+ // deleted this menu model while it's still being used by something (e.g. by a MenuBarComponent)
+ jassert (listeners.contains (listenerToRemove));
+
+ listeners.removeValue (listenerToRemove);
+}
+
+void MenuBarModel::handleAsyncUpdate()
+{
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ ((MenuBarModelListener*) listeners.getUnchecked (i))->menuBarItemsChanged (this);
+ i = jmin (i, listeners.size());
+ }
+}
+
+void MenuBarModel::applicationCommandInvoked (const ApplicationCommandTarget::InvocationInfo& info)
+{
+ for (int i = listeners.size(); --i >= 0;)
+ {
+ ((MenuBarModelListener*) listeners.getUnchecked (i))->menuCommandInvoked (this, info);
+ i = jmin (i, listeners.size());
+ }
+}
+
+void MenuBarModel::applicationCommandListChanged()
+{
+ menuItemsChanged();
+}
+
+END_JUCE_NAMESPACE
+/********* End of inlined file: juce_MenuBarModel.cpp *********/
+
+/********* Start of inlined file: juce_PopupMenu.cpp *********/
+
+BEGIN_JUCE_NAMESPACE
+
+static VoidArray activeMenuWindows;
+
+class MenuItemInfo
+{
+public:
+
+ const int itemId;
+ String text;
+ const Colour textColour;
+ const bool active, isSeparator, isTicked, usesColour;
+ Image* image;
+ PopupMenuCustomComponent* const customComp;
+ PopupMenu* subMenu;
+ ApplicationCommandManager* const commandManager;
+
+ MenuItemInfo() throw()
+ : itemId (0),
+ active (true),
+ isSeparator (true),
+ isTicked (false),
+ usesColour (false),
+ image (0),
+ customComp (0),
+ subMenu (0),
+ commandManager (0)
+ {
+ }
+
+ MenuItemInfo (const int itemId_,
+ const String& text_,
+ const bool active_,
+ const bool isTicked_,
+ const Image* im,
+ const Colour& textColour_,
+ const bool usesColour_,
+ PopupMenuCustomComponent* const customComp_,
+ const PopupMenu* const subMenu_,
+ ApplicationCommandManager* const commandManager_) throw()
+ : itemId (itemId_),
+ text (text_),
+ textColour (textColour_),
+ active (active_),
+ isSeparator (false),
+ isTicked (isTicked_),
+ usesColour (usesColour_),
+ image (0),
+ customComp (customComp_),
+ commandManager (commandManager_)
+ {
+ subMenu = (subMenu_ != 0) ? new PopupMenu (*subMenu_) : 0;
+
+ if (customComp != 0)
+ customComp->refCount_++;
+
+ if (im != 0)
+ image = im->createCopy();
+
+ if (commandManager_ != 0 && itemId_ != 0)
+ {
+ String shortcutKey;
+
+ Array keyPresses (commandManager_->getKeyMappings()
+ ->getKeyPressesAssignedToCommand (itemId_));
+
+ for (int i = 0; i < keyPresses.size(); ++i)
+ {
+ const String key (keyPresses.getReference(i).getTextDescription());
+
+ if (shortcutKey.isNotEmpty())
+ shortcutKey << ", ";
+
+ if (key.length() == 1)
+ shortcutKey << "shortcut: '" << key << '\'';
+ else
+ shortcutKey << key;
+ }
+
+ shortcutKey = shortcutKey.trim();
+
+ if (shortcutKey.isNotEmpty())
+ text << "