Changes for VC6 comptibility. Fixed a typo in BitArray::toString.

juce_amalgamated.cpp

@@ -3002,7 +3002,7 @@ const String BitArray::toString (const int base, const int minimumNumCharacters)
     const int length = s.length();
 
     if (length < minimumNumCharacters)
-        s = String::repeatedString (T("0"), minimumNumCharacters - length);
+        s = String::repeatedString (T("0"), minimumNumCharacters - length) + s;
 
     return isNegative() ? T("-") + s : s;
 }
@@ -3839,12 +3839,12 @@ var::operator int() const throw()
 {
     switch (type)
     {
-        case voidType:
-        case objectType:    break;
+        case voidType:      break;
         case intType:       return value.intValue;
         case boolType:      return value.boolValue ? 1 : 0;
         case doubleType:    return (int) value.doubleValue;
         case stringType:    return value.stringValue->getIntValue();
+        case objectType:    break;
         default:            jassertfalse; break;
     }
 
@@ -3856,13 +3856,13 @@ var::operator bool() const throw()
     switch (type)
     {
         case voidType:      break;
-        case objectType:    return value.objectValue != 0;
         case intType:       return value.intValue != 0;
         case boolType:      return value.boolValue;
         case doubleType:    return value.doubleValue != 0;
         case stringType:    return value.stringValue->getIntValue() != 0
                                     || value.stringValue->trim().equalsIgnoreCase (T("true"))
                                     || value.stringValue->trim().equalsIgnoreCase (T("yes"));
+        case objectType:    return value.objectValue != 0;
         default:            jassertfalse; break;
     }
 
@@ -3873,12 +3873,12 @@ var::operator double() const throw()
 {
     switch (type)
     {
-        case voidType:
-        case objectType:    break;
+        case voidType:      break;
         case intType:       return value.intValue;
         case boolType:      return value.boolValue ? 1.0 : 0.0;
         case doubleType:    return value.doubleValue;
         case stringType:    return value.stringValue->getDoubleValue();
+        case objectType:    break;
         default:            jassertfalse; break;
     }
 
@@ -3889,12 +3889,12 @@ const String var::toString() const throw()
 {
     switch (type)
     {
-        case voidType:
-        case objectType:    return "Object 0x" + String::toHexString ((int) (pointer_sized_int) value.objectValue);
+        case voidType:      return String::empty;
         case intType:       return String (value.intValue);
         case boolType:      return value.boolValue ? T("1") : T("0");
         case doubleType:    return String (value.doubleValue);
         case stringType:    return *(value.stringValue);
+        case objectType:    return "Object 0x" + String::toHexString ((int) (pointer_sized_int) value.objectValue);
         default:            jassertfalse; break;
     }
 
@@ -11327,11 +11327,6 @@ String& String::operator<< (const short number) throw()
     return *this;
 }
 
-String& String::operator<< (const unsigned short number) throw()
-{
-    return operator<< ((unsigned int) number);
-}
-
 String& String::operator<< (const long number) throw()
 {
     return operator<< ((int) number);
@@ -54749,7 +54744,10 @@ public:
 
     void mouseDrag (const MouseEvent& e)
     {
-        if (isEnabled() && ! (e.mouseWasClicked() || isDragging))
+        if (isEnabled()
+             && ! (isDragging || e.mouseWasClicked()
+                    || e.getDistanceFromDragStart() < 5
+                    || e.mods.isPopupMenu()))
         {
             isDragging = true;
 
@@ -55499,7 +55497,7 @@ TreeViewItem* TreeView::getInsertPosition (int& x, int& y, int& insertIndex,
     insertIndex = 0;
     TreeViewItem* item = getItemAt (y);
 
-    if (item == 0 || item->parentItem == 0)
+    if (item == 0)
         return 0;
 
     Rectangle itemPos (item->getItemPosition (true));
@@ -79035,7 +79033,8 @@ EdgeTable::EdgeTable (const Rectangle& bounds_,
 {
     table = (int*) juce_malloc ((bounds.getHeight() + 1) * lineStrideElements * sizeof (int));
     int* t = table;
-    for (int i = bounds.getHeight(); --i >= 0;)
+    int i = 0;
+    for (i = bounds.getHeight(); --i >= 0;)
     {
         *t = 0;
         t += lineStrideElements;
@@ -79100,7 +79099,7 @@ EdgeTable::EdgeTable (const Rectangle& bounds_,
     // Convert the table from relative windings to absolute levels..
     int* lineStart = table;
 
-    for (int i = bounds.getHeight(); --i >= 0;)
+    for (i = bounds.getHeight(); --i >= 0;)
     {
         int* line = lineStart;
         lineStart += lineStrideElements;
@@ -79555,12 +79554,13 @@ void EdgeTable::clipToEdgeTable (const EdgeTable& other)
         if (clipped.getRight() < bounds.getRight())
             bounds.setRight (clipped.getRight());
 
-        for (int i = top; --i >= 0;)
+        int i = 0;
+        for (i = top; --i >= 0;)
             table [lineStrideElements * i] = 0;
 
         const int* otherLine = other.table + other.lineStrideElements * (clipped.getY() - other.bounds.getY());
 
-        for (int i = top; i < bottom; ++i)
+        for (i = top; i < bottom; ++i)
         {
             intersectWithEdgeTableLine (i, otherLine);
             otherLine += other.lineStrideElements;
@@ -81960,9 +81960,9 @@ public:
 
             switch (image.getFormat())
             {
-                case Image::ARGB:   renderGradient <PixelARGB>  (et, destData, g2, transform, lookupTable, numLookupEntries, isIdentity); break;
-                case Image::RGB:    renderGradient <PixelRGB>   (et, destData, g2, transform, lookupTable, numLookupEntries, isIdentity); break;
-                default:            renderGradient <PixelAlpha> (et, destData, g2, transform, lookupTable, numLookupEntries, isIdentity); break;
+                case Image::ARGB:   renderGradient (et, destData, g2, transform, lookupTable, numLookupEntries, isIdentity, (PixelARGB*) 0); break;
+                case Image::RGB:    renderGradient (et, destData, g2, transform, lookupTable, numLookupEntries, isIdentity, (PixelRGB*) 0); break;
+                default:            renderGradient (et, destData, g2, transform, lookupTable, numLookupEntries, isIdentity, (PixelAlpha*) 0); break;
             }
 
             juce_free (lookupTable);
@@ -81977,9 +81977,9 @@ public:
 
             switch (image.getFormat())
             {
-                case Image::ARGB:   renderSolidFill2 <PixelARGB>  (et, destData, fillColour, replaceContents); break;
-                case Image::RGB:    renderSolidFill2 <PixelRGB>   (et, destData, fillColour, replaceContents); break;
-                default:            renderSolidFill2 <PixelAlpha> (et, destData, fillColour, replaceContents); break;
+                case Image::ARGB:   renderSolidFill (et, destData, fillColour, replaceContents, (PixelARGB*) 0); break;
+                case Image::RGB:    renderSolidFill (et, destData, fillColour, replaceContents, (PixelRGB*) 0); break;
+                default:            renderSolidFill (et, destData, fillColour, replaceContents, (PixelAlpha*) 0); break;
             }
         }
     }
@@ -82007,7 +82007,7 @@ public:
 
                 if (tiledFillClipRegion != 0)
                 {
-                    blittedRenderImage3 <true> (sourceImage, destImage, *tiledFillClipRegion, destData, srcData, alpha, tx, ty);
+                    blittedRenderImage (sourceImage, destImage, *tiledFillClipRegion, destData, srcData, alpha, tx, ty, true);
                 }
                 else
                 {
@@ -82015,7 +82015,7 @@ public:
                     et.clipToEdgeTable (edgeTable->edgeTable);
 
                     if (! et.isEmpty())
-                        blittedRenderImage3 <false> (sourceImage, destImage, et, destData, srcData, alpha, tx, ty);
+                        blittedRenderImage (sourceImage, destImage, et, destData, srcData, alpha, tx, ty, false);
                 }
 
                 return;
@@ -82027,7 +82027,7 @@ public:
 
         if (tiledFillClipRegion != 0)
         {
-            transformedRenderImage3 <true> (sourceImage, destImage, *tiledFillClipRegion, destData, srcData, alpha, transform, betterQuality);
+            transformedRenderImage (sourceImage, destImage, *tiledFillClipRegion, destData, srcData, alpha, transform, betterQuality, true);
         }
         else
         {
@@ -82038,7 +82038,7 @@ public:
             et.clipToEdgeTable (edgeTable->edgeTable);
 
             if (! et.isEmpty())
-                transformedRenderImage3 <false> (sourceImage, destImage, et, destData, srcData, alpha, transform, betterQuality);
+                transformedRenderImage (sourceImage, destImage, et, destData, srcData, alpha, transform, betterQuality, false);
         }
     }
 
@@ -82071,9 +82071,9 @@ public:
                 const int imageY = ((ty + 128) >> 8);
 
                 if (image.getFormat() == Image::ARGB)
-                    straightClipImage <PixelARGB> (et, srcData, imageX, imageY);
+                    straightClipImage (et, srcData, imageX, imageY, (PixelARGB*)0);
                 else
-                    straightClipImage <PixelAlpha> (et, srcData, imageX, imageY);
+                    straightClipImage (et, srcData, imageX, imageY, (PixelAlpha*)0);
 
                 return;
             }
@@ -82095,14 +82095,14 @@ public:
         if (! et.isEmpty())
         {
             if (image.getFormat() == Image::ARGB)
-                transformedClipImage <PixelARGB> (et, srcData, transform, betterQuality);
+                transformedClipImage (et, srcData, transform, betterQuality, (PixelARGB*)0);
             else
-                transformedClipImage <PixelAlpha> (et, srcData, transform, betterQuality);
+                transformedClipImage (et, srcData, transform, betterQuality, (PixelAlpha*)0);
         }
     }
 
     template <class SrcPixelType>
-    void transformedClipImage (EdgeTable& et, const Image::BitmapData& srcData, const AffineTransform& transform, const bool betterQuality) throw()
+    void transformedClipImage (EdgeTable& et, const Image::BitmapData& srcData, const AffineTransform& transform, const bool betterQuality, const SrcPixelType *) throw()
     {
         TransformedImageFillEdgeTableRenderer <SrcPixelType, SrcPixelType, false> renderer (srcData, srcData, transform, 255, betterQuality);
 
@@ -82112,7 +82112,7 @@ public:
     }
 
     template <class SrcPixelType>
-    void straightClipImage (EdgeTable& et, const Image::BitmapData& srcData, int imageX, int imageY) throw()
+    void straightClipImage (EdgeTable& et, const Image::BitmapData& srcData, int imageX, int imageY, const SrcPixelType *) throw()
     {
         Rectangle r (imageX, imageY, srcData.width, srcData.height);
         et.clipToRectangle (r);
@@ -82148,7 +82148,7 @@ private:
 
     template <class DestPixelType>
     void renderGradient (EdgeTable& et, const Image::BitmapData& destData, const ColourGradient& g, const AffineTransform& transform,
-                         const PixelARGB* const lookupTable, const int numLookupEntries, const bool isIdentity) throw()
+                         const PixelARGB* const lookupTable, const int numLookupEntries, const bool isIdentity, DestPixelType*) throw()
     {
         jassert (destData.pixelStride == sizeof (DestPixelType));
 
@@ -82172,84 +82172,137 @@ private:
         }
     }
 
-    template <class DestPixelType, bool replaceContents>
-    void renderSolidFill1 (EdgeTable& et, const Image::BitmapData& destData, const PixelARGB& fillColour) throw()
-    {
-        jassert (destData.pixelStride == sizeof (DestPixelType));
-        SolidColourEdgeTableRenderer <DestPixelType, replaceContents> renderer (destData, fillColour);
-        et.iterate (renderer);
-    }
-
     template <class DestPixelType>
-    void renderSolidFill2 (EdgeTable& et, const Image::BitmapData& destData, const PixelARGB& fillColour, const bool replaceContents) throw()
+    void renderSolidFill (EdgeTable& et, const Image::BitmapData& destData, const PixelARGB& fillColour, const bool replaceContents, DestPixelType*) throw()
     {
+        jassert (destData.pixelStride == sizeof (DestPixelType));
         if (replaceContents)
-            renderSolidFill1 <DestPixelType, true> (et, destData, fillColour);
-        else
-            renderSolidFill1 <DestPixelType, false> (et, destData, fillColour);
-    }
-
-    template <class SrcPixelType, class DestPixelType, bool repeatPattern>
-    void transformedRenderImage1 (const EdgeTable& et, const Image::BitmapData& destData, const Image::BitmapData& srcData,
-                                  const int alpha, const AffineTransform& transform, const bool betterQuality) throw()
-    {
-        TransformedImageFillEdgeTableRenderer <DestPixelType, SrcPixelType, repeatPattern> renderer (destData, srcData, transform, alpha, betterQuality);
-        et.iterate (renderer);
-    }
-
-    template <class SrcPixelType, bool repeatPattern>
-    void transformedRenderImage2 (Image& destImage, const EdgeTable& et, const Image::BitmapData& destData, const Image::BitmapData& srcData,
-                                  const int alpha, const AffineTransform& transform, const bool betterQuality) throw()
-    {
-        switch (destImage.getFormat())
         {
-            case Image::ARGB:   transformedRenderImage1 <SrcPixelType, PixelARGB, repeatPattern>  (et, destData, srcData, alpha, transform, betterQuality); break;
-            case Image::RGB:    transformedRenderImage1 <SrcPixelType, PixelRGB, repeatPattern>   (et, destData, srcData, alpha, transform, betterQuality); break;
-            default:            transformedRenderImage1 <SrcPixelType, PixelAlpha, repeatPattern> (et, destData, srcData, alpha, transform, betterQuality); break;
+            SolidColourEdgeTableRenderer <DestPixelType, true> r (destData, fillColour);
+            et.iterate (r);
         }
-    }
-
-    template <bool repeatPattern>
-    void transformedRenderImage3 (const Image& srcImage, Image& destImage, const EdgeTable& et, const Image::BitmapData& destData, const Image::BitmapData& srcData,
-                                  const int alpha, const AffineTransform& transform, const bool betterQuality) throw()
-    {
-        switch (srcImage.getFormat())
+        else
         {
-            case Image::ARGB:   transformedRenderImage2 <PixelARGB,  repeatPattern> (destImage, et, destData, srcData, alpha, transform, betterQuality); break;
-            case Image::RGB:    transformedRenderImage2 <PixelRGB,   repeatPattern> (destImage, et, destData, srcData, alpha, transform, betterQuality); break;
-            default:            transformedRenderImage2 <PixelAlpha, repeatPattern> (destImage, et, destData, srcData, alpha, transform, betterQuality); break;
+            SolidColourEdgeTableRenderer <DestPixelType, false> r (destData, fillColour);
+            et.iterate (r);
         }
     }
 
-    template <class SrcPixelType, class DestPixelType, bool repeatPattern>
-    void blittedRenderImage1 (const EdgeTable& et, const Image::BitmapData& destData, const Image::BitmapData& srcData,
-                              const int alpha, int x, int y) throw()
-    {
-        ImageFillEdgeTableRenderer <DestPixelType, SrcPixelType, repeatPattern> renderer (destData, srcData, alpha, x, y);
-        et.iterate (renderer);
-    }
-
-    template <class SrcPixelType, bool repeatPattern>
-    void blittedRenderImage2 (Image& destImage, const EdgeTable& et, const Image::BitmapData& destData,
-                              const Image::BitmapData& srcData, const int alpha, int x, int y) throw()
+    void transformedRenderImage (const Image& srcImage, Image& destImage, const EdgeTable& et, const Image::BitmapData& destData, const Image::BitmapData& srcData,
+                                 const int alpha, const AffineTransform& transform, const bool betterQuality, const bool repeatPattern) throw()
     {
         switch (destImage.getFormat())
         {
-            case Image::ARGB:   blittedRenderImage1 <SrcPixelType, PixelARGB,  repeatPattern> (et, destData, srcData, alpha, x, y); break;
-            case Image::RGB:    blittedRenderImage1 <SrcPixelType, PixelRGB,   repeatPattern> (et, destData, srcData, alpha, x, y); break;
-            default:            blittedRenderImage1 <SrcPixelType, PixelAlpha, repeatPattern> (et, destData, srcData, alpha, x, y); break;
+        case Image::ARGB:
+            switch (srcImage.getFormat())
+            {
+            case Image::ARGB:
+                if (repeatPattern) { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelARGB, true> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                else               { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelARGB, false> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                break;
+            case Image::RGB:
+                if (repeatPattern) { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelRGB, true> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                else               { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelRGB, false> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                break;
+            default:
+                if (repeatPattern) { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelAlpha, true> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                else               { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelAlpha, false> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                break;
+            }
+            break;
+        case Image::RGB:
+            switch (srcImage.getFormat())
+            {
+            case Image::ARGB:
+                if (repeatPattern) { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelARGB, true> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                else               { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelARGB, false> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                break;
+            case Image::RGB:
+                if (repeatPattern) { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelRGB, true> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                else               { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelRGB, false> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                break;
+            default:
+                if (repeatPattern) { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelAlpha, true> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                else               { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelAlpha, false> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                break;
+            }
+            break;
+        default:
+            switch (srcImage.getFormat())
+            {
+            case Image::ARGB:
+                if (repeatPattern) { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelARGB, true> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                else               { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelARGB, false> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                break;
+            case Image::RGB:
+                if (repeatPattern) { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelRGB, true> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                else               { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelRGB, false> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                break;
+            default:
+                if (repeatPattern) { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelAlpha, true> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                else               { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelAlpha, false> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                break;
+            }
+            break;
         }
     }
 
-    template <bool repeatPattern>
-    void blittedRenderImage3 (const Image& srcImage, Image& destImage, const EdgeTable& et, const Image::BitmapData& destData,
-                              const Image::BitmapData& srcData, const int alpha, int x, int y) throw()
+    void blittedRenderImage (const Image& srcImage, Image& destImage, const EdgeTable& et, const Image::BitmapData& destData,
+                             const Image::BitmapData& srcData, const int alpha, int x, int y, const bool repeatPattern) throw()
     {
-        switch (srcImage.getFormat())
+        switch (destImage.getFormat())
         {
-            case Image::ARGB:   blittedRenderImage2 <PixelARGB,  repeatPattern> (destImage, et, destData, srcData, alpha, x, y); break;
-            case Image::RGB:    blittedRenderImage2 <PixelRGB,   repeatPattern> (destImage, et, destData, srcData, alpha, x, y); break;
-            default:            blittedRenderImage2 <PixelAlpha, repeatPattern> (destImage, et, destData, srcData, alpha, x, y); break;
+            case Image::ARGB:
+                switch (srcImage.getFormat())
+                {
+                case Image::ARGB:
+                    if (repeatPattern) { ImageFillEdgeTableRenderer <PixelARGB, PixelARGB, true> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    else               { ImageFillEdgeTableRenderer <PixelARGB, PixelARGB, false> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    break;
+                case Image::RGB:
+                    if (repeatPattern) { ImageFillEdgeTableRenderer <PixelARGB, PixelRGB, true> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    else               { ImageFillEdgeTableRenderer <PixelARGB, PixelRGB, false> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    break;
+                default:
+                    if (repeatPattern) { ImageFillEdgeTableRenderer <PixelARGB, PixelAlpha, true> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    else               { ImageFillEdgeTableRenderer <PixelARGB, PixelAlpha, false> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    break;
+                }
+            break;
+            case Image::RGB:
+                switch (srcImage.getFormat())
+                {
+                case Image::ARGB:
+                    if (repeatPattern) { ImageFillEdgeTableRenderer <PixelRGB, PixelARGB, true> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    else               { ImageFillEdgeTableRenderer <PixelRGB, PixelARGB, false> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    break;
+                case Image::RGB:
+                    if (repeatPattern) { ImageFillEdgeTableRenderer <PixelRGB, PixelRGB, true> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    else               { ImageFillEdgeTableRenderer <PixelRGB, PixelRGB, false> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    break;
+                default:
+                    if (repeatPattern) { ImageFillEdgeTableRenderer <PixelRGB, PixelAlpha, true> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    else               { ImageFillEdgeTableRenderer <PixelRGB, PixelAlpha, false> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    break;
+                }
+            break;
+            default:
+                switch (srcImage.getFormat())
+                {
+                case Image::ARGB:
+                    if (repeatPattern) { ImageFillEdgeTableRenderer <PixelAlpha, PixelARGB, true> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    else               { ImageFillEdgeTableRenderer <PixelAlpha, PixelARGB, false> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    break;
+                case Image::RGB:
+                    if (repeatPattern) { ImageFillEdgeTableRenderer <PixelAlpha, PixelRGB, true> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    else               { ImageFillEdgeTableRenderer <PixelAlpha, PixelRGB, false> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    break;
+                default:
+                    if (repeatPattern) { ImageFillEdgeTableRenderer <PixelAlpha, PixelAlpha, true> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    else               { ImageFillEdgeTableRenderer <PixelAlpha, PixelAlpha, false> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    break;
+                }
+            break;
         }
     }
 };

juce_amalgamated.h

@@ -706,6 +706,7 @@
 #endif
 
 #if JUCE_MSVC
+  #include <malloc.h>
   #pragma warning (pop)
 #endif
 
@@ -1562,8 +1563,6 @@ public:
     /** Appends a decimal number at the end of this string. */
     String& operator<< (const short number) throw();
     /** Appends a decimal number at the end of this string. */
-    String& operator<< (const unsigned short number) throw();
-    /** Appends a decimal number at the end of this string. */
     String& operator<< (const int number) throw();
     /** Appends a decimal number at the end of this string. */
     String& operator<< (const unsigned int number) throw();
@@ -18827,6 +18826,7 @@ private:
 #endif
 
 class PixelRGB;
+class PixelAlpha;
 
 /**
     Represents a 32-bit ARGB pixel with premultiplied alpha, and can perform compositing
@@ -18864,8 +18864,7 @@ public:
         This takes into account the opacity of the pixel being overlaid, and blends
         it accordingly.
     */
-    template <class Pixel>
-    forcedinline void blend (const Pixel& src) throw()
+    forcedinline void blend (const PixelARGB& src) throw()
     {
         uint32 sargb = src.getARGB();
         const uint32 alpha = 0x100 - (sargb >> 24);
@@ -18876,6 +18875,13 @@ public:
         argb = sargb;
     }
 
+    /** Blends another pixel onto this one.
+
+        This takes into account the opacity of the pixel being overlaid, and blends
+        it accordingly.
+    */
+    forcedinline void blend (const PixelAlpha& src) throw();
+
     /** Blends another pixel onto this one.
 
         This takes into account the opacity of the pixel being overlaid, and blends
@@ -19104,11 +19110,7 @@ public:
         set (src);
     }
 
-    template <class Pixel>
-    forcedinline void blend (const Pixel& src) throw()
-    {
-        blend (PixelARGB (src.getARGB()));
-    }
+    forcedinline void blend (const PixelAlpha& src) throw();
 
     /** Blends another pixel onto this one, applying an extra multiplier to its opacity.
 
@@ -19330,6 +19332,22 @@ private:
     uint8 a : 8;
 } PACKED;
 
+forcedinline void PixelRGB::blend (const PixelAlpha& src) throw()
+{
+    blend (PixelARGB (src.getARGB()));
+}
+
+forcedinline void PixelARGB::blend (const PixelAlpha& src) throw()
+{
+    uint32 sargb = src.getARGB();
+    const uint32 alpha = 0x100 - (sargb >> 24);
+
+    sargb += 0x00ff00ff & ((getRB() * alpha) >> 8);
+    sargb += 0xff00ff00 & (getAG() * alpha);
+
+    argb = sargb;
+}
+
 #if JUCE_MSVC
   #pragma pack (pop)
 #endif

src/containers/juce_BitArray.cpp

@@ -875,7 +875,7 @@ const String BitArray::toString (const int base, const int minimumNumCharacters)
     const int length = s.length();
 
     if (length < minimumNumCharacters)
-        s = String::repeatedString (T("0"), minimumNumCharacters - length);
+        s = String::repeatedString (T("0"), minimumNumCharacters - length) + s;
 
     return isNegative() ? T("-") + s : s;
 }

src/containers/juce_Variant.cpp

@@ -207,12 +207,12 @@ var::operator int() const throw()
 {
     switch (type)
     {
-        case voidType:
-        case objectType:    break;
+        case voidType:      break;
         case intType:       return value.intValue;
         case boolType:      return value.boolValue ? 1 : 0;
         case doubleType:    return (int) value.doubleValue;
         case stringType:    return value.stringValue->getIntValue();
+        case objectType:    break;
         default:            jassertfalse; break;
     }
 
@@ -224,13 +224,13 @@ var::operator bool() const throw()
     switch (type)
     {
         case voidType:      break;
-        case objectType:    return value.objectValue != 0;
         case intType:       return value.intValue != 0;
         case boolType:      return value.boolValue;
         case doubleType:    return value.doubleValue != 0;
         case stringType:    return value.stringValue->getIntValue() != 0
                                     || value.stringValue->trim().equalsIgnoreCase (T("true"))
                                     || value.stringValue->trim().equalsIgnoreCase (T("yes"));
+        case objectType:    return value.objectValue != 0;
         default:            jassertfalse; break;
     }
 
@@ -241,12 +241,12 @@ var::operator double() const throw()
 {
     switch (type)
     {
-        case voidType:
-        case objectType:    break;
+        case voidType:      break;
         case intType:       return value.intValue;
         case boolType:      return value.boolValue ? 1.0 : 0.0;
         case doubleType:    return value.doubleValue;
         case stringType:    return value.stringValue->getDoubleValue();
+        case objectType:    break;
         default:            jassertfalse; break;
     }
 
@@ -257,12 +257,12 @@ const String var::toString() const throw()
 {
     switch (type)
     {
-        case voidType:
-        case objectType:    return "Object 0x" + String::toHexString ((int) (pointer_sized_int) value.objectValue);
+        case voidType:      return String::empty;
         case intType:       return String (value.intValue);
         case boolType:      return value.boolValue ? T("1") : T("0");
         case doubleType:    return String (value.doubleValue);
         case stringType:    return *(value.stringValue);
+        case objectType:    return "Object 0x" + String::toHexString ((int) (pointer_sized_int) value.objectValue);
         default:            jassertfalse; break;
     }
 

src/core/juce_StandardHeader.h

@@ -95,6 +95,7 @@
 #endif
 
 #if JUCE_MSVC
+  #include <malloc.h>
   #pragma warning (pop)
 #endif
 

src/gui/components/controls/juce_TreeView.cpp

@@ -125,7 +125,10 @@ public:
 
     void mouseDrag (const MouseEvent& e)
     {
-        if (isEnabled() && ! (e.mouseWasClicked() || isDragging))
+        if (isEnabled()
+             && ! (isDragging || e.mouseWasClicked()
+                    || e.getDistanceFromDragStart() < 5
+                    || e.mods.isPopupMenu()))
         {
             isDragging = true;
 
@@ -886,7 +889,7 @@ TreeViewItem* TreeView::getInsertPosition (int& x, int& y, int& insertIndex,
     insertIndex = 0;
     TreeViewItem* item = getItemAt (y);
 
-    if (item == 0 || item->parentItem == 0)
+    if (item == 0)
         return 0;
 
     Rectangle itemPos (item->getItemPosition (true));

src/gui/graphics/colour/juce_PixelFormats.h

@@ -38,6 +38,7 @@
 #endif
 
 class PixelRGB;
+class PixelAlpha;
 
 /**
     Represents a 32-bit ARGB pixel with premultiplied alpha, and can perform compositing
@@ -75,8 +76,7 @@ public:
         This takes into account the opacity of the pixel being overlaid, and blends
         it accordingly.
     */
-    template <class Pixel>
-    forcedinline void blend (const Pixel& src) throw()
+    forcedinline void blend (const PixelARGB& src) throw()
     {
         uint32 sargb = src.getARGB();
         const uint32 alpha = 0x100 - (sargb >> 24);
@@ -87,6 +87,14 @@ public:
         argb = sargb;
     }
 
+    /** Blends another pixel onto this one.
+
+        This takes into account the opacity of the pixel being overlaid, and blends
+        it accordingly.
+    */
+    forcedinline void blend (const PixelAlpha& src) throw();
+
+
     /** Blends another pixel onto this one.
 
         This takes into account the opacity of the pixel being overlaid, and blends
@@ -94,6 +102,7 @@ public:
     */
     forcedinline void blend (const PixelRGB& src) throw();
 
+
     /** Blends another pixel onto this one, applying an extra multiplier to its opacity.
 
         The opacity of the pixel being overlaid is scaled by the extraAlpha factor before
@@ -318,11 +327,7 @@ public:
         set (src);
     }
 
-    template <class Pixel>
-    forcedinline void blend (const Pixel& src) throw()
-    {
-        blend (PixelARGB (src.getARGB()));
-    }
+    forcedinline void blend (const PixelAlpha& src) throw();
 
     /** Blends another pixel onto this one, applying an extra multiplier to its opacity.
 
@@ -546,6 +551,24 @@ private:
     uint8 a : 8;
 } PACKED;
 
+forcedinline void PixelRGB::blend (const PixelAlpha& src) throw()
+{
+    blend (PixelARGB (src.getARGB()));
+}
+
+
+forcedinline void PixelARGB::blend (const PixelAlpha& src) throw()
+{
+    uint32 sargb = src.getARGB();
+    const uint32 alpha = 0x100 - (sargb >> 24);
+
+    sargb += 0x00ff00ff & ((getRB() * alpha) >> 8);
+    sargb += 0xff00ff00 & (getAG() * alpha);
+
+    argb = sargb;
+}
+
+
 #if JUCE_MSVC
   #pragma pack (pop)
 #endif

src/gui/graphics/contexts/juce_EdgeTable.cpp

@@ -54,7 +54,8 @@ EdgeTable::EdgeTable (const Rectangle& bounds_,
 {
     table = (int*) juce_malloc ((bounds.getHeight() + 1) * lineStrideElements * sizeof (int));
     int* t = table;
-    for (int i = bounds.getHeight(); --i >= 0;)
+    int i = 0;
+    for (i = bounds.getHeight(); --i >= 0;)
     {
         *t = 0;
         t += lineStrideElements;
@@ -119,7 +120,7 @@ EdgeTable::EdgeTable (const Rectangle& bounds_,
     // Convert the table from relative windings to absolute levels..
     int* lineStart = table;
 
-    for (int i = bounds.getHeight(); --i >= 0;)
+    for (i = bounds.getHeight(); --i >= 0;)
     {
         int* line = lineStart;
         lineStart += lineStrideElements;
@@ -576,12 +577,13 @@ void EdgeTable::clipToEdgeTable (const EdgeTable& other)
         if (clipped.getRight() < bounds.getRight())
             bounds.setRight (clipped.getRight());
 
-        for (int i = top; --i >= 0;)
+        int i = 0;
+        for (i = top; --i >= 0;)
             table [lineStrideElements * i] = 0;
 
         const int* otherLine = other.table + other.lineStrideElements * (clipped.getY() - other.bounds.getY());
 
-        for (int i = top; i < bottom; ++i)
+        for (i = top; i < bottom; ++i)
         {
             intersectWithEdgeTableLine (i, otherLine);
             otherLine += other.lineStrideElements;

src/gui/graphics/contexts/juce_LowLevelGraphicsSoftwareRenderer.cpp

@@ -969,9 +969,9 @@ public:
 
             switch (image.getFormat())
             {
-                case Image::ARGB:   renderGradient <PixelARGB>  (et, destData, g2, transform, lookupTable, numLookupEntries, isIdentity); break;
-                case Image::RGB:    renderGradient <PixelRGB>   (et, destData, g2, transform, lookupTable, numLookupEntries, isIdentity); break;
-                default:            renderGradient <PixelAlpha> (et, destData, g2, transform, lookupTable, numLookupEntries, isIdentity); break;
+                case Image::ARGB:   renderGradient (et, destData, g2, transform, lookupTable, numLookupEntries, isIdentity, (PixelARGB*) 0); break;
+                case Image::RGB:    renderGradient (et, destData, g2, transform, lookupTable, numLookupEntries, isIdentity, (PixelRGB*) 0); break;
+                default:            renderGradient (et, destData, g2, transform, lookupTable, numLookupEntries, isIdentity, (PixelAlpha*) 0); break;
             }
 
             juce_free (lookupTable);
@@ -986,9 +986,9 @@ public:
 
             switch (image.getFormat())
             {
-                case Image::ARGB:   renderSolidFill2 <PixelARGB>  (et, destData, fillColour, replaceContents); break;
-                case Image::RGB:    renderSolidFill2 <PixelRGB>   (et, destData, fillColour, replaceContents); break;
-                default:            renderSolidFill2 <PixelAlpha> (et, destData, fillColour, replaceContents); break;
+                case Image::ARGB:   renderSolidFill (et, destData, fillColour, replaceContents, (PixelARGB*) 0); break;
+                case Image::RGB:    renderSolidFill (et, destData, fillColour, replaceContents, (PixelRGB*) 0); break;
+                default:            renderSolidFill (et, destData, fillColour, replaceContents, (PixelAlpha*) 0); break;
             }
         }
     }
@@ -1017,7 +1017,7 @@ public:
 
                 if (tiledFillClipRegion != 0)
                 {
-                    blittedRenderImage3 <true> (sourceImage, destImage, *tiledFillClipRegion, destData, srcData, alpha, tx, ty);
+                    blittedRenderImage (sourceImage, destImage, *tiledFillClipRegion, destData, srcData, alpha, tx, ty, true);
                 }
                 else
                 {
@@ -1025,7 +1025,7 @@ public:
                     et.clipToEdgeTable (edgeTable->edgeTable);
 
                     if (! et.isEmpty())
-                        blittedRenderImage3 <false> (sourceImage, destImage, et, destData, srcData, alpha, tx, ty);
+                        blittedRenderImage (sourceImage, destImage, et, destData, srcData, alpha, tx, ty, false);
                 }
 
                 return;
@@ -1037,7 +1037,7 @@ public:
 
         if (tiledFillClipRegion != 0)
         {
-            transformedRenderImage3 <true> (sourceImage, destImage, *tiledFillClipRegion, destData, srcData, alpha, transform, betterQuality);
+            transformedRenderImage (sourceImage, destImage, *tiledFillClipRegion, destData, srcData, alpha, transform, betterQuality, true);
         }
         else
         {
@@ -1048,7 +1048,7 @@ public:
             et.clipToEdgeTable (edgeTable->edgeTable);
 
             if (! et.isEmpty())
-                transformedRenderImage3 <false> (sourceImage, destImage, et, destData, srcData, alpha, transform, betterQuality);
+                transformedRenderImage (sourceImage, destImage, et, destData, srcData, alpha, transform, betterQuality, false);
         }
     }
 
@@ -1082,9 +1082,9 @@ public:
                 const int imageY = ((ty + 128) >> 8);
 
                 if (image.getFormat() == Image::ARGB)
-                    straightClipImage <PixelARGB> (et, srcData, imageX, imageY);
+                    straightClipImage (et, srcData, imageX, imageY, (PixelARGB*)0);
                 else
-                    straightClipImage <PixelAlpha> (et, srcData, imageX, imageY);
+                    straightClipImage (et, srcData, imageX, imageY, (PixelAlpha*)0);
 
                 return;
             }
@@ -1106,14 +1106,14 @@ public:
         if (! et.isEmpty())
         {
             if (image.getFormat() == Image::ARGB)
-                transformedClipImage <PixelARGB> (et, srcData, transform, betterQuality);
+                transformedClipImage (et, srcData, transform, betterQuality, (PixelARGB*)0);
             else
-                transformedClipImage <PixelAlpha> (et, srcData, transform, betterQuality);
+                transformedClipImage (et, srcData, transform, betterQuality, (PixelAlpha*)0);
         }
     }
 
     template <class SrcPixelType>
-    void transformedClipImage (EdgeTable& et, const Image::BitmapData& srcData, const AffineTransform& transform, const bool betterQuality) throw()
+    void transformedClipImage (EdgeTable& et, const Image::BitmapData& srcData, const AffineTransform& transform, const bool betterQuality, const SrcPixelType *) throw()
     {
         TransformedImageFillEdgeTableRenderer <SrcPixelType, SrcPixelType, false> renderer (srcData, srcData, transform, 255, betterQuality);
 
@@ -1123,7 +1123,7 @@ public:
     }
 
     template <class SrcPixelType>
-    void straightClipImage (EdgeTable& et, const Image::BitmapData& srcData, int imageX, int imageY) throw()
+    void straightClipImage (EdgeTable& et, const Image::BitmapData& srcData, int imageX, int imageY, const SrcPixelType *) throw()
     {
         Rectangle r (imageX, imageY, srcData.width, srcData.height);
         et.clipToRectangle (r);
@@ -1161,7 +1161,7 @@ private:
     //==============================================================================
     template <class DestPixelType>
     void renderGradient (EdgeTable& et, const Image::BitmapData& destData, const ColourGradient& g, const AffineTransform& transform,
-                         const PixelARGB* const lookupTable, const int numLookupEntries, const bool isIdentity) throw()
+                         const PixelARGB* const lookupTable, const int numLookupEntries, const bool isIdentity, DestPixelType*) throw()
     {
         jassert (destData.pixelStride == sizeof (DestPixelType));
 
@@ -1186,86 +1186,139 @@ private:
     }
 
     //==============================================================================
-    template <class DestPixelType, bool replaceContents>
-    void renderSolidFill1 (EdgeTable& et, const Image::BitmapData& destData, const PixelARGB& fillColour) throw()
-    {
-        jassert (destData.pixelStride == sizeof (DestPixelType));
-        SolidColourEdgeTableRenderer <DestPixelType, replaceContents> renderer (destData, fillColour);
-        et.iterate (renderer);
-    }
-
     template <class DestPixelType>
-    void renderSolidFill2 (EdgeTable& et, const Image::BitmapData& destData, const PixelARGB& fillColour, const bool replaceContents) throw()
+    void renderSolidFill (EdgeTable& et, const Image::BitmapData& destData, const PixelARGB& fillColour, const bool replaceContents, DestPixelType*) throw()
     {
+        jassert (destData.pixelStride == sizeof (DestPixelType));
         if (replaceContents)
-            renderSolidFill1 <DestPixelType, true> (et, destData, fillColour);
-        else
-            renderSolidFill1 <DestPixelType, false> (et, destData, fillColour);
-    }
-
-    //==============================================================================
-    template <class SrcPixelType, class DestPixelType, bool repeatPattern>
-    void transformedRenderImage1 (const EdgeTable& et, const Image::BitmapData& destData, const Image::BitmapData& srcData,
-                                  const int alpha, const AffineTransform& transform, const bool betterQuality) throw()
-    {
-        TransformedImageFillEdgeTableRenderer <DestPixelType, SrcPixelType, repeatPattern> renderer (destData, srcData, transform, alpha, betterQuality);
-        et.iterate (renderer);
-    }
-
-    template <class SrcPixelType, bool repeatPattern>
-    void transformedRenderImage2 (Image& destImage, const EdgeTable& et, const Image::BitmapData& destData, const Image::BitmapData& srcData,
-                                  const int alpha, const AffineTransform& transform, const bool betterQuality) throw()
-    {
-        switch (destImage.getFormat())
         {
-            case Image::ARGB:   transformedRenderImage1 <SrcPixelType, PixelARGB, repeatPattern>  (et, destData, srcData, alpha, transform, betterQuality); break;
-            case Image::RGB:    transformedRenderImage1 <SrcPixelType, PixelRGB, repeatPattern>   (et, destData, srcData, alpha, transform, betterQuality); break;
-            default:            transformedRenderImage1 <SrcPixelType, PixelAlpha, repeatPattern> (et, destData, srcData, alpha, transform, betterQuality); break;
+            SolidColourEdgeTableRenderer <DestPixelType, true> r (destData, fillColour);
+            et.iterate (r);
         }
-    }
-
-    template <bool repeatPattern>
-    void transformedRenderImage3 (const Image& srcImage, Image& destImage, const EdgeTable& et, const Image::BitmapData& destData, const Image::BitmapData& srcData,
-                                  const int alpha, const AffineTransform& transform, const bool betterQuality) throw()
-    {
-        switch (srcImage.getFormat())
+        else
         {
-            case Image::ARGB:   transformedRenderImage2 <PixelARGB,  repeatPattern> (destImage, et, destData, srcData, alpha, transform, betterQuality); break;
-            case Image::RGB:    transformedRenderImage2 <PixelRGB,   repeatPattern> (destImage, et, destData, srcData, alpha, transform, betterQuality); break;
-            default:            transformedRenderImage2 <PixelAlpha, repeatPattern> (destImage, et, destData, srcData, alpha, transform, betterQuality); break;
+            SolidColourEdgeTableRenderer <DestPixelType, false> r (destData, fillColour);
+            et.iterate (r);
         }
     }
 
     //==============================================================================
-    template <class SrcPixelType, class DestPixelType, bool repeatPattern>
-    void blittedRenderImage1 (const EdgeTable& et, const Image::BitmapData& destData, const Image::BitmapData& srcData,
-                              const int alpha, int x, int y) throw()
-    {
-        ImageFillEdgeTableRenderer <DestPixelType, SrcPixelType, repeatPattern> renderer (destData, srcData, alpha, x, y);
-        et.iterate (renderer);
-    }
-
-    template <class SrcPixelType, bool repeatPattern>
-    void blittedRenderImage2 (Image& destImage, const EdgeTable& et, const Image::BitmapData& destData,
-                              const Image::BitmapData& srcData, const int alpha, int x, int y) throw()
+    void transformedRenderImage (const Image& srcImage, Image& destImage, const EdgeTable& et, const Image::BitmapData& destData, const Image::BitmapData& srcData,
+                                 const int alpha, const AffineTransform& transform, const bool betterQuality, const bool repeatPattern) throw()
     {
         switch (destImage.getFormat())
         {
-            case Image::ARGB:   blittedRenderImage1 <SrcPixelType, PixelARGB,  repeatPattern> (et, destData, srcData, alpha, x, y); break;
-            case Image::RGB:    blittedRenderImage1 <SrcPixelType, PixelRGB,   repeatPattern> (et, destData, srcData, alpha, x, y); break;
-            default:            blittedRenderImage1 <SrcPixelType, PixelAlpha, repeatPattern> (et, destData, srcData, alpha, x, y); break;
+        case Image::ARGB:
+            switch (srcImage.getFormat())
+            {
+            case Image::ARGB:
+                if (repeatPattern) { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelARGB, true> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                else               { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelARGB, false> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                break;
+            case Image::RGB:
+                if (repeatPattern) { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelRGB, true> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                else               { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelRGB, false> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                break;
+            default:
+                if (repeatPattern) { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelAlpha, true> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                else               { TransformedImageFillEdgeTableRenderer <PixelARGB, PixelAlpha, false> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                break;
+            }
+            break;
+        case Image::RGB:
+            switch (srcImage.getFormat())
+            {
+            case Image::ARGB:
+                if (repeatPattern) { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelARGB, true> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                else               { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelARGB, false> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                break;
+            case Image::RGB:
+                if (repeatPattern) { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelRGB, true> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                else               { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelRGB, false> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                break;
+            default:
+                if (repeatPattern) { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelAlpha, true> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                else               { TransformedImageFillEdgeTableRenderer <PixelRGB, PixelAlpha, false> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                break;
+            }
+            break;
+        default:
+            switch (srcImage.getFormat())
+            {
+            case Image::ARGB:
+                if (repeatPattern) { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelARGB, true> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                else               { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelARGB, false> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                break;
+            case Image::RGB:
+                if (repeatPattern) { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelRGB, true> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                else               { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelRGB, false> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                break;
+            default:
+                if (repeatPattern) { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelAlpha, true> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                else               { TransformedImageFillEdgeTableRenderer <PixelAlpha, PixelAlpha, false> r (destData, srcData, transform, alpha, betterQuality); et.iterate (r); }
+                break;
+            }
+            break;
         }
     }
 
-    template <bool repeatPattern>
-    void blittedRenderImage3 (const Image& srcImage, Image& destImage, const EdgeTable& et, const Image::BitmapData& destData,
-                              const Image::BitmapData& srcData, const int alpha, int x, int y) throw()
+    //==============================================================================
+    void blittedRenderImage (const Image& srcImage, Image& destImage, const EdgeTable& et, const Image::BitmapData& destData,
+                             const Image::BitmapData& srcData, const int alpha, int x, int y, const bool repeatPattern) throw()
     {
-        switch (srcImage.getFormat())
+        switch (destImage.getFormat())
         {
-            case Image::ARGB:   blittedRenderImage2 <PixelARGB,  repeatPattern> (destImage, et, destData, srcData, alpha, x, y); break;
-            case Image::RGB:    blittedRenderImage2 <PixelRGB,   repeatPattern> (destImage, et, destData, srcData, alpha, x, y); break;
-            default:            blittedRenderImage2 <PixelAlpha, repeatPattern> (destImage, et, destData, srcData, alpha, x, y); break;
+            case Image::ARGB:
+                switch (srcImage.getFormat())
+                {
+                case Image::ARGB:
+                    if (repeatPattern) { ImageFillEdgeTableRenderer <PixelARGB, PixelARGB, true> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    else               { ImageFillEdgeTableRenderer <PixelARGB, PixelARGB, false> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    break;
+                case Image::RGB:
+                    if (repeatPattern) { ImageFillEdgeTableRenderer <PixelARGB, PixelRGB, true> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    else               { ImageFillEdgeTableRenderer <PixelARGB, PixelRGB, false> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    break;
+                default:
+                    if (repeatPattern) { ImageFillEdgeTableRenderer <PixelARGB, PixelAlpha, true> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    else               { ImageFillEdgeTableRenderer <PixelARGB, PixelAlpha, false> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    break;
+                }
+            break;
+            case Image::RGB:
+                switch (srcImage.getFormat())
+                {
+                case Image::ARGB:
+                    if (repeatPattern) { ImageFillEdgeTableRenderer <PixelRGB, PixelARGB, true> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    else               { ImageFillEdgeTableRenderer <PixelRGB, PixelARGB, false> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    break;
+                case Image::RGB:
+                    if (repeatPattern) { ImageFillEdgeTableRenderer <PixelRGB, PixelRGB, true> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    else               { ImageFillEdgeTableRenderer <PixelRGB, PixelRGB, false> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    break;
+                default:
+                    if (repeatPattern) { ImageFillEdgeTableRenderer <PixelRGB, PixelAlpha, true> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    else               { ImageFillEdgeTableRenderer <PixelRGB, PixelAlpha, false> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    break;
+                }
+            break;
+            default:
+                switch (srcImage.getFormat())
+                {
+                case Image::ARGB:
+                    if (repeatPattern) { ImageFillEdgeTableRenderer <PixelAlpha, PixelARGB, true> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    else               { ImageFillEdgeTableRenderer <PixelAlpha, PixelARGB, false> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    break;
+                case Image::RGB:
+                    if (repeatPattern) { ImageFillEdgeTableRenderer <PixelAlpha, PixelRGB, true> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    else               { ImageFillEdgeTableRenderer <PixelAlpha, PixelRGB, false> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    break;
+                default:
+                    if (repeatPattern) { ImageFillEdgeTableRenderer <PixelAlpha, PixelAlpha, true> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    else               { ImageFillEdgeTableRenderer <PixelAlpha, PixelAlpha, false> r (destData, srcData, alpha, x, y); et.iterate (r); }
+                    break;
+                }
+            break;
         }
     }
 };

src/text/juce_String.cpp

@@ -882,11 +882,6 @@ String& String::operator<< (const short number) throw()
     return *this;
 }
 
-String& String::operator<< (const unsigned short number) throw()
-{
-    return operator<< ((unsigned int) number);
-}
-
 String& String::operator<< (const long number) throw()
 {
     return operator<< ((int) number);

src/text/juce_String.h

@@ -156,8 +156,6 @@ public:
     /** Appends a decimal number at the end of this string. */
     String& operator<< (const short number) throw();
     /** Appends a decimal number at the end of this string. */
-    String& operator<< (const unsigned short number) throw();
-    /** Appends a decimal number at the end of this string. */
     String& operator<< (const int number) throw();
     /** Appends a decimal number at the end of this string. */
     String& operator<< (const unsigned int number) throw();