Mouse cursor update fix. FLAC support for multiple channels. win32 scroll wheel tweak.

juce_amalgamated.cpp

@@ -42083,7 +42083,7 @@ const MouseCursor Component::getMouseCursor()
 
 void Component::updateMouseCursor() const
 {
-	sendFakeMouseMove();
+	Desktop::getInstance().getMainMouseSource().forceMouseCursorUpdate();
 }
 
 void Component::setRepaintsOnMouseActivity (const bool shouldRepaint) noexcept
@@ -86292,15 +86292,15 @@ protected:
 			switch (srcData.pixelFormat)
 			{
 			case Image::ARGB:
-				if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelARGB, true> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
+				if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelARGB, true>  r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
 				else		{ TransformedImageFillEdgeTableRenderer <PixelARGB, PixelARGB, false> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
 				break;
 			case Image::RGB:
-				if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelRGB, true> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
+				if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelRGB, true>  r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
 				else		{ TransformedImageFillEdgeTableRenderer <PixelARGB, PixelRGB, false> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
 				break;
 			default:
-				if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelAlpha, true> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
+				if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelAlpha, true>  r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
 				else		{ TransformedImageFillEdgeTableRenderer <PixelARGB, PixelAlpha, false> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
 				break;
 			}
@@ -86310,15 +86310,15 @@ protected:
 			switch (srcData.pixelFormat)
 			{
 			case Image::ARGB:
-				if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelARGB, true> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
+				if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelARGB, true>  r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
 				else		{ TransformedImageFillEdgeTableRenderer <PixelRGB, PixelARGB, false> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
 				break;
 			case Image::RGB:
-				if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelRGB, true> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
+				if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelRGB, true>  r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
 				else		{ TransformedImageFillEdgeTableRenderer <PixelRGB, PixelRGB, false> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
 				break;
 			default:
-				if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelAlpha, true> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
+				if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelAlpha, true>  r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
 				else		{ TransformedImageFillEdgeTableRenderer <PixelRGB, PixelAlpha, false> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
 				break;
 			}
@@ -86328,15 +86328,15 @@ protected:
 			switch (srcData.pixelFormat)
 			{
 			case Image::ARGB:
-				if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelARGB, true> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
+				if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelARGB, true>  r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
 				else		{ TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelARGB, false> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
 				break;
 			case Image::RGB:
-				if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelRGB, true> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
+				if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelRGB, true>  r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
 				else		{ TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelRGB, false> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
 				break;
 			default:
-				if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelAlpha, true> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
+				if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelAlpha, true>  r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
 				else		{ TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelAlpha, false> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
 				break;
 			}
@@ -86353,15 +86353,15 @@ protected:
 			switch (srcData.pixelFormat)
 			{
 			case Image::ARGB:
-				if (tiledFill)  { ImageFillEdgeTableRenderer <PixelARGB, PixelARGB, true> r (destData, srcData, alpha, x, y); iter.iterate (r); }
+				if (tiledFill)  { ImageFillEdgeTableRenderer <PixelARGB, PixelARGB, true>  r (destData, srcData, alpha, x, y); iter.iterate (r); }
 				else		{ ImageFillEdgeTableRenderer <PixelARGB, PixelARGB, false> r (destData, srcData, alpha, x, y); iter.iterate (r); }
 				break;
 			case Image::RGB:
-				if (tiledFill)  { ImageFillEdgeTableRenderer <PixelARGB, PixelRGB, true> r (destData, srcData, alpha, x, y); iter.iterate (r); }
+				if (tiledFill)  { ImageFillEdgeTableRenderer <PixelARGB, PixelRGB, true>  r (destData, srcData, alpha, x, y); iter.iterate (r); }
 				else		{ ImageFillEdgeTableRenderer <PixelARGB, PixelRGB, false> r (destData, srcData, alpha, x, y); iter.iterate (r); }
 				break;
 			default:
-				if (tiledFill)  { ImageFillEdgeTableRenderer <PixelARGB, PixelAlpha, true> r (destData, srcData, alpha, x, y); iter.iterate (r); }
+				if (tiledFill)  { ImageFillEdgeTableRenderer <PixelARGB, PixelAlpha, true>  r (destData, srcData, alpha, x, y); iter.iterate (r); }
 				else		{ ImageFillEdgeTableRenderer <PixelARGB, PixelAlpha, false> r (destData, srcData, alpha, x, y); iter.iterate (r); }
 				break;
 			}
@@ -86371,15 +86371,15 @@ protected:
 			switch (srcData.pixelFormat)
 			{
 			case Image::ARGB:
-				if (tiledFill)  { ImageFillEdgeTableRenderer <PixelRGB, PixelARGB, true> r (destData, srcData, alpha, x, y); iter.iterate (r); }
+				if (tiledFill)  { ImageFillEdgeTableRenderer <PixelRGB, PixelARGB, true>  r (destData, srcData, alpha, x, y); iter.iterate (r); }
 				else		{ ImageFillEdgeTableRenderer <PixelRGB, PixelARGB, false> r (destData, srcData, alpha, x, y); iter.iterate (r); }
 				break;
 			case Image::RGB:
-				if (tiledFill)  { ImageFillEdgeTableRenderer <PixelRGB, PixelRGB, true> r (destData, srcData, alpha, x, y); iter.iterate (r); }
+				if (tiledFill)  { ImageFillEdgeTableRenderer <PixelRGB, PixelRGB, true>  r (destData, srcData, alpha, x, y); iter.iterate (r); }
 				else		{ ImageFillEdgeTableRenderer <PixelRGB, PixelRGB, false> r (destData, srcData, alpha, x, y); iter.iterate (r); }
 				break;
 			default:
-				if (tiledFill)  { ImageFillEdgeTableRenderer <PixelRGB, PixelAlpha, true> r (destData, srcData, alpha, x, y); iter.iterate (r); }
+				if (tiledFill)  { ImageFillEdgeTableRenderer <PixelRGB, PixelAlpha, true>  r (destData, srcData, alpha, x, y); iter.iterate (r); }
 				else		{ ImageFillEdgeTableRenderer <PixelRGB, PixelAlpha, false> r (destData, srcData, alpha, x, y); iter.iterate (r); }
 				break;
 			}
@@ -86389,15 +86389,15 @@ protected:
 			switch (srcData.pixelFormat)
 			{
 			case Image::ARGB:
-				if (tiledFill)  { ImageFillEdgeTableRenderer <PixelAlpha, PixelARGB, true> r (destData, srcData, alpha, x, y); iter.iterate (r); }
-				else		{ ImageFillEdgeTableRenderer <PixelAlpha, PixelARGB, false> r (destData, srcData, alpha, x, y); iter.iterate (r); }
+				if (tiledFill)  { ImageFillEdgeTableRenderer <PixelAlpha, PixelARGB, true>   r (destData, srcData, alpha, x, y); iter.iterate (r); }
+				else		{ ImageFillEdgeTableRenderer <PixelAlpha, PixelARGB, false>  r (destData, srcData, alpha, x, y); iter.iterate (r); }
 				break;
 			case Image::RGB:
-				if (tiledFill)  { ImageFillEdgeTableRenderer <PixelAlpha, PixelRGB, true> r (destData, srcData, alpha, x, y); iter.iterate (r); }
-				else		{ ImageFillEdgeTableRenderer <PixelAlpha, PixelRGB, false> r (destData, srcData, alpha, x, y); iter.iterate (r); }
+				if (tiledFill)  { ImageFillEdgeTableRenderer <PixelAlpha, PixelRGB, true>	r (destData, srcData, alpha, x, y); iter.iterate (r); }
+				else		{ ImageFillEdgeTableRenderer <PixelAlpha, PixelRGB, false>   r (destData, srcData, alpha, x, y); iter.iterate (r); }
 				break;
 			default:
-				if (tiledFill)  { ImageFillEdgeTableRenderer <PixelAlpha, PixelAlpha, true> r (destData, srcData, alpha, x, y); iter.iterate (r); }
+				if (tiledFill)  { ImageFillEdgeTableRenderer <PixelAlpha, PixelAlpha, true>  r (destData, srcData, alpha, x, y); iter.iterate (r); }
 				else		{ ImageFillEdgeTableRenderer <PixelAlpha, PixelAlpha, false> r (destData, srcData, alpha, x, y); iter.iterate (r); }
 				break;
 			}
@@ -86451,10 +86451,10 @@ protected:
 class ClipRegion_EdgeTable  : public ClipRegionBase
 {
 public:
-	ClipRegion_EdgeTable (const EdgeTable& e) : edgeTable (e) {}
-	ClipRegion_EdgeTable (const Rectangle<int>& r) : edgeTable (r) {}
+	ClipRegion_EdgeTable (const EdgeTable& e)	: edgeTable (e) {}
+	ClipRegion_EdgeTable (const Rectangle<int>& r)   : edgeTable (r) {}
 	ClipRegion_EdgeTable (const Rectangle<float>& r) : edgeTable (r) {}
-	ClipRegion_EdgeTable (const RectangleList& r) : edgeTable (r) {}
+	ClipRegion_EdgeTable (const RectangleList& r)	: edgeTable (r) {}
 	ClipRegion_EdgeTable (const Rectangle<int>& bounds, const Path& p, const AffineTransform& t) : edgeTable (bounds, p, t) {}
 	ClipRegion_EdgeTable (const ClipRegion_EdgeTable& other) : edgeTable (other.edgeTable) {}
 
@@ -86658,7 +86658,7 @@ class ClipRegion_RectangleList  : public ClipRegionBase
 {
 public:
 	ClipRegion_RectangleList (const Rectangle<int>& r) : clip (r) {}
-	ClipRegion_RectangleList (const RectangleList& r) : clip (r) {}
+	ClipRegion_RectangleList (const RectangleList& r)  : clip (r) {}
 	ClipRegion_RectangleList (const ClipRegion_RectangleList& other) : clip (other.clip) {}
 
 	const Ptr clone() const
@@ -107583,6 +107583,8 @@ END_JUCE_NAMESPACE
  #include <windows.h>
 #endif
 
+BEGIN_JUCE_NAMESPACE
+
 namespace FlacNamespace
 {
 #if JUCE_INCLUDE_FLAC_CODE
@@ -130364,8 +130366,6 @@ void FLAC__window_welch(FLAC__real *window, const FLAC__int32 L)
 #undef max
 #undef min
 
-BEGIN_JUCE_NAMESPACE
-
 static const char* const flacFormatName = "FLAC file";
 static const char* const flacExtensions[] = { ".flac", 0 };
 
@@ -130609,7 +130609,7 @@ public:
 		FLAC__stream_encoder_set_channels (encoder, numChannels);
 		FLAC__stream_encoder_set_bits_per_sample (encoder, jmin ((unsigned int) 24, bitsPerSample));
 		FLAC__stream_encoder_set_sample_rate (encoder, (unsigned int) sampleRate);
-		FLAC__stream_encoder_set_blocksize (encoder, 2048);
+		FLAC__stream_encoder_set_blocksize (encoder, 0);
 		FLAC__stream_encoder_set_do_escape_coding (encoder, true);
 
 		ok = FLAC__stream_encoder_init_stream (encoder,
@@ -130640,25 +130640,28 @@ public:
 		if (! ok)
 			return false;
 
-		int* buf[3];
+		HeapBlock<int*> channels;
 		HeapBlock<int> temp;
 		const int bitsToShift = 32 - bitsPerSample;
 
 		if (bitsToShift > 0)
 		{
-			const int numChannelsToWrite = (samplesToWrite[1] == 0) ? 1 : 2;
-			temp.malloc (numSamples * numChannelsToWrite);
+			temp.malloc (numSamples * numChannels);
+			channels.calloc (numChannels + 1);
 
-			buf[0] = temp.getData();
-			buf[1] = temp.getData() + numSamples;
-			buf[2] = 0;
+			for (unsigned int i = 0; i < numChannels; ++i)
+			{
+				if (samplesToWrite[i] == nullptr)
+					break;
 
-			for (int i = numChannelsToWrite; --i >= 0;)
-				if (samplesToWrite[i] != nullptr)
-					for (int j = 0; j < numSamples; ++j)
-						buf [i][j] = (samplesToWrite [i][j] >> bitsToShift);
+				int* const destData = temp.getData() + i * numSamples;
+				channels[i] = destData;
+
+				for (int j = 0; j < numSamples; ++j)
+					destData[j] = (samplesToWrite[i][j] >> bitsToShift);
+			}
 
-			samplesToWrite = const_cast<const int**> (buf);
+			samplesToWrite = const_cast<const int**> (channels.getData());
 		}
 
 		return FLAC__stream_encoder_process (encoder, (const FLAC__int32**) samplesToWrite, numSamples) != 0;
@@ -130671,12 +130674,11 @@ public:
 
 	static void packUint32 (FlacNamespace::FLAC__uint32 val, FlacNamespace::FLAC__byte* b, const int bytes)
 	{
-		using namespace FlacNamespace;
 		b += bytes;
 
 		for (int i = 0; i < bytes; ++i)
 		{
-			*(--b) = (FLAC__byte) (val & 0xff);
+			*(--b) = (FlacNamespace::FLAC__byte) (val & 0xff);
 			val >>= 8;
 		}
 	}
@@ -130828,10 +130830,12 @@ END_JUCE_NAMESPACE
 /*** Start of inlined file: juce_OggVorbisAudioFormat.cpp ***/
 #if JUCE_USE_OGGVORBIS
 
-#if JUCE_MAC
-  #define __MACOSX__ 1
+#if JUCE_MAC && ! defined (__MACOSX__)
+ #define __MACOSX__ 1
 #endif
 
+BEGIN_JUCE_NAMESPACE
+
 namespace OggVorbisNamespace
 {
 #if JUCE_INCLUDE_OGGVORBIS_CODE
@@ -193711,8 +193715,6 @@ void _vorbis_apply_window(float *d,int *winno,long *blocksizes,
 #undef max
 #undef min
 
-BEGIN_JUCE_NAMESPACE
-
 static const char* const oggFormatName = "Ogg-Vorbis file";
 static const char* const oggExtensions[] = { ".ogg", 0 };
 
@@ -247871,18 +247873,22 @@ public:
 
 		if (transparent)
 		{
-			POINT p, pos;
-			SIZE size;
+			if (! maskedRegion.isEmpty())
+			{
+				for (RectangleList::Iterator i (maskedRegion); i.next();)
+				{
+					const Rectangle<int>& r = *i.getRectangle();
+					ExcludeClipRect (hdc, r.getX(), r.getY(), r.getRight(), r.getBottom());
+				}
+			}
 
 			RECT windowBounds;
 			GetWindowRect (hwnd, &windowBounds);
 
-			p.x = -x;
-			p.y = -y;
-			pos.x = windowBounds.left;
-			pos.y = windowBounds.top;
-			size.cx = windowBounds.right - windowBounds.left;
-			size.cy = windowBounds.bottom - windowBounds.top;
+			POINT p = { -x, -y };
+			POINT pos = { windowBounds.left, windowBounds.top };
+			SIZE size = { windowBounds.right - windowBounds.left,
+						  windowBounds.bottom - windowBounds.top };
 
 			BLENDFUNCTION bf;
 			bf.AlphaFormat = AC_SRC_ALPHA;
@@ -247890,15 +247896,6 @@ public:
 			bf.BlendOp = AC_SRC_OVER;
 			bf.SourceConstantAlpha = updateLayeredWindowAlpha;
 
-			if (! maskedRegion.isEmpty())
-			{
-				for (RectangleList::Iterator i (maskedRegion); i.next();)
-				{
-					const Rectangle<int>& r = *i.getRectangle();
-					ExcludeClipRect (hdc, r.getX(), r.getY(), r.getRight(), r.getBottom());
-				}
-			}
-
 			updateLayeredWindow (hwnd, 0, &pos, &size, hdc, &p, 0, &bf, ULW_ALPHA);
 		}
 		else
@@ -248326,9 +248323,8 @@ public:
 		RECT r;
 		GetWindowRect (hwnd, &r);
 
-		POINT p;
-		p.x = position.getX() + r.left + windowBorder.getLeft();
-		p.y = position.getY() + r.top + windowBorder.getTop();
+		POINT p = { position.getX() + r.left + windowBorder.getLeft(),
+					position.getY() + r.top  + windowBorder.getTop() };
 
 		HWND w = WindowFromPoint (p);
 		return w == hwnd || (trueIfInAChildWindow && (IsChild (hwnd, w) != 0));
@@ -249121,15 +249117,22 @@ private:
 		doMouseEvent (getCurrentMousePos());
 	}
 
-	void doMouseWheel (const Point<int>& position, const WPARAM wParam, const bool isVertical)
+	void doMouseWheel (const Point<int>& globalPos, const WPARAM wParam, const bool isVertical)
 	{
 		updateKeyModifiers();
-
 		const float amount = jlimit (-1000.0f, 1000.0f, 0.75f * (short) HIWORD (wParam));
 
-		handleMouseWheel (0, position, getMouseEventTime(),
-						  isVertical ? 0.0f : amount,
-						  isVertical ? amount : 0.0f);
+		// Because win32 stupidly sends all wheel events to the window with the keyboard
+		// focus, we have to redirect them here according to the mouse pos..
+		POINT p = { globalPos.getX(), globalPos.getY() };
+		Win32ComponentPeer* peer = getOwnerOfWindow (WindowFromPoint (p));
+
+		if (peer == nullptr)
+			peer = this;
+
+		peer->handleMouseWheel (0, peer->globalToLocal (globalPos), getMouseEventTime(),
+								isVertical ? 0.0f : amount,
+								isVertical ? amount : 0.0f);
 	}
 
 	void sendModifierKeyChangeIfNeeded()
@@ -249589,14 +249592,16 @@ private:
 		return Point<int> (GET_X_LPARAM (lParam), GET_Y_LPARAM (lParam));
 	}
 
-	const Point<int> getCurrentMousePos() noexcept
+	static const Point<int> getCurrentMousePosGlobal() noexcept
 	{
-		RECT wr;
-		GetWindowRect (hwnd, &wr);
 		const DWORD mp = GetMessagePos();
+		return Point<int> (GET_X_LPARAM (mp),
+						   GET_Y_LPARAM (mp));
+	}
 
-		return Point<int> (GET_X_LPARAM (mp) - wr.left - windowBorder.getLeft(),
-						   GET_Y_LPARAM (mp) - wr.top - windowBorder.getTop());
+	const Point<int> getCurrentMousePos() noexcept
+	{
+		return globalToLocal (getCurrentMousePosGlobal());
 	}
 
 	LRESULT peerWindowProc (HWND h, UINT message, WPARAM wParam, LPARAM lParam)
@@ -249664,7 +249669,7 @@ private:
 
 			case 0x020A: /* WM_MOUSEWHEEL */
 			case 0x020E: /* WM_MOUSEHWHEEL */
-				doMouseWheel (getCurrentMousePos(), wParam, message == 0x020A);
+				doMouseWheel (getCurrentMousePosGlobal(), wParam, message == 0x020A);
 				return 0;
 
 			case WM_SIZING:

juce_amalgamated.h

@@ -73,7 +73,7 @@ namespace JuceDummyNamespace {}
 */
 #define JUCE_MAJOR_VERSION	  1
 #define JUCE_MINOR_VERSION	  53
-#define JUCE_BUILDNUMBER	95
+#define JUCE_BUILDNUMBER	96
 
 /** Current Juce version number.
 
@@ -37110,25 +37110,25 @@ private:
 
 	Array<int> trackStartSamples;
 
-#if JUCE_MAC
+   #if JUCE_MAC
 	File volumeDir;
 	Array<File> tracks;
 	int currentReaderTrack;
 	ScopedPointer <AudioFormatReader> reader;
 	AudioCDReader (const File& volume);
 
-#elif JUCE_WINDOWS
+   #elif JUCE_WINDOWS
 	bool audioTracks [100];
 	void* handle;
+	MemoryBlock buffer;
 	bool indexingEnabled;
 	int lastIndex, firstFrameInBuffer, samplesInBuffer;
-	MemoryBlock buffer;
 	AudioCDReader (void* handle);
 	int getIndexAt (int samplePos);
 
-#elif JUCE_LINUX
+   #elif JUCE_LINUX
 	AudioCDReader();
-#endif
+   #endif
 
 	JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AudioCDReader);
 };

src/audio/audio_file_formats/juce_AudioCDReader.h

@@ -32,8 +32,9 @@
 #include "../../containers/juce_Array.h"
 #include "../../memory/juce_ScopedPointer.h"
 #include "../../text/juce_StringArray.h"
+#include "../../memory/juce_MemoryBlock.h"
 #if JUCE_MAC
-#include "../../io/files/juce_File.h"
+ #include "../../io/files/juce_File.h"
 #endif
 
 //==============================================================================
@@ -163,25 +164,25 @@ private:
     //==============================================================================
     Array<int> trackStartSamples;
 
-#if JUCE_MAC
+   #if JUCE_MAC
     File volumeDir;
     Array<File> tracks;
     int currentReaderTrack;
     ScopedPointer <AudioFormatReader> reader;
     AudioCDReader (const File& volume);
 
-#elif JUCE_WINDOWS
+   #elif JUCE_WINDOWS
     bool audioTracks [100];
     void* handle;
+    MemoryBlock buffer;
     bool indexingEnabled;
     int lastIndex, firstFrameInBuffer, samplesInBuffer;
-    MemoryBlock buffer;
     AudioCDReader (void* handle);
     int getIndexAt (int samplePos);
 
-#elif JUCE_LINUX
+   #elif JUCE_LINUX
     AudioCDReader();
-#endif
+   #endif
 
     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (AudioCDReader);
 };

src/audio/audio_file_formats/juce_FlacAudioFormat.cpp

@@ -34,6 +34,8 @@
 
 #include "../../core/juce_StandardHeader.h"
 
+BEGIN_JUCE_NAMESPACE
+
 namespace FlacNamespace
 {
 #if JUCE_INCLUDE_FLAC_CODE
@@ -72,8 +74,6 @@ namespace FlacNamespace
 #undef max
 #undef min
 
-BEGIN_JUCE_NAMESPACE
-
 #include "juce_FlacAudioFormat.h"
 #include "../../text/juce_LocalisedStrings.h"
 #include "../../memory/juce_ScopedPointer.h"
@@ -328,7 +328,7 @@ public:
         FLAC__stream_encoder_set_channels (encoder, numChannels);
         FLAC__stream_encoder_set_bits_per_sample (encoder, jmin ((unsigned int) 24, bitsPerSample));
         FLAC__stream_encoder_set_sample_rate (encoder, (unsigned int) sampleRate);
-        FLAC__stream_encoder_set_blocksize (encoder, 2048);
+        FLAC__stream_encoder_set_blocksize (encoder, 0);
         FLAC__stream_encoder_set_do_escape_coding (encoder, true);
 
         ok = FLAC__stream_encoder_init_stream (encoder,
@@ -360,25 +360,28 @@ public:
         if (! ok)
             return false;
 
-        int* buf[3];
+        HeapBlock<int*> channels;
         HeapBlock<int> temp;
         const int bitsToShift = 32 - bitsPerSample;
 
         if (bitsToShift > 0)
         {
-            const int numChannelsToWrite = (samplesToWrite[1] == 0) ? 1 : 2;
-            temp.malloc (numSamples * numChannelsToWrite);
+            temp.malloc (numSamples * numChannels);
+            channels.calloc (numChannels + 1);
+
+            for (unsigned int i = 0; i < numChannels; ++i)
+            {
+                if (samplesToWrite[i] == nullptr)
+                    break;
 
-            buf[0] = temp.getData();
-            buf[1] = temp.getData() + numSamples;
-            buf[2] = 0;
+                int* const destData = temp.getData() + i * numSamples;
+                channels[i] = destData;
 
-            for (int i = numChannelsToWrite; --i >= 0;)
-                if (samplesToWrite[i] != nullptr)
-                    for (int j = 0; j < numSamples; ++j)
-                        buf [i][j] = (samplesToWrite [i][j] >> bitsToShift);
+                for (int j = 0; j < numSamples; ++j)
+                    destData[j] = (samplesToWrite[i][j] >> bitsToShift);
+            }
 
-            samplesToWrite = const_cast<const int**> (buf);
+            samplesToWrite = const_cast<const int**> (channels.getData());
         }
 
         return FLAC__stream_encoder_process (encoder, (const FLAC__int32**) samplesToWrite, numSamples) != 0;
@@ -391,12 +394,11 @@ public:
 
     static void packUint32 (FlacNamespace::FLAC__uint32 val, FlacNamespace::FLAC__byte* b, const int bytes)
     {
-        using namespace FlacNamespace;
         b += bytes;
 
         for (int i = 0; i < bytes; ++i)
         {
-            *(--b) = (FLAC__byte) (val & 0xff);
+            *(--b) = (FlacNamespace::FLAC__byte) (val & 0xff);
             val >>= 8;
         }
     }

src/audio/audio_file_formats/juce_OggVorbisAudioFormat.cpp

@@ -30,10 +30,11 @@
 
 #include "../../core/juce_StandardHeader.h"
 
-#if JUCE_MAC
-  #define __MACOSX__ 1
+#if JUCE_MAC && ! defined (__MACOSX__)
+ #define __MACOSX__ 1
 #endif
 
+BEGIN_JUCE_NAMESPACE
 
 namespace OggVorbisNamespace
 {
@@ -75,8 +76,6 @@ namespace OggVorbisNamespace
 #undef max
 #undef min
 
-BEGIN_JUCE_NAMESPACE
-
 #include "juce_OggVorbisAudioFormat.h"
 #include "../../application/juce_Application.h"
 #include "../../maths/juce_Random.h"

src/core/juce_StandardHeader.h

@@ -33,7 +33,7 @@
 */
 #define JUCE_MAJOR_VERSION      1
 #define JUCE_MINOR_VERSION      53
-#define JUCE_BUILDNUMBER        95
+#define JUCE_BUILDNUMBER        96
 
 /** Current Juce version number.
 

src/gui/components/juce_Component.cpp

@@ -1693,7 +1693,7 @@ const MouseCursor Component::getMouseCursor()
 
 void Component::updateMouseCursor() const
 {
-    sendFakeMouseMove();
+    Desktop::getInstance().getMainMouseSource().forceMouseCursorUpdate();
 }
 
 //==============================================================================

src/gui/graphics/contexts/juce_LowLevelGraphicsSoftwareRenderer.cpp

@@ -1059,15 +1059,15 @@ protected:
             switch (srcData.pixelFormat)
             {
             case Image::ARGB:
-                if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelARGB, true> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
+                if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelARGB, true>  r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
                 else            { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelARGB, false> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
                 break;
             case Image::RGB:
-                if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelRGB, true> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
+                if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelRGB, true>  r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
                 else            { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelRGB, false> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
                 break;
             default:
-                if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelAlpha, true> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
+                if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelAlpha, true>  r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
                 else            { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelAlpha, false> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
                 break;
             }
@@ -1077,15 +1077,15 @@ protected:
             switch (srcData.pixelFormat)
             {
             case Image::ARGB:
-                if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelARGB, true> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
+                if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelARGB, true>  r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
                 else            { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelARGB, false> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
                 break;
             case Image::RGB:
-                if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelRGB, true> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
+                if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelRGB, true>  r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
                 else            { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelRGB, false> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
                 break;
             default:
-                if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelAlpha, true> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
+                if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelAlpha, true>  r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
                 else            { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelAlpha, false> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
                 break;
             }
@@ -1095,15 +1095,15 @@ protected:
             switch (srcData.pixelFormat)
             {
             case Image::ARGB:
-                if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelARGB, true> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
+                if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelARGB, true>  r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
                 else            { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelARGB, false> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
                 break;
             case Image::RGB:
-                if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelRGB, true> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
+                if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelRGB, true>  r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
                 else            { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelRGB, false> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
                 break;
             default:
-                if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelAlpha, true> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
+                if (tiledFill)  { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelAlpha, true>  r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
                 else            { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelAlpha, false> r (destData, srcData, transform, alpha, betterQuality); iter.iterate (r); }
                 break;
             }
@@ -1120,15 +1120,15 @@ protected:
             switch (srcData.pixelFormat)
             {
             case Image::ARGB:
-                if (tiledFill)  { ImageFillEdgeTableRenderer <PixelARGB, PixelARGB, true> r (destData, srcData, alpha, x, y); iter.iterate (r); }
+                if (tiledFill)  { ImageFillEdgeTableRenderer <PixelARGB, PixelARGB, true>  r (destData, srcData, alpha, x, y); iter.iterate (r); }
                 else            { ImageFillEdgeTableRenderer <PixelARGB, PixelARGB, false> r (destData, srcData, alpha, x, y); iter.iterate (r); }
                 break;
             case Image::RGB:
-                if (tiledFill)  { ImageFillEdgeTableRenderer <PixelARGB, PixelRGB, true> r (destData, srcData, alpha, x, y); iter.iterate (r); }
+                if (tiledFill)  { ImageFillEdgeTableRenderer <PixelARGB, PixelRGB, true>  r (destData, srcData, alpha, x, y); iter.iterate (r); }
                 else            { ImageFillEdgeTableRenderer <PixelARGB, PixelRGB, false> r (destData, srcData, alpha, x, y); iter.iterate (r); }
                 break;
             default:
-                if (tiledFill)  { ImageFillEdgeTableRenderer <PixelARGB, PixelAlpha, true> r (destData, srcData, alpha, x, y); iter.iterate (r); }
+                if (tiledFill)  { ImageFillEdgeTableRenderer <PixelARGB, PixelAlpha, true>  r (destData, srcData, alpha, x, y); iter.iterate (r); }
                 else            { ImageFillEdgeTableRenderer <PixelARGB, PixelAlpha, false> r (destData, srcData, alpha, x, y); iter.iterate (r); }
                 break;
             }
@@ -1138,15 +1138,15 @@ protected:
             switch (srcData.pixelFormat)
             {
             case Image::ARGB:
-                if (tiledFill)  { ImageFillEdgeTableRenderer <PixelRGB, PixelARGB, true> r (destData, srcData, alpha, x, y); iter.iterate (r); }
+                if (tiledFill)  { ImageFillEdgeTableRenderer <PixelRGB, PixelARGB, true>  r (destData, srcData, alpha, x, y); iter.iterate (r); }
                 else            { ImageFillEdgeTableRenderer <PixelRGB, PixelARGB, false> r (destData, srcData, alpha, x, y); iter.iterate (r); }
                 break;
             case Image::RGB:
-                if (tiledFill)  { ImageFillEdgeTableRenderer <PixelRGB, PixelRGB, true> r (destData, srcData, alpha, x, y); iter.iterate (r); }
+                if (tiledFill)  { ImageFillEdgeTableRenderer <PixelRGB, PixelRGB, true>  r (destData, srcData, alpha, x, y); iter.iterate (r); }
                 else            { ImageFillEdgeTableRenderer <PixelRGB, PixelRGB, false> r (destData, srcData, alpha, x, y); iter.iterate (r); }
                 break;
             default:
-                if (tiledFill)  { ImageFillEdgeTableRenderer <PixelRGB, PixelAlpha, true> r (destData, srcData, alpha, x, y); iter.iterate (r); }
+                if (tiledFill)  { ImageFillEdgeTableRenderer <PixelRGB, PixelAlpha, true>  r (destData, srcData, alpha, x, y); iter.iterate (r); }
                 else            { ImageFillEdgeTableRenderer <PixelRGB, PixelAlpha, false> r (destData, srcData, alpha, x, y); iter.iterate (r); }
                 break;
             }
@@ -1156,15 +1156,15 @@ protected:
             switch (srcData.pixelFormat)
             {
             case Image::ARGB:
-                if (tiledFill)  { ImageFillEdgeTableRenderer <PixelAlpha, PixelARGB, true> r (destData, srcData, alpha, x, y); iter.iterate (r); }
-                else            { ImageFillEdgeTableRenderer <PixelAlpha, PixelARGB, false> r (destData, srcData, alpha, x, y); iter.iterate (r); }
+                if (tiledFill)  { ImageFillEdgeTableRenderer <PixelAlpha, PixelARGB, true>   r (destData, srcData, alpha, x, y); iter.iterate (r); }
+                else            { ImageFillEdgeTableRenderer <PixelAlpha, PixelARGB, false>  r (destData, srcData, alpha, x, y); iter.iterate (r); }
                 break;
             case Image::RGB:
-                if (tiledFill)  { ImageFillEdgeTableRenderer <PixelAlpha, PixelRGB, true> r (destData, srcData, alpha, x, y); iter.iterate (r); }
-                else            { ImageFillEdgeTableRenderer <PixelAlpha, PixelRGB, false> r (destData, srcData, alpha, x, y); iter.iterate (r); }
+                if (tiledFill)  { ImageFillEdgeTableRenderer <PixelAlpha, PixelRGB, true>    r (destData, srcData, alpha, x, y); iter.iterate (r); }
+                else            { ImageFillEdgeTableRenderer <PixelAlpha, PixelRGB, false>   r (destData, srcData, alpha, x, y); iter.iterate (r); }
                 break;
             default:
-                if (tiledFill)  { ImageFillEdgeTableRenderer <PixelAlpha, PixelAlpha, true> r (destData, srcData, alpha, x, y); iter.iterate (r); }
+                if (tiledFill)  { ImageFillEdgeTableRenderer <PixelAlpha, PixelAlpha, true>  r (destData, srcData, alpha, x, y); iter.iterate (r); }
                 else            { ImageFillEdgeTableRenderer <PixelAlpha, PixelAlpha, false> r (destData, srcData, alpha, x, y); iter.iterate (r); }
                 break;
             }
@@ -1219,10 +1219,10 @@ protected:
 class ClipRegion_EdgeTable  : public ClipRegionBase
 {
 public:
-    ClipRegion_EdgeTable (const EdgeTable& e) : edgeTable (e) {}
-    ClipRegion_EdgeTable (const Rectangle<int>& r) : edgeTable (r) {}
+    ClipRegion_EdgeTable (const EdgeTable& e)        : edgeTable (e) {}
+    ClipRegion_EdgeTable (const Rectangle<int>& r)   : edgeTable (r) {}
     ClipRegion_EdgeTable (const Rectangle<float>& r) : edgeTable (r) {}
-    ClipRegion_EdgeTable (const RectangleList& r) : edgeTable (r) {}
+    ClipRegion_EdgeTable (const RectangleList& r)    : edgeTable (r) {}
     ClipRegion_EdgeTable (const Rectangle<int>& bounds, const Path& p, const AffineTransform& t) : edgeTable (bounds, p, t) {}
     ClipRegion_EdgeTable (const ClipRegion_EdgeTable& other) : edgeTable (other.edgeTable) {}
 
@@ -1428,7 +1428,7 @@ class ClipRegion_RectangleList  : public ClipRegionBase
 {
 public:
     ClipRegion_RectangleList (const Rectangle<int>& r) : clip (r) {}
-    ClipRegion_RectangleList (const RectangleList& r) : clip (r) {}
+    ClipRegion_RectangleList (const RectangleList& r)  : clip (r) {}
     ClipRegion_RectangleList (const ClipRegion_RectangleList& other) : clip (other.clip) {}
 
     const Ptr clone() const

src/native/windows/juce_win32_Windowing.cpp

@@ -247,18 +247,22 @@ public:
 
         if (transparent)
         {
-            POINT p, pos;
-            SIZE size;
+            if (! maskedRegion.isEmpty())
+            {
+                for (RectangleList::Iterator i (maskedRegion); i.next();)
+                {
+                    const Rectangle<int>& r = *i.getRectangle();
+                    ExcludeClipRect (hdc, r.getX(), r.getY(), r.getRight(), r.getBottom());
+                }
+            }
 
             RECT windowBounds;
             GetWindowRect (hwnd, &windowBounds);
 
-            p.x = -x;
-            p.y = -y;
-            pos.x = windowBounds.left;
-            pos.y = windowBounds.top;
-            size.cx = windowBounds.right - windowBounds.left;
-            size.cy = windowBounds.bottom - windowBounds.top;
+            POINT p = { -x, -y };
+            POINT pos = { windowBounds.left, windowBounds.top };
+            SIZE size = { windowBounds.right - windowBounds.left,
+                          windowBounds.bottom - windowBounds.top };
 
             BLENDFUNCTION bf;
             bf.AlphaFormat = AC_SRC_ALPHA;
@@ -266,15 +270,6 @@ public:
             bf.BlendOp = AC_SRC_OVER;
             bf.SourceConstantAlpha = updateLayeredWindowAlpha;
 
-            if (! maskedRegion.isEmpty())
-            {
-                for (RectangleList::Iterator i (maskedRegion); i.next();)
-                {
-                    const Rectangle<int>& r = *i.getRectangle();
-                    ExcludeClipRect (hdc, r.getX(), r.getY(), r.getRight(), r.getBottom());
-                }
-            }
-
             updateLayeredWindow (hwnd, 0, &pos, &size, hdc, &p, 0, &bf, ULW_ALPHA);
         }
         else
@@ -708,9 +703,8 @@ public:
         RECT r;
         GetWindowRect (hwnd, &r);
 
-        POINT p;
-        p.x = position.getX() + r.left + windowBorder.getLeft();
-        p.y = position.getY() + r.top + windowBorder.getTop();
+        POINT p = { position.getX() + r.left + windowBorder.getLeft(),
+                    position.getY() + r.top  + windowBorder.getTop() };
 
         HWND w = WindowFromPoint (p);
         return w == hwnd || (trueIfInAChildWindow && (IsChild (hwnd, w) != 0));
@@ -1514,15 +1508,22 @@ private:
         doMouseEvent (getCurrentMousePos());
     }
 
-    void doMouseWheel (const Point<int>& position, const WPARAM wParam, const bool isVertical)
+    void doMouseWheel (const Point<int>& globalPos, const WPARAM wParam, const bool isVertical)
     {
         updateKeyModifiers();
-
         const float amount = jlimit (-1000.0f, 1000.0f, 0.75f * (short) HIWORD (wParam));
 
-        handleMouseWheel (0, position, getMouseEventTime(),
-                          isVertical ? 0.0f : amount,
-                          isVertical ? amount : 0.0f);
+        // Because win32 stupidly sends all wheel events to the window with the keyboard
+        // focus, we have to redirect them here according to the mouse pos..
+        POINT p = { globalPos.getX(), globalPos.getY() };
+        Win32ComponentPeer* peer = getOwnerOfWindow (WindowFromPoint (p));
+
+        if (peer == nullptr)
+            peer = this;
+
+        peer->handleMouseWheel (0, peer->globalToLocal (globalPos), getMouseEventTime(),
+                                isVertical ? 0.0f : amount,
+                                isVertical ? amount : 0.0f);
     }
 
     //==============================================================================
@@ -1985,14 +1986,16 @@ private:
         return Point<int> (GET_X_LPARAM (lParam), GET_Y_LPARAM (lParam));
     }
 
-    const Point<int> getCurrentMousePos() noexcept
+    static const Point<int> getCurrentMousePosGlobal() noexcept
     {
-        RECT wr;
-        GetWindowRect (hwnd, &wr);
         const DWORD mp = GetMessagePos();
+        return Point<int> (GET_X_LPARAM (mp),
+                           GET_Y_LPARAM (mp));
+    }
 
-        return Point<int> (GET_X_LPARAM (mp) - wr.left - windowBorder.getLeft(),
-                           GET_Y_LPARAM (mp) - wr.top - windowBorder.getTop());
+    const Point<int> getCurrentMousePos() noexcept
+    {
+        return globalToLocal (getCurrentMousePosGlobal());
     }
 
     LRESULT peerWindowProc (HWND h, UINT message, WPARAM wParam, LPARAM lParam)
@@ -2062,7 +2065,7 @@ private:
 
             case 0x020A: /* WM_MOUSEWHEEL */
             case 0x020E: /* WM_MOUSEHWHEEL */
-                doMouseWheel (getCurrentMousePos(), wParam, message == 0x020A);
+                doMouseWheel (getCurrentMousePosGlobal(), wParam, message == 0x020A);
                 return 0;
 
             //==============================================================================