falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 43 Activity
Browse Source

Update juce again

tags/1.9.8
falkTX 8 years ago
parent
6c107aba5b
commit
de0bb14ffb
26 changed files with 275 additions and 196 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +14
    -14
      source/modules/juce_audio_basics/buffers/juce_AudioDataConverters.h
  2. +2
    -0
      source/modules/juce_audio_basics/buffers/juce_FloatVectorOperations.cpp
  3. +32
    -10
      source/modules/juce_audio_formats/codecs/juce_WavAudioFormat.cpp
  4. +5
    -3
      source/modules/juce_audio_processors/format_types/juce_AudioUnitPluginFormat.mm
  5. +1
    -0
      source/modules/juce_core/juce_core.cpp
  6. +2
    -2
      source/modules/juce_core/maths/juce_Random.cpp
  7. +67
    -61
      source/modules/juce_core/memory/juce_ByteOrder.h
  8. +81
    -47
      source/modules/juce_core/native/java/JuceAppActivity.java
  9. +4
    -2
      source/modules/juce_core/native/juce_android_Network.cpp
  10. +2
    -2
      source/modules/juce_core/native/juce_curl_Network.cpp
  11. +2
    -2
      source/modules/juce_core/native/juce_linux_Network.cpp
  12. +11
    -7
      source/modules/juce_core/native/juce_mac_Network.mm
  13. +1
    -1
      source/modules/juce_core/native/juce_win32_Files.cpp
  14. +2
    -2
      source/modules/juce_core/native/juce_win32_Network.cpp
  15. +3
    -2
      source/modules/juce_core/network/juce_URL.cpp
  16. +4
    -4
      source/modules/juce_core/network/juce_URL.h
  17. +1
    -1
      source/modules/juce_core/system/juce_StandardHeader.h
  18. +2
    -4
      source/modules/juce_core/text/juce_CharPointer_UTF8.h
  19. +16
    -14
      source/modules/juce_core/text/juce_CharacterFunctions.h
  20. +1
    -1
      source/modules/juce_core/text/juce_String.cpp
  21. +1
    -1
      source/modules/juce_core/threads/juce_ThreadPool.cpp
  22. +9
    -4
      source/modules/juce_core/zip/juce_ZipFile.cpp
  23. +2
    -2
      source/modules/juce_core/zip/juce_ZipFile.h
  24. +6
    -6
      source/modules/juce_data_structures/app_properties/juce_PropertiesFile.cpp
  25. +3
    -3
      source/modules/juce_gui_basics/native/juce_win32_FileChooser.cpp
  26. +1
    -1
      source/modules/juce_gui_basics/native/juce_win32_Windowing.cpp

+ 14
- 14
source/modules/juce_audio_basics/buffers/juce_AudioDataConverters.h View File

@@ -104,7 +104,7 @@ public:
inline float getAsFloatBE() const noexcept { return getAsFloatLE(); }
inline void setAsFloatLE (float newValue) noexcept { *data = (int8) jlimit ((int) -maxValue, (int) maxValue, roundToInt (newValue * (1.0 + maxValue))); }
inline void setAsFloatBE (float newValue) noexcept { setAsFloatLE (newValue); }
inline int32 getAsInt32LE() const noexcept { return (int) (*data << 24); }
inline int32 getAsInt32LE() const noexcept { return (int) (*((uint8*) data) << 24); }
inline int32 getAsInt32BE() const noexcept { return getAsInt32LE(); }
inline void setAsInt32LE (int newValue) noexcept { *data = (int8) (newValue >> 24); }
inline void setAsInt32BE (int newValue) noexcept { setAsInt32LE (newValue); }
@@ -129,7 +129,7 @@ public:
inline float getAsFloatBE() const noexcept { return getAsFloatLE(); }
inline void setAsFloatLE (float newValue) noexcept { *data = (uint8) jlimit (0, 255, 128 + roundToInt (newValue * (1.0 + maxValue))); }
inline void setAsFloatBE (float newValue) noexcept { setAsFloatLE (newValue); }
inline int32 getAsInt32LE() const noexcept { return (int) ((*data - 128) << 24); }
inline int32 getAsInt32LE() const noexcept { return (int) (((uint8) (*data - 128)) << 24); }
inline int32 getAsInt32BE() const noexcept { return getAsInt32LE(); }
inline void setAsInt32LE (int newValue) noexcept { *data = (uint8) (128 + (newValue >> 24)); }
inline void setAsInt32BE (int newValue) noexcept { setAsInt32LE (newValue); }
@@ -150,13 +150,13 @@ public:
inline void advance() noexcept { ++data; }
inline void skip (int numSamples) noexcept { data += numSamples; }
inline float getAsFloatLE() const noexcept { return (float) ((1.0 / (1.0 + maxValue)) * (int16) ByteOrder::swapIfBigEndian (*data)); }
inline float getAsFloatLE() const noexcept { return (float) ((1.0 / (1.0 + maxValue)) * (int16) ByteOrder::swapIfBigEndian (*data)); }
inline float getAsFloatBE() const noexcept { return (float) ((1.0 / (1.0 + maxValue)) * (int16) ByteOrder::swapIfLittleEndian (*data)); }
inline void setAsFloatLE (float newValue) noexcept { *data = ByteOrder::swapIfBigEndian ((uint16) jlimit ((int) -maxValue, (int) maxValue, roundToInt (newValue * (1.0 + maxValue)))); }
inline void setAsFloatLE (float newValue) noexcept { *data = ByteOrder::swapIfBigEndian ((uint16) jlimit ((int) -maxValue, (int) maxValue, roundToInt (newValue * (1.0 + maxValue)))); }
inline void setAsFloatBE (float newValue) noexcept { *data = ByteOrder::swapIfLittleEndian ((uint16) jlimit ((int) -maxValue, (int) maxValue, roundToInt (newValue * (1.0 + maxValue)))); }
inline int32 getAsInt32LE() const noexcept { return (int32) (ByteOrder::swapIfBigEndian ((uint16) *data) << 16); }
inline int32 getAsInt32LE() const noexcept { return (int32) (ByteOrder::swapIfBigEndian ((uint16) *data) << 16); }
inline int32 getAsInt32BE() const noexcept { return (int32) (ByteOrder::swapIfLittleEndian ((uint16) *data) << 16); }
inline void setAsInt32LE (int32 newValue) noexcept { *data = ByteOrder::swapIfBigEndian ((uint16) (newValue >> 16)); }
inline void setAsInt32LE (int32 newValue) noexcept { *data = ByteOrder::swapIfBigEndian ((uint16) (newValue >> 16)); }
inline void setAsInt32BE (int32 newValue) noexcept { *data = ByteOrder::swapIfLittleEndian ((uint16) (newValue >> 16)); }
inline void clear() noexcept { *data = 0; }
inline void clearMultiple (int num) noexcept { zeromem (data, (size_t) (num * bytesPerSample)) ;}
@@ -176,13 +176,13 @@ public:
inline void advance() noexcept { data += 3; }
inline void skip (int numSamples) noexcept { data += 3 * numSamples; }
inline float getAsFloatLE() const noexcept { return (float) (ByteOrder::littleEndian24Bit (data) * (1.0 / (1.0 + maxValue))); }
inline float getAsFloatBE() const noexcept { return (float) (ByteOrder::bigEndian24Bit (data) * (1.0 / (1.0 + maxValue))); }
inline float getAsFloatBE() const noexcept { return (float) (ByteOrder::bigEndian24Bit (data) * (1.0 / (1.0 + maxValue))); }
inline void setAsFloatLE (float newValue) noexcept { ByteOrder::littleEndian24BitToChars (jlimit ((int) -maxValue, (int) maxValue, roundToInt (newValue * (1.0 + maxValue))), data); }
inline void setAsFloatBE (float newValue) noexcept { ByteOrder::bigEndian24BitToChars (jlimit ((int) -maxValue, (int) maxValue, roundToInt (newValue * (1.0 + maxValue))), data); }
inline int32 getAsInt32LE() const noexcept { return (int32) ByteOrder::littleEndian24Bit (data) << 8; }
inline int32 getAsInt32BE() const noexcept { return (int32) ByteOrder::bigEndian24Bit (data) << 8; }
inline void setAsFloatBE (float newValue) noexcept { ByteOrder::bigEndian24BitToChars (jlimit ((int) -maxValue, (int) maxValue, roundToInt (newValue * (1.0 + maxValue))), data); }
inline int32 getAsInt32LE() const noexcept { return (int32) (((unsigned int) ByteOrder::littleEndian24Bit (data)) << 8); }
inline int32 getAsInt32BE() const noexcept { return (int32) (((unsigned int) ByteOrder::bigEndian24Bit (data)) << 8); }
inline void setAsInt32LE (int32 newValue) noexcept { ByteOrder::littleEndian24BitToChars (newValue >> 8, data); }
inline void setAsInt32BE (int32 newValue) noexcept { ByteOrder::bigEndian24BitToChars (newValue >> 8, data); }
inline void setAsInt32BE (int32 newValue) noexcept { ByteOrder::bigEndian24BitToChars (newValue >> 8, data); }
inline void clear() noexcept { data[0] = 0; data[1] = 0; data[2] = 0; }
inline void clearMultiple (int num) noexcept { zeromem (data, (size_t) (num * bytesPerSample)) ;}
template <class SourceType> inline void copyFromLE (SourceType& source) noexcept { setAsInt32LE (source.getAsInt32()); }
@@ -200,10 +200,10 @@ public:
inline void advance() noexcept { ++data; }
inline void skip (int numSamples) noexcept { data += numSamples; }
inline float getAsFloatLE() const noexcept { return (float) ((1.0 / (1.0 + maxValue)) * (int32) ByteOrder::swapIfBigEndian (*data)); }
inline float getAsFloatLE() const noexcept { return (float) ((1.0 / (1.0 + maxValue)) * (int32) ByteOrder::swapIfBigEndian (*data)); }
inline float getAsFloatBE() const noexcept { return (float) ((1.0 / (1.0 + maxValue)) * (int32) ByteOrder::swapIfLittleEndian (*data)); }
inline void setAsFloatLE (float newValue) noexcept { *data = ByteOrder::swapIfBigEndian ((uint32) (maxValue * jlimit (-1.0, 1.0, (double) newValue))); }
inline void setAsFloatBE (float newValue) noexcept { *data = ByteOrder::swapIfLittleEndian ((uint32) (maxValue * jlimit (-1.0, 1.0, (double) newValue))); }
inline void setAsFloatLE (float newValue) noexcept { *data = ByteOrder::swapIfBigEndian ((uint32) (int32) (maxValue * jlimit (-1.0, 1.0, (double) newValue))); }
inline void setAsFloatBE (float newValue) noexcept { *data = ByteOrder::swapIfLittleEndian ((uint32) (int32) (maxValue * jlimit (-1.0, 1.0, (double) newValue))); }
inline int32 getAsInt32LE() const noexcept { return (int32) ByteOrder::swapIfBigEndian (*data); }
inline int32 getAsInt32BE() const noexcept { return (int32) ByteOrder::swapIfLittleEndian (*data); }
inline void setAsInt32LE (int32 newValue) noexcept { *data = ByteOrder::swapIfBigEndian ((uint32) newValue); }


+ 2
- 0
source/modules/juce_audio_basics/buffers/juce_FloatVectorOperations.cpp View File

@@ -1066,6 +1066,8 @@ public:
ValueType* const data2 = buffer2;
int* const int1 = buffer3;
#else
// These tests deliberately operate on misaligned memory and will be flagged up by
// checks for undefined behavior!
ValueType* const data1 = addBytesToPointer (buffer1.getData(), random.nextInt (16));
ValueType* const data2 = addBytesToPointer (buffer2.getData(), random.nextInt (16));
int* const int1 = addBytesToPointer (buffer3.getData(), random.nextInt (16));


+ 32
- 10
source/modules/juce_audio_formats/codecs/juce_WavAudioFormat.cpp View File

@@ -154,7 +154,7 @@ const char* const WavAudioFormat::tracktionLoopInfo = "tracktion loop info";
//==============================================================================
namespace WavFileHelpers
{
inline int chunkName (const char* const name) noexcept { return (int) ByteOrder::littleEndianInt (name); }
inline int chunkName (const char* const name) noexcept { return (int) ByteOrder::littleEndianInt (name[0], name[1], name[2], name[3]); }
inline size_t roundUpSize (size_t sz) noexcept { return (sz + 3) & ~3u; }
#if JUCE_MSVC
@@ -1017,15 +1017,7 @@ public:
input->skipNextBytes (4); // skip over size and bitsPerSample
auto channelMask = input->readInt();
metadataValues.set ("ChannelMask", String (channelMask));
// AudioChannelSet and wav's dwChannelMask are compatible
BigInteger channelBits (channelMask);
for (auto bit = channelBits.findNextSetBit (0); bit >= 0; bit = channelBits.findNextSetBit (bit + 1))
channelLayout.addChannel (static_cast<AudioChannelSet::ChannelType> (bit + 1));
// channel layout and number of channels do not match
jassert (channelLayout.size() == static_cast<int> (numChannels));
channelLayout = getChannelLayoutFromMask (channelMask, numChannels);
ExtensibleWavSubFormat subFormat;
subFormat.data1 = (uint32) input->readInt();
@@ -1230,6 +1222,7 @@ public:
}
}
//==============================================================================
AudioChannelSet getChannelLayout() override
{
if (channelLayout.size() == static_cast<int> (numChannels))
@@ -1238,6 +1231,35 @@ public:
return WavFileHelpers::canonicalWavChannelSet (static_cast<int> (numChannels));
}
static AudioChannelSet getChannelLayoutFromMask (int dwChannelMask, size_t totalNumChannels)
{
AudioChannelSet wavFileChannelLayout;
// AudioChannelSet and wav's dwChannelMask are compatible
BigInteger channelBits (dwChannelMask);
for (auto bit = channelBits.findNextSetBit (0); bit >= 0; bit = channelBits.findNextSetBit (bit + 1))
wavFileChannelLayout.addChannel (static_cast<AudioChannelSet::ChannelType> (bit + 1));
// channel layout and number of channels do not match
if (wavFileChannelLayout.size() != static_cast<int> (totalNumChannels))
{
// for backward compatibility with old wav files, assume 1 or 2
// channel wav files are mono/stereo respectively
if (totalNumChannels <= 2 && dwChannelMask == 0)
wavFileChannelLayout = AudioChannelSet::canonicalChannelSet (static_cast<int> (totalNumChannels));
else
{
auto discreteSpeaker = static_cast<int> (AudioChannelSet::discreteChannel0);
while (wavFileChannelLayout.size() < static_cast<int> (totalNumChannels))
wavFileChannelLayout.addChannel (static_cast<AudioChannelSet::ChannelType> (discreteSpeaker++));
}
}
return wavFileChannelLayout;
}
int64 bwavChunkStart = 0, bwavSize = 0;
int64 dataChunkStart = 0, dataLength = 0;
int bytesPerFrame = 0;


+ 5
- 3
source/modules/juce_audio_processors/format_types/juce_AudioUnitPluginFormat.mm View File

@@ -55,6 +55,8 @@
#include <CoreAudioKit/AUViewController.h>
#endif
#include <unordered_map>
namespace juce
{
@@ -1265,7 +1267,7 @@ private:
};
OwnedArray<ParamInfo> parameters;
std::unordered_map<AudioUnitParameterID, int> paramIDToIndex;
std::unordered_map<AudioUnitParameterID, size_t> paramIDToIndex;
MidiDataConcatenator midiConcatenator;
CriticalSection midiInLock;
@@ -1351,10 +1353,10 @@ private:
|| event.mEventType == kAudioUnitEvent_BeginParameterChangeGesture
|| event.mEventType == kAudioUnitEvent_EndParameterChangeGesture)
{
auto it = paramIDToIndex.find (event.mArgument.mParameter.mParameterID)
auto it = paramIDToIndex.find (event.mArgument.mParameter.mParameterID);
if (it != paramIDToIndex.end())
paramIndex = it->second;
paramIndex = (int) it->second;
if (! isPositiveAndBelow (paramIndex, parameters.size()))
return;


+ 1
- 0
source/modules/juce_core/juce_core.cpp View File

@@ -60,6 +60,7 @@
#if JUCE_MINGW
#include <ws2spi.h>
_locale_t _create_locale(int, const char*) { _locale_t loc; juce::zeromem(&loc, sizeof(loc)); return loc; }
#endif
#else


+ 2
- 2
source/modules/juce_core/maths/juce_Random.cpp View File

@@ -64,7 +64,7 @@ Random& Random::getSystemRandom() noexcept
//==============================================================================
int Random::nextInt() noexcept
{
seed = (seed * 0x5deece66dLL + 11) & 0xffffffffffffLL;
seed = (int64) (((((uint64) seed) * 0x5deece66dLL) + 11) & 0xffffffffffffLL);
return (int) (seed >> 16);
}
@@ -82,7 +82,7 @@ int Random::nextInt (Range<int> range) noexcept
int64 Random::nextInt64() noexcept
{
return (((int64) nextInt()) << 32) | (int64) (uint64) (uint32) nextInt();
return (int64) ((((uint64) (unsigned int) nextInt()) << 32) | (uint64) (unsigned int) nextInt());
}
bool Random::nextBool() noexcept


+ 67
- 61
source/modules/juce_core/memory/juce_ByteOrder.h View File

@@ -32,7 +32,7 @@ class JUCE_API ByteOrder
public:
//==============================================================================
/** Swaps the upper and lower bytes of a 16-bit integer. */
static uint16 swap (uint16 value) noexcept;
JUCE_CONSTEXPR static uint16 swap (uint16 value) noexcept;
/** Reverses the order of the 4 bytes in a 32-bit integer. */
static uint32 swap (uint32 value) noexcept;
@@ -42,7 +42,7 @@ public:
//==============================================================================
/** Swaps the byte order of a 16-bit unsigned int if the CPU is big-endian */
static uint16 swapIfBigEndian (uint16 value) noexcept;
JUCE_CONSTEXPR static uint16 swapIfBigEndian (uint16 value) noexcept;
/** Swaps the byte order of a 32-bit unsigned int if the CPU is big-endian */
static uint32 swapIfBigEndian (uint32 value) noexcept;
@@ -51,7 +51,7 @@ public:
static uint64 swapIfBigEndian (uint64 value) noexcept;
/** Swaps the byte order of a 16-bit signed int if the CPU is big-endian */
static int16 swapIfBigEndian (int16 value) noexcept;
JUCE_CONSTEXPR static int16 swapIfBigEndian (int16 value) noexcept;
/** Swaps the byte order of a 32-bit signed int if the CPU is big-endian */
static int32 swapIfBigEndian (int32 value) noexcept;
@@ -66,7 +66,7 @@ public:
static double swapIfBigEndian (double value) noexcept;
/** Swaps the byte order of a 16-bit unsigned int if the CPU is little-endian */
static uint16 swapIfLittleEndian (uint16 value) noexcept;
JUCE_CONSTEXPR static uint16 swapIfLittleEndian (uint16 value) noexcept;
/** Swaps the byte order of a 32-bit unsigned int if the CPU is little-endian */
static uint32 swapIfLittleEndian (uint32 value) noexcept;
@@ -75,7 +75,7 @@ public:
static uint64 swapIfLittleEndian (uint64 value) noexcept;
/** Swaps the byte order of a 16-bit signed int if the CPU is little-endian */
static int16 swapIfLittleEndian (int16 value) noexcept;
JUCE_CONSTEXPR static int16 swapIfLittleEndian (int16 value) noexcept;
/** Swaps the byte order of a 32-bit signed int if the CPU is little-endian */
static int32 swapIfLittleEndian (int32 value) noexcept;
@@ -93,6 +93,9 @@ public:
/** Turns 4 bytes into a little-endian integer. */
static uint32 littleEndianInt (const void* bytes) noexcept;
/** Turns 4 characters into a little-endian integer. */
JUCE_CONSTEXPR static uint32 littleEndianInt (char c1, char c2, char c3, char c4) noexcept;
/** Turns 8 bytes into a little-endian integer. */
static uint64 littleEndianInt64 (const void* bytes) noexcept;
@@ -123,7 +126,7 @@ public:
//==============================================================================
/** Returns true if the current CPU is big-endian. */
static bool isBigEndian() noexcept;
JUCE_CONSTEXPR static bool isBigEndian() noexcept;
private:
ByteOrder() JUCE_DELETED_FUNCTION;
@@ -137,7 +140,7 @@ private:
#pragma intrinsic (_byteswap_ulong)
#endif
inline uint16 ByteOrder::swap (uint16 n) noexcept
JUCE_CONSTEXPR inline uint16 ByteOrder::swap (uint16 n) noexcept
{
return static_cast<uint16> ((n << 8) | (n >> 8));
}
@@ -170,60 +173,63 @@ inline uint64 ByteOrder::swap (uint64 value) noexcept
}
#if JUCE_LITTLE_ENDIAN
inline uint16 ByteOrder::swapIfBigEndian (const uint16 v) noexcept { return v; }
inline uint32 ByteOrder::swapIfBigEndian (const uint32 v) noexcept { return v; }
inline uint64 ByteOrder::swapIfBigEndian (const uint64 v) noexcept { return v; }
inline int16 ByteOrder::swapIfBigEndian (const int16 v) noexcept { return v; }
inline int32 ByteOrder::swapIfBigEndian (const int32 v) noexcept { return v; }
inline int64 ByteOrder::swapIfBigEndian (const int64 v) noexcept { return v; }
inline float ByteOrder::swapIfBigEndian (const float v) noexcept { return v; }
inline double ByteOrder::swapIfBigEndian (const double v) noexcept { return v; }
inline uint16 ByteOrder::swapIfLittleEndian (const uint16 v) noexcept { return swap (v); }
inline uint32 ByteOrder::swapIfLittleEndian (const uint32 v) noexcept { return swap (v); }
inline uint64 ByteOrder::swapIfLittleEndian (const uint64 v) noexcept { return swap (v); }
inline int16 ByteOrder::swapIfLittleEndian (const int16 v) noexcept { return static_cast<int16> (swap (static_cast<uint16> (v))); }
inline int32 ByteOrder::swapIfLittleEndian (const int32 v) noexcept { return static_cast<int32> (swap (static_cast<uint32> (v))); }
inline int64 ByteOrder::swapIfLittleEndian (const int64 v) noexcept { return static_cast<int64> (swap (static_cast<uint64> (v))); }
inline float ByteOrder::swapIfLittleEndian (const float v) noexcept { union { uint32 asUInt; float asFloat; } n; n.asFloat = v; n.asUInt = ByteOrder::swap (n.asUInt); return n.asFloat; }
inline double ByteOrder::swapIfLittleEndian (const double v) noexcept { union { uint64 asUInt; double asFloat; } n; n.asFloat = v; n.asUInt = ByteOrder::swap (n.asUInt); return n.asFloat; }
inline uint32 ByteOrder::littleEndianInt (const void* const bytes) noexcept { return *static_cast<const uint32*> (bytes); }
inline uint64 ByteOrder::littleEndianInt64 (const void* const bytes) noexcept { return *static_cast<const uint64*> (bytes); }
inline uint16 ByteOrder::littleEndianShort (const void* const bytes) noexcept { return *static_cast<const uint16*> (bytes); }
inline uint32 ByteOrder::bigEndianInt (const void* const bytes) noexcept { return swap (*static_cast<const uint32*> (bytes)); }
inline uint64 ByteOrder::bigEndianInt64 (const void* const bytes) noexcept { return swap (*static_cast<const uint64*> (bytes)); }
inline uint16 ByteOrder::bigEndianShort (const void* const bytes) noexcept { return swap (*static_cast<const uint16*> (bytes)); }
inline bool ByteOrder::isBigEndian() noexcept { return false; }
JUCE_CONSTEXPR inline uint16 ByteOrder::swapIfBigEndian (const uint16 v) noexcept { return v; }
inline uint32 ByteOrder::swapIfBigEndian (const uint32 v) noexcept { return v; }
inline uint64 ByteOrder::swapIfBigEndian (const uint64 v) noexcept { return v; }
JUCE_CONSTEXPR inline int16 ByteOrder::swapIfBigEndian (const int16 v) noexcept { return v; }
inline int32 ByteOrder::swapIfBigEndian (const int32 v) noexcept { return v; }
inline int64 ByteOrder::swapIfBigEndian (const int64 v) noexcept { return v; }
inline float ByteOrder::swapIfBigEndian (const float v) noexcept { return v; }
inline double ByteOrder::swapIfBigEndian (const double v) noexcept { return v; }
JUCE_CONSTEXPR inline uint16 ByteOrder::swapIfLittleEndian (const uint16 v) noexcept { return swap (v); }
inline uint32 ByteOrder::swapIfLittleEndian (const uint32 v) noexcept { return swap (v); }
inline uint64 ByteOrder::swapIfLittleEndian (const uint64 v) noexcept { return swap (v); }
JUCE_CONSTEXPR inline int16 ByteOrder::swapIfLittleEndian (const int16 v) noexcept { return static_cast<int16> (swap (static_cast<uint16> (v))); }
inline int32 ByteOrder::swapIfLittleEndian (const int32 v) noexcept { return static_cast<int32> (swap (static_cast<uint32> (v))); }
inline int64 ByteOrder::swapIfLittleEndian (const int64 v) noexcept { return static_cast<int64> (swap (static_cast<uint64> (v))); }
inline float ByteOrder::swapIfLittleEndian (const float v) noexcept { union { uint32 asUInt; float asFloat; } n; n.asFloat = v; n.asUInt = ByteOrder::swap (n.asUInt); return n.asFloat; }
inline double ByteOrder::swapIfLittleEndian (const double v) noexcept { union { uint64 asUInt; double asFloat; } n; n.asFloat = v; n.asUInt = ByteOrder::swap (n.asUInt); return n.asFloat; }
inline uint32 ByteOrder::littleEndianInt (const void* const bytes) noexcept { return *static_cast<const uint32*> (bytes); }
JUCE_CONSTEXPR inline uint32 ByteOrder::littleEndianInt (char c1, char c2, char c3, char c4) noexcept { return (((uint32) c4) << 24) + (((uint32) c3) << 16) + (((uint32) c2) << 8) + (uint32) c1; }
inline uint64 ByteOrder::littleEndianInt64 (const void* const bytes) noexcept { return *static_cast<const uint64*> (bytes); }
inline uint16 ByteOrder::littleEndianShort (const void* const bytes) noexcept { return *static_cast<const uint16*> (bytes); }
inline uint32 ByteOrder::bigEndianInt (const void* const bytes) noexcept { return swap (*static_cast<const uint32*> (bytes)); }
inline uint64 ByteOrder::bigEndianInt64 (const void* const bytes) noexcept { return swap (*static_cast<const uint64*> (bytes)); }
inline uint16 ByteOrder::bigEndianShort (const void* const bytes) noexcept { return swap (*static_cast<const uint16*> (bytes)); }
JUCE_CONSTEXPR inline bool ByteOrder::isBigEndian() noexcept { return false; }
#else
inline uint16 ByteOrder::swapIfBigEndian (const uint16 v) noexcept { return swap (v); }
inline uint32 ByteOrder::swapIfBigEndian (const uint32 v) noexcept { return swap (v); }
inline uint64 ByteOrder::swapIfBigEndian (const uint64 v) noexcept { return swap (v); }
inline int16 ByteOrder::swapIfBigEndian (const int16 v) noexcept { return static_cast<int16> (swap (static_cast<uint16> (v))); }
inline int32 ByteOrder::swapIfBigEndian (const int32 v) noexcept { return static_cast<int16> (swap (static_cast<uint16> (v))); }
inline int64 ByteOrder::swapIfBigEndian (const int64 v) noexcept { return static_cast<int16> (swap (static_cast<uint16> (v))); }
inline float ByteOrder::swapIfBigEndian (const float v) noexcept { union { uint32 asUInt; float asFloat; } n; n.asFloat = v; n.asUInt = ByteOrder::swap (n.asUInt); return n.asFloat; }
inline double ByteOrder::swapIfBigEndian (const double v) noexcept { union { uint64 asUInt; double asFloat; } n; n.asFloat = v; n.asUInt = ByteOrder::swap (n.asUInt); return n.asFloat; }
inline uint16 ByteOrder::swapIfLittleEndian (const uint16 v) noexcept { return v; }
inline uint32 ByteOrder::swapIfLittleEndian (const uint32 v) noexcept { return v; }
inline uint64 ByteOrder::swapIfLittleEndian (const uint64 v) noexcept { return v; }
inline int16 ByteOrder::swapIfLittleEndian (const int16 v) noexcept { return v; }
inline int32 ByteOrder::swapIfLittleEndian (const int32 v) noexcept { return v; }
inline int64 ByteOrder::swapIfLittleEndian (const int64 v) noexcept { return v; }
inline float ByteOrder::swapIfLittleEndian (const float v) noexcept { return v; }
inline double ByteOrder::swapIfLittleEndian (const double v) noexcept { return v; }
inline uint32 ByteOrder::littleEndianInt (const void* const bytes) noexcept { return swap (*static_cast<const uint32*> (bytes)); }
inline uint64 ByteOrder::littleEndianInt64 (const void* const bytes) noexcept { return swap (*static_cast<const uint64*> (bytes)); }
inline uint16 ByteOrder::littleEndianShort (const void* const bytes) noexcept { return swap (*static_cast<const uint16*> (bytes)); }
inline uint32 ByteOrder::bigEndianInt (const void* const bytes) noexcept { return *static_cast<const uint32*> (bytes); }
inline uint64 ByteOrder::bigEndianInt64 (const void* const bytes) noexcept { return *static_cast<const uint64*> (bytes); }
inline uint16 ByteOrder::bigEndianShort (const void* const bytes) noexcept { return *static_cast<const uint16*> (bytes); }
inline bool ByteOrder::isBigEndian() noexcept { return true; }
JUCE_CONSTEXPR inline uint16 ByteOrder::swapIfBigEndian (const uint16 v) noexcept { return swap (v); }
inline uint32 ByteOrder::swapIfBigEndian (const uint32 v) noexcept { return swap (v); }
inline uint64 ByteOrder::swapIfBigEndian (const uint64 v) noexcept { return swap (v); }
JUCE_CONSTEXPR inline int16 ByteOrder::swapIfBigEndian (const int16 v) noexcept { return static_cast<int16> (swap (static_cast<uint16> (v))); }
inline int32 ByteOrder::swapIfBigEndian (const int32 v) noexcept { return static_cast<int16> (swap (static_cast<uint16> (v))); }
inline int64 ByteOrder::swapIfBigEndian (const int64 v) noexcept { return static_cast<int16> (swap (static_cast<uint16> (v))); }
inline float ByteOrder::swapIfBigEndian (const float v) noexcept { union { uint32 asUInt; float asFloat; } n; n.asFloat = v; n.asUInt = ByteOrder::swap (n.asUInt); return n.asFloat; }
inline double ByteOrder::swapIfBigEndian (const double v) noexcept { union { uint64 asUInt; double asFloat; } n; n.asFloat = v; n.asUInt = ByteOrder::swap (n.asUInt); return n.asFloat; }
JUCE_CONSTEXPR inline uint16 ByteOrder::swapIfLittleEndian (const uint16 v) noexcept { return v; }
inline uint32 ByteOrder::swapIfLittleEndian (const uint32 v) noexcept { return v; }
inline uint64 ByteOrder::swapIfLittleEndian (const uint64 v) noexcept { return v; }
JUCE_CONSTEXPR inline int16 ByteOrder::swapIfLittleEndian (const int16 v) noexcept { return v; }
inline int32 ByteOrder::swapIfLittleEndian (const int32 v) noexcept { return v; }
inline int64 ByteOrder::swapIfLittleEndian (const int64 v) noexcept { return v; }
inline float ByteOrder::swapIfLittleEndian (const float v) noexcept { return v; }
inline double ByteOrder::swapIfLittleEndian (const double v) noexcept { return v; }
inline uint32 ByteOrder::littleEndianInt (const void* const bytes) noexcept { return swap (*static_cast<const uint32*> (bytes)); }
JUCE_CONSTEXPR inline uint32 ByteOrder::littleEndianInt (char c1, char c2, char c3, char c4) noexcept { return (((uint32) c1) << 24) + (((uint32) c2) << 16) + (((uint32) c3) << 8) + (uint32) c4; }
inline uint64 ByteOrder::littleEndianInt64 (const void* const bytes) noexcept { return swap (*static_cast<const uint64*> (bytes)); }
inline uint16 ByteOrder::littleEndianShort (const void* const bytes) noexcept { return swap (*static_cast<const uint16*> (bytes)); }
inline uint32 ByteOrder::bigEndianInt (const void* const bytes) noexcept { return *static_cast<const uint32*> (bytes); }
inline uint64 ByteOrder::bigEndianInt64 (const void* const bytes) noexcept { return *static_cast<const uint64*> (bytes); }
inline uint16 ByteOrder::bigEndianShort (const void* const bytes) noexcept { return *static_cast<const uint16*> (bytes); }
JUCE_CONSTEXPR inline bool ByteOrder::isBigEndian() noexcept { return true; }
#endif
inline int ByteOrder::littleEndian24Bit (const void* const bytes) noexcept { return (((int) static_cast<const int8*> (bytes)[2]) << 16) | (((int) static_cast<const uint8*> (bytes)[1]) << 8) | ((int) static_cast<const uint8*> (bytes)[0]); }
inline int ByteOrder::bigEndian24Bit (const void* const bytes) noexcept { return (((int) static_cast<const int8*> (bytes)[0]) << 16) | (((int) static_cast<const uint8*> (bytes)[1]) << 8) | ((int) static_cast<const uint8*> (bytes)[2]); }
inline void ByteOrder::littleEndian24BitToChars (const int value, void* const destBytes) noexcept { static_cast<uint8*> (destBytes)[0] = (uint8) value; static_cast<uint8*> (destBytes)[1] = (uint8) (value >> 8); static_cast<uint8*> (destBytes)[2] = (uint8) (value >> 16); }
inline void ByteOrder::bigEndian24BitToChars (const int value, void* const destBytes) noexcept { static_cast<uint8*> (destBytes)[0] = (uint8) (value >> 16); static_cast<uint8*> (destBytes)[1] = (uint8) (value >> 8); static_cast<uint8*> (destBytes)[2] = (uint8) value; }
inline int ByteOrder::littleEndian24Bit (const void* const bytes) noexcept { return (int) ((((unsigned int) static_cast<const int8*> (bytes)[2]) << 16) | (((unsigned int) static_cast<const uint8*> (bytes)[1]) << 8) | ((unsigned int) static_cast<const uint8*> (bytes)[0])); }
inline int ByteOrder::bigEndian24Bit (const void* const bytes) noexcept { return (int) ((((unsigned int) static_cast<const int8*> (bytes)[0]) << 16) | (((unsigned int) static_cast<const uint8*> (bytes)[1]) << 8) | ((unsigned int) static_cast<const uint8*> (bytes)[2])); }
inline void ByteOrder::littleEndian24BitToChars (const int value, void* const destBytes) noexcept { static_cast<uint8*> (destBytes)[0] = (uint8) value; static_cast<uint8*> (destBytes)[1] = (uint8) (value >> 8); static_cast<uint8*> (destBytes)[2] = (uint8) (value >> 16); }
inline void ByteOrder::bigEndian24BitToChars (const int value, void* const destBytes) noexcept { static_cast<uint8*> (destBytes)[0] = (uint8) (value >> 16); static_cast<uint8*> (destBytes)[1] = (uint8) (value >> 8); static_cast<uint8*> (destBytes)[2] = (uint8) value; }

+ 81
- 47
source/modules/juce_core/native/java/JuceAppActivity.java View File

@@ -949,36 +949,30 @@ public class JuceAppActivity extends Activity
public final boolean connect()
{
try
synchronized (createStreamLock)
{
if (hasBeenCancelled.get())
return false;
try
{
synchronized (createStreamLock)
try
{
if (hasBeenCancelled.get())
return false;
inputStream = getCancellableStream (true);
}
}
catch (ExecutionException e)
{
if (connection.getResponseCode() < 400)
catch (ExecutionException e)
{
if (connection.getResponseCode() < 400)
{
statusCode[0] = connection.getResponseCode();
connection.disconnect();
return false;
}
}
finally
{
statusCode[0] = connection.getResponseCode();
connection.disconnect();
return false;
}
}
finally
{
statusCode[0] = connection.getResponseCode();
}
synchronized (createStreamLock)
{
if (hasBeenCancelled.get())
return false;
try
{
@@ -989,49 +983,89 @@ public class JuceAppActivity extends Activity
}
catch (ExecutionException e)
{}
}
for (java.util.Map.Entry<String, java.util.List<String>> entry : connection.getHeaderFields().entrySet())
if (entry.getKey() != null && entry.getValue() != null)
responseHeaders.append (entry.getKey() + ": "
+ android.text.TextUtils.join (",", entry.getValue()) + "\n");
for (java.util.Map.Entry<String, java.util.List<String>> entry : connection.getHeaderFields().entrySet())
if (entry.getKey() != null && entry.getValue() != null)
responseHeaders.append (entry.getKey() + ": "
+ android.text.TextUtils.join (",", entry.getValue()) + "\n");
return true;
}
catch (IOException e)
{
return false;
return true;
}
catch (IOException e)
{
return false;
}
}
}
public final void release()
static class DisconnectionRunnable implements Runnable
{
hasBeenCancelled.set (true);
public DisconnectionRunnable (HttpURLConnection theConnection,
InputStream theInputStream,
ReentrantLock theCreateStreamLock,
Object theCreateFutureLock,
Future<BufferedInputStream> theStreamFuture)
{
connectionToDisconnect = theConnection;
inputStream = theInputStream;
createStreamLock = theCreateStreamLock;
createFutureLock = theCreateFutureLock;
streamFuture = theStreamFuture;
}
try
public void run()
{
if (! createStreamLock.tryLock())
try
{
synchronized (createFutureLock)
if (! createStreamLock.tryLock())
{
if (streamFuture != null)
streamFuture.cancel (true);
synchronized (createFutureLock)
{
if (streamFuture != null)
streamFuture.cancel (true);
}
createStreamLock.lock();
}
createStreamLock.lock();
}
if (connectionToDisconnect != null)
connectionToDisconnect.disconnect();
if (inputStream != null)
inputStream.close();
if (inputStream != null)
inputStream.close();
}
catch (IOException e)
{}
finally
{
createStreamLock.unlock();
}
}
catch (IOException e)
{}
finally
private HttpURLConnection connectionToDisconnect;
private InputStream inputStream;
private ReentrantLock createStreamLock;
private Object createFutureLock;
Future<BufferedInputStream> streamFuture;
}
public final void release()
{
DisconnectionRunnable disconnectionRunnable = new DisconnectionRunnable (connection,
inputStream,
createStreamLock,
createFutureLock,
streamFuture);
synchronized (createStreamLock)
{
createStreamLock.unlock();
hasBeenCancelled.set (true);
connection = null;
}
connection.disconnect();
Thread disconnectionThread = new Thread(disconnectionRunnable);
disconnectionThread.start();
}
public final int read (byte[] buffer, int numBytes)


+ 4
- 2
source/modules/juce_core/native/juce_android_Network.cpp View File

@@ -201,6 +201,8 @@ public:
{
jassert (buffer != nullptr && bytesToRead >= 0);
const ScopedLock lock (createStreamLock);
if (stream == nullptr)
return 0;
@@ -233,9 +235,9 @@ private:
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (Pimpl)
};
URL::DownloadTask* URL::downloadToFile (const File& targetLocation, String extraHeaders, DownloadTask::Listener* listener)
URL::DownloadTask* URL::downloadToFile (const File& targetLocation, String extraHeaders, DownloadTask::Listener* listener, bool shouldUsePost)
{
return URL::DownloadTask::createFallbackDownloader (*this, targetLocation, extraHeaders, listener);
return URL::DownloadTask::createFallbackDownloader (*this, targetLocation, extraHeaders, listener, shouldUsePost);
}
//==============================================================================


+ 2
- 2
source/modules/juce_core/native/juce_curl_Network.cpp View File

@@ -548,7 +548,7 @@ public:
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (Pimpl)
};
URL::DownloadTask* URL::downloadToFile (const File& targetLocation, String extraHeaders, DownloadTask::Listener* listener)
URL::DownloadTask* URL::downloadToFile (const File& targetLocation, String extraHeaders, DownloadTask::Listener* listener, bool shouldUsePost)
{
return URL::DownloadTask::createFallbackDownloader (*this, targetLocation, extraHeaders, listener);
return URL::DownloadTask::createFallbackDownloader (*this, targetLocation, extraHeaders, listener, shouldUsePost);
}

+ 2
- 2
source/modules/juce_core/native/juce_linux_Network.cpp View File

@@ -573,8 +573,8 @@ private:
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (Pimpl)
};
URL::DownloadTask* URL::downloadToFile (const File& targetLocation, String extraHeaders, DownloadTask::Listener* listener)
URL::DownloadTask* URL::downloadToFile (const File& targetLocation, String extraHeaders, DownloadTask::Listener* listener, bool shouldUsePost)
{
return URL::DownloadTask::createFallbackDownloader (*this, targetLocation, extraHeaders, listener);
return URL::DownloadTask::createFallbackDownloader (*this, targetLocation, extraHeaders, listener, shouldUsePost);
}
#endif

+ 11
- 7
source/modules/juce_core/native/juce_mac_Network.mm View File

@@ -406,7 +406,8 @@ struct BackgroundDownloadTask : public URL::DownloadTask
BackgroundDownloadTask (const URL& urlToUse,
const File& targetLocationToUse,
String extraHeadersToUse,
URL::DownloadTask::Listener* listenerToUse)
URL::DownloadTask::Listener* listenerToUse,
bool shouldUsePostRequest)
: targetLocation (targetLocationToUse), listener (listenerToUse),
uniqueIdentifier (String (urlToUse.toString (true).hashCode64()) + String (Random().nextInt64()))
{
@@ -419,6 +420,9 @@ struct BackgroundDownloadTask : public URL::DownloadTask
activeSessions.set (uniqueIdentifier, this);
NSMutableURLRequest* request = [[NSMutableURLRequest alloc] initWithURL:[NSURL URLWithString:juceStringToNS (urlToUse.toString (true))]];
if (shouldUsePostRequest)
[request setHTTPMethod: @"POST"];
StringArray headerLines;
headerLines.addLines (extraHeadersToUse);
headerLines.removeEmptyStrings (true);
@@ -633,9 +637,9 @@ struct BackgroundDownloadTask : public URL::DownloadTask
HashMap<String, BackgroundDownloadTask*, DefaultHashFunctions, CriticalSection> BackgroundDownloadTask::activeSessions;
URL::DownloadTask* URL::downloadToFile (const File& targetLocation, String extraHeaders, DownloadTask::Listener* listener)
URL::DownloadTask* URL::downloadToFile (const File& targetLocation, String extraHeaders, DownloadTask::Listener* listener, bool usePostRequest)
{
ScopedPointer<BackgroundDownloadTask> downloadTask = new BackgroundDownloadTask (*this, targetLocation, extraHeaders, listener);
ScopedPointer<BackgroundDownloadTask> downloadTask = new BackgroundDownloadTask (*this, targetLocation, extraHeaders, listener, usePostRequest);
if (downloadTask->initOK() && downloadTask->connect())
return downloadTask.release();
@@ -648,9 +652,9 @@ void URL::DownloadTask::juce_iosURLSessionNotify (const String& identifier)
BackgroundDownloadTask::invokeNotify (identifier);
}
#else
URL::DownloadTask* URL::downloadToFile (const File& targetLocation, String extraHeaders, DownloadTask::Listener* listener)
URL::DownloadTask* URL::downloadToFile (const File& targetLocation, String extraHeaders, DownloadTask::Listener* listener, bool usePost)
{
return URL::DownloadTask::createFallbackDownloader (*this, targetLocation, extraHeaders, listener);
return URL::DownloadTask::createFallbackDownloader (*this, targetLocation, extraHeaders, listener, usePost);
}
#endif
@@ -912,9 +916,9 @@ private:
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (URLConnectionState)
};
URL::DownloadTask* URL::downloadToFile (const File& targetLocation, String extraHeaders, DownloadTask::Listener* listener)
URL::DownloadTask* URL::downloadToFile (const File& targetLocation, String extraHeaders, DownloadTask::Listener* listener, bool shouldUsePost)
{
return URL::DownloadTask::createFallbackDownloader (*this, targetLocation, extraHeaders, listener);
return URL::DownloadTask::createFallbackDownloader (*this, targetLocation, extraHeaders, listener, shouldUsePost);
}
#pragma clang diagnostic pop


+ 1
- 1
source/modules/juce_core/native/juce_win32_Files.cpp View File

@@ -682,7 +682,7 @@ File File::getLinkedTarget() const
CloseHandle (h);
const StringRef prefix ("\\\\?\\");
const String path (buffer);
const String path (buffer.getData());
// It turns out that GetFinalPathNameByHandleW prepends \\?\ to the path.
// This is not a bug, it's feature. See MSDN for more information.


+ 2
- 2
source/modules/juce_core/native/juce_win32_Network.cpp View File

@@ -651,7 +651,7 @@ bool JUCE_CALLTYPE Process::openEmailWithAttachments (const String& targetEmailA
return mapiSendMail (0, 0, &message, MAPI_DIALOG | MAPI_LOGON_UI, 0) == SUCCESS_SUCCESS;
}
URL::DownloadTask* URL::downloadToFile (const File& targetLocation, String extraHeaders, DownloadTask::Listener* listener)
URL::DownloadTask* URL::downloadToFile (const File& targetLocation, String extraHeaders, DownloadTask::Listener* listener, bool shouldUsePost)
{
return URL::DownloadTask::createFallbackDownloader (*this, targetLocation, extraHeaders, listener);
return URL::DownloadTask::createFallbackDownloader (*this, targetLocation, extraHeaders, listener, shouldUsePost);
}

+ 3
- 2
source/modules/juce_core/network/juce_URL.cpp View File

@@ -106,14 +106,15 @@ URL::DownloadTask::Listener::~Listener() {}
URL::DownloadTask* URL::DownloadTask::createFallbackDownloader (const URL& urlToUse,
const File& targetFileToUse,
const String& extraHeadersToUse,
Listener* listenerToUse)
Listener* listenerToUse,
bool usePostRequest)
{
const size_t bufferSize = 0x8000;
targetFileToUse.deleteFile();
if (ScopedPointer<FileOutputStream> outputStream = targetFileToUse.createOutputStream (bufferSize))
{
ScopedPointer<WebInputStream> stream = new WebInputStream (urlToUse, false);
ScopedPointer<WebInputStream> stream = new WebInputStream (urlToUse, usePostRequest);
stream->withExtraHeaders (extraHeadersToUse);
if (stream->connect (nullptr))


+ 4
- 4
source/modules/juce_core/network/juce_URL.h View File

@@ -372,7 +372,7 @@ public:
private:
friend class URL;
static DownloadTask* createFallbackDownloader (const URL&, const File&, const String&, Listener*);
static DownloadTask* createFallbackDownloader (const URL&, const File&, const String&, Listener*, bool);
public:
#if JUCE_IOS
@@ -390,12 +390,12 @@ public:
Using this method to download files on mobile is less flexible but more reliable
than using createInputStream or WebInputStreams as it will attempt to download the file
using a native OS background network task. Such tasks automatically deal with
network re-connections and continuing your download while your app is suspended but are
limited to simple GET requests.
network re-connections and continuing your download while your app is suspended.
*/
DownloadTask* downloadToFile (const File& targetLocation,
String extraHeaders = String(),
DownloadTask::Listener* listener = nullptr);
DownloadTask::Listener* listener = nullptr,
bool usePostCommand = false);
//==============================================================================
/** Tries to download the entire contents of this URL into a binary data block.


+ 1
- 1
source/modules/juce_core/system/juce_StandardHeader.h View File

@@ -50,7 +50,6 @@
#include <functional>
#include <algorithm>
#include <limits>
#include <sstream>
//==============================================================================
#include "juce_CompilerSupport.h"
@@ -66,6 +65,7 @@
#if JUCE_MAC || JUCE_IOS
#include <libkern/OSAtomic.h>
#include <xlocale.h>
#endif
#if JUCE_LINUX


+ 2
- 4
source/modules/juce_core/text/juce_CharPointer_UTF8.h View File

@@ -470,12 +470,10 @@ public:
/** Parses this string as a 64-bit integer. */
int64 getIntValue64() const noexcept
{
#if JUCE_LINUX || JUCE_ANDROID || JUCE_MINGW
return atoll (data);
#elif JUCE_WINDOWS
#if JUCE_WINDOWS
return _atoi64 (data);
#else
return CharacterFunctions::getIntValue <int64, CharPointer_UTF8> (*this);
return atoll (data);
#endif
}


+ 16
- 14
source/modules/juce_core/text/juce_CharacterFunctions.h View File

@@ -218,17 +218,17 @@ public:
*currentCharacter++ = '0';
}
double result = 0;
const size_t stringSize = (size_t) (currentCharacter - &buffer[0]) + 1;
if (stringSize > 1)
{
std::istringstream is (std::string (&buffer[0], stringSize));
is.imbue (std::locale ("C"));
is >> result;
}
return result;
#if JUCE_WINDOWS
static _locale_t locale = _create_locale (LC_ALL, "C");
return _strtod_l (&buffer[0], nullptr, locale);
#else
static locale_t locale = newlocale (LC_ALL_MASK, "C", nullptr);
#if JUCE_ANDROID
return (double) strtold_l (&buffer[0], nullptr, locale);
#else
return strtod_l (&buffer[0], nullptr, locale);
#endif
#endif
}
/** Parses a character string, to read a floating-point value. */
@@ -243,7 +243,9 @@ public:
template <typename IntType, typename CharPointerType>
static IntType getIntValue (const CharPointerType text) noexcept
{
IntType v = 0;
typedef typename std::make_unsigned<IntType>::type UIntType;
UIntType v = 0;
auto s = text.findEndOfWhitespace();
const bool isNeg = *s == '-';
@@ -255,12 +257,12 @@ public:
auto c = s.getAndAdvance();
if (c >= '0' && c <= '9')
v = v * 10 + (IntType) (c - '0');
v = v * 10 + (UIntType) (c - '0');
else
break;
}
return isNeg ? -v : v;
return isNeg ? - (IntType) v : (IntType) v;
}
template <typename ResultType>


+ 1
- 1
source/modules/juce_core/text/juce_String.cpp View File

@@ -211,7 +211,7 @@ private:
{
// (Can't use offsetof() here because of warnings about this not being a POD)
return reinterpret_cast<StringHolder*> (reinterpret_cast<char*> (text.getAddress())
- (reinterpret_cast<size_t> (reinterpret_cast<StringHolder*> (1)->text) - 1));
- (reinterpret_cast<size_t> (reinterpret_cast<StringHolder*> (128)->text) - 128));
}
void compileTimeChecks()


+ 1
- 1
source/modules/juce_core/threads/juce_ThreadPool.cpp View File

@@ -193,7 +193,7 @@ void ThreadPool::moveJobToFront (const ThreadPoolJob* job) noexcept
{
const ScopedLock sl (lock);
if (! ! job->isActive)
if (! job->isActive)
{
auto index = jobs.indexOf (const_cast<ThreadPoolJob*> (job));


+ 9
- 4
source/modules/juce_core/zip/juce_ZipFile.cpp View File

@@ -263,18 +263,23 @@ const ZipFile::ZipEntry* ZipFile::getEntry (const int index) const noexcept
return nullptr;
}
int ZipFile::getIndexOfFileName (const String& fileName) const noexcept
int ZipFile::getIndexOfFileName (const String& fileName, bool ignoreCase) const noexcept
{
for (int i = 0; i < entries.size(); ++i)
if (entries.getUnchecked (i)->entry.filename == fileName)
{
auto& entryFilename = entries.getUnchecked (i)->entry.filename;
if (ignoreCase ? entryFilename.equalsIgnoreCase (fileName)
: entryFilename == fileName)
return i;
}
return -1;
}
const ZipFile::ZipEntry* ZipFile::getEntry (const String& fileName) const noexcept
const ZipFile::ZipEntry* ZipFile::getEntry (const String& fileName, bool ignoreCase) const noexcept
{
return getEntry (getIndexOfFileName (fileName));
return getEntry (getIndexOfFileName (fileName, ignoreCase));
}
InputStream* ZipFile::createStreamForEntry (const int index)


+ 2
- 2
source/modules/juce_core/zip/juce_ZipFile.h View File

@@ -95,7 +95,7 @@ public:
@see ZipFile::ZipEntry
*/
int getIndexOfFileName (const String& fileName) const noexcept;
int getIndexOfFileName (const String& fileName, bool ignoreCase = false) const noexcept;
/** Returns a structure that describes one of the entries in the zip file.
@@ -104,7 +104,7 @@ public:
@see ZipFile::ZipEntry
*/
const ZipEntry* getEntry (const String& fileName) const noexcept;
const ZipEntry* getEntry (const String& fileName, bool ignoreCase = false) const noexcept;
/** Sorts the list of entries, based on the filename. */
void sortEntriesByFilename();


+ 6
- 6
source/modules/juce_data_structures/app_properties/juce_PropertiesFile.cpp View File

@@ -26,13 +26,13 @@
namespace PropertyFileConstants
{
static const int magicNumber = (int) ByteOrder::littleEndianInt ("PROP");
static const int magicNumberCompressed = (int) ByteOrder::littleEndianInt ("CPRP");
JUCE_CONSTEXPR static const int magicNumber = (int) ByteOrder::littleEndianInt ('P', 'R', 'O', 'P');
JUCE_CONSTEXPR static const int magicNumberCompressed = (int) ByteOrder::littleEndianInt ('C', 'P', 'R', 'P');
static const char* const fileTag = "PROPERTIES";
static const char* const valueTag = "VALUE";
static const char* const nameAttribute = "name";
static const char* const valueAttribute = "val";
JUCE_CONSTEXPR static const char* const fileTag = "PROPERTIES";
JUCE_CONSTEXPR static const char* const valueTag = "VALUE";
JUCE_CONSTEXPR static const char* const nameAttribute = "name";
JUCE_CONSTEXPR static const char* const valueAttribute = "val";
}
//==============================================================================


+ 3
- 3
source/modules/juce_gui_basics/native/juce_win32_FileChooser.cpp View File

@@ -202,7 +202,7 @@ void FileChooser::showPlatformDialog (Array<File>& results, const String& title_
if (info.returnedString.isNotEmpty())
{
results.add (File (String (files)).getSiblingFile (info.returnedString));
results.add (File (String (files.getData())).getSiblingFile (info.returnedString));
return;
}
}
@@ -287,12 +287,12 @@ void FileChooser::showPlatformDialog (Array<File>& results, const String& title_
while (*filename != 0)
{
results.add (File (String (files)).getChildFile (String (filename)));
results.add (File (String (files.getData())).getChildFile (String (filename)));
filename += wcslen (filename) + 1;
}
}
else if (files[0] != 0)
{
results.add (File (String (files)));
results.add (File (String (files.getData())));
}
}

+ 1
- 1
source/modules/juce_gui_basics/native/juce_win32_Windowing.cpp View File

@@ -3440,7 +3440,7 @@ private:
HeapBlock<TCHAR> buffer;
buffer.calloc (stringSizeBytes / sizeof (TCHAR) + 1);
ImmGetCompositionString (hImc, type, buffer, (DWORD) stringSizeBytes);
return String (buffer);
return String (buffer.getData());
}
return {};


Write Preview
Loading…
Cancel
Save