Blob Blame History Raw
From 0533dd425a46fb8344c12eead0b7ac21fe7db047 Mon Sep 17 00:00:00 2001
From: rpmbuild <rpmbuild@fedoraproject.org>
Date: Fri, 18 Aug 2017 12:12:40 +0100
Subject: [PATCH] bubble the original gtk surface type through rendering

this makes presenting from a hidpi internal monitor to non-hidpi external
monitor use the correct sizes

and this may make scrolling a tad faster in general
---
 vcl/headless/svpframe.cxx     |   4 +-
 vcl/headless/svpgdi.cxx       | 135 ++++++++++++++++++++++++++----------------
 vcl/headless/svpvd.cxx        |  21 +++----
 vcl/inc/headless/svpgdi.hxx   |   5 +-
 vcl/inc/headless/svpvd.hxx    |   1 +
 vcl/inc/unx/gtk/gtkframe.hxx  |   2 +
 vcl/unx/gtk3/gtk3gtkframe.cxx |  50 +++++++---------
 7 files changed, 128 insertions(+), 90 deletions(-)

diff --git a/vcl/headless/svpframe.cxx b/vcl/headless/svpframe.cxx
index 0ce76cf..962cea0 100644
--- a/vcl/headless/svpframe.cxx
+++ b/vcl/headless/svpframe.cxx
@@ -150,7 +150,7 @@ SalGraphics* SvpSalFrame::AcquireGraphics()
 {
     SvpSalGraphics* pGraphics = new SvpSalGraphics();
 #ifndef IOS
-    pGraphics->setSurface( m_pSurface );
+    pGraphics->setSurface(m_pSurface, B2IVector(maGeometry.nWidth, maGeometry.nHeight));
 #endif
     m_aGraphics.push_back( pGraphics );
     return pGraphics;
@@ -281,7 +281,7 @@ void SvpSalFrame::SetPosSize( long nX, long nY, long nWidth, long nHeight, sal_u
         for( std::list< SvpSalGraphics* >::iterator it = m_aGraphics.begin();
              it != m_aGraphics.end(); ++it )
         {
-             (*it)->setSurface(m_pSurface);
+             (*it)->setSurface(m_pSurface, aFrameSize);
         }
     }
     if( m_bVisible )
diff --git a/vcl/headless/svpgdi.cxx b/vcl/headless/svpgdi.cxx
index bcc1df9..242cc13 100644
--- a/vcl/headless/svpgdi.cxx
+++ b/vcl/headless/svpgdi.cxx
@@ -133,6 +133,22 @@ namespace
         {
             return source;
         }
+        void mark_dirty()
+        {
+            cairo_surface_mark_dirty(source);
+        }
+        unsigned char* getBits(sal_Int32 &rStride)
+        {
+            cairo_surface_flush(source);
+
+            unsigned char *mask_data = cairo_image_surface_get_data(source);
+
+            cairo_format_t nFormat = cairo_image_surface_get_format(source);
+            assert(nFormat == CAIRO_FORMAT_ARGB32 && "need to implement CAIRO_FORMAT_A1 after all here");
+            rStride = cairo_format_stride_for_width(nFormat, cairo_image_surface_get_width(source));
+
+            return mask_data;
+        }
     private:
         SvpSalBitmap aTmpBmp;
         cairo_surface_t* source;
@@ -386,9 +402,10 @@ SvpSalGraphics::~SvpSalGraphics()
 {
 }
 
-void SvpSalGraphics::setSurface(cairo_surface_t* pSurface)
+void SvpSalGraphics::setSurface(cairo_surface_t* pSurface, const basegfx::B2IVector& rSize)
 {
     m_pSurface = pSurface;
+    m_aFrameSize = rSize;
 #if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 14, 0)
     cairo_surface_get_device_scale(pSurface, &m_fScale, nullptr);
 #endif
@@ -402,14 +419,14 @@ void SvpSalGraphics::GetResolution( sal_Int32& rDPIX, sal_Int32& rDPIY )
 
 sal_uInt16 SvpSalGraphics::GetBitCount() const
 {
-    if (CAIRO_FORMAT_A1 == cairo_image_surface_get_format(m_pSurface))
+    if (cairo_surface_get_content(m_pSurface) != CAIRO_CONTENT_COLOR_ALPHA)
         return 1;
     return 32;
 }
 
 long SvpSalGraphics::GetGraphicsWidth() const
 {
-    return m_pSurface ? cairo_image_surface_get_width(m_pSurface) / m_fScale : 0;
+    return m_pSurface ? m_aFrameSize.getX() : 0;
 }
 
 void SvpSalGraphics::ResetClipRegion()
@@ -885,7 +902,7 @@ bool SvpSalGraphics::drawPolyPolygon(const basegfx::B2DPolyPolygon& rPolyPoly, d
 
 void SvpSalGraphics::applyColor(cairo_t *cr, SalColor aColor)
 {
-    if (CAIRO_FORMAT_ARGB32 == cairo_image_surface_get_format(m_pSurface))
+    if (cairo_surface_get_content(m_pSurface) == CAIRO_CONTENT_COLOR_ALPHA)
     {
         cairo_set_source_rgba(cr, SALCOLOR_RED(aColor)/255.0,
                                   SALCOLOR_GREEN(aColor)/255.0,
@@ -982,17 +999,10 @@ void SvpSalGraphics::copyBits( const SalTwoRect& rTR,
     if (pSrc == this)
     {
         //self copy is a problem, so dup source in that case
-#if CAIRO_VERSION < CAIRO_VERSION_ENCODE(1, 12, 0)
         pCopy = cairo_surface_create_similar(source,
                                             cairo_surface_get_content(m_pSurface),
                                             aTR.mnSrcWidth * m_fScale,
                                             aTR.mnSrcHeight * m_fScale);
-#else
-        pCopy = cairo_surface_create_similar_image(source,
-                                            cairo_image_surface_get_format(m_pSurface),
-                                            aTR.mnSrcWidth * m_fScale,
-                                            aTR.mnSrcHeight * m_fScale);
-#endif
 #if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 14, 0)
         cairo_surface_set_device_scale(pCopy, m_fScale, m_fScale);
 #endif
@@ -1049,16 +1059,8 @@ void SvpSalGraphics::drawMask( const SalTwoRect& rTR,
     /** creates an image from the given rectangle, replacing all black pixels
      *  with nMaskColor and make all other full transparent */
     SourceHelper aSurface(rSalBitmap);
-    cairo_surface_t* mask = aSurface.getSurface();
-
-    cairo_surface_flush(mask);
-
-    unsigned char *mask_data = cairo_image_surface_get_data(mask);
-
-    cairo_format_t nFormat = cairo_image_surface_get_format(mask);
-    assert(nFormat == CAIRO_FORMAT_ARGB32 && "need to implement CAIRO_FORMAT_A1 after all here");
-    sal_Int32 nStride = cairo_format_stride_for_width(nFormat,
-                                                      cairo_image_surface_get_width(mask));
+    sal_Int32 nStride;
+    unsigned char *mask_data = aSurface.getBits(nStride);
     for (sal_Int32 y = rTR.mnSrcY ; y < rTR.mnSrcY + rTR.mnSrcHeight; ++y)
     {
         unsigned char *row = mask_data + (nStride*y);
@@ -1085,7 +1087,7 @@ void SvpSalGraphics::drawMask( const SalTwoRect& rTR,
             data+=4;
         }
     }
-    cairo_surface_mark_dirty(mask);
+    aSurface.mark_dirty();
 
     cairo_t* cr = getCairoContext(false);
     clipRegion(cr);
@@ -1098,7 +1100,7 @@ void SvpSalGraphics::drawMask( const SalTwoRect& rTR,
 
     cairo_translate(cr, rTR.mnDestX, rTR.mnDestY);
     cairo_scale(cr, (double)(rTR.mnDestWidth)/rTR.mnSrcWidth, ((double)rTR.mnDestHeight)/rTR.mnSrcHeight);
-    cairo_set_source_surface(cr, mask, -rTR.mnSrcX, -rTR.mnSrcY);
+    cairo_set_source_surface(cr, aSurface.getSurface(), -rTR.mnSrcX, -rTR.mnSrcY);
     cairo_paint(cr);
 
     releaseCairoContext(cr, false, extents);
@@ -1123,18 +1125,24 @@ SalBitmap* SvpSalGraphics::getBitmap( long nX, long nY, long nWidth, long nHeigh
 
 SalColor SvpSalGraphics::getPixel( long nX, long nY )
 {
-    cairo_surface_flush(m_pSurface);
-    cairo_format_t nFormat = cairo_image_surface_get_format(m_pSurface);
-    assert(nFormat == CAIRO_FORMAT_ARGB32 && "need to implement CAIRO_FORMAT_A1 after all here");
-    sal_Int32 nStride = cairo_format_stride_for_width(nFormat,
-                                                      cairo_image_surface_get_width(m_pSurface));
-    unsigned char *surface_data = cairo_image_surface_get_data(m_pSurface);
-    unsigned char *row = surface_data + (nStride*nY);
-    unsigned char *data = row + (nX * 4);
+    cairo_surface_t *target = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, 1, 1);
+    cairo_t* cr = cairo_create(target);
+
+    cairo_rectangle(cr, 0, 0, 1, 1);
+    cairo_set_source_surface(cr, m_pSurface, -nX, -nY);
+    cairo_paint(cr);
+    cairo_destroy(cr);
+
+    cairo_surface_flush(target);
+    unsigned char *data = cairo_image_surface_get_data(target);
     sal_uInt8 b = unpremultiply(data[SVP_CAIRO_BLUE], data[SVP_CAIRO_ALPHA]);
     sal_uInt8 g = unpremultiply(data[SVP_CAIRO_GREEN], data[SVP_CAIRO_ALPHA]);
     sal_uInt8 r = unpremultiply(data[SVP_CAIRO_RED], data[SVP_CAIRO_ALPHA]);
-    return MAKE_SALCOLOR(r, g, b);
+    SalColor nRet = MAKE_SALCOLOR(r, g, b);
+
+    cairo_surface_destroy(target);
+
+    return nRet;
 }
 
 namespace
@@ -1268,17 +1276,15 @@ cairo_surface_t* SvpSalGraphics::createCairoSurface(const BitmapBuffer *pBuffer)
     return target;
 }
 
-static cairo_t* createTmpCompatibleCairoContext(cairo_surface_t* pSurface, double fScale)
+cairo_t* SvpSalGraphics::createTmpCompatibleCairoContext() const
 {
-    cairo_surface_t *target = cairo_image_surface_create(
-                                cairo_image_surface_get_format(pSurface),
-                                cairo_image_surface_get_width(pSurface),
-                                cairo_image_surface_get_height(pSurface));
+    cairo_surface_t *target = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
+                                                         m_aFrameSize.getX() * m_fScale,
+                                                         m_aFrameSize.getY() * m_fScale);
 #if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 14, 0)
-    cairo_surface_set_device_scale(target, fScale, fScale);
-#else
-    (void)fScale;
+    cairo_surface_set_device_scale(target, m_fScale, m_fScale);
 #endif
+
     return cairo_create(target);
 }
 
@@ -1286,7 +1292,7 @@ cairo_t* SvpSalGraphics::getCairoContext(bool bXorModeAllowed) const
 {
     cairo_t* cr;
     if (m_ePaintMode == XOR && bXorModeAllowed)
-        cr = createTmpCompatibleCairoContext(m_pSurface, m_fScale);
+        cr = createTmpCompatibleCairoContext();
     else
         cr = cairo_create(m_pSurface);
     cairo_set_line_width(cr, 1);
@@ -1316,8 +1322,8 @@ void SvpSalGraphics::releaseCairoContext(cairo_t* cr, bool bXorModeAllowed, cons
 
     sal_Int32 nExtentsLeft(rExtents.getMinX()), nExtentsTop(rExtents.getMinY());
     sal_Int32 nExtentsRight(rExtents.getMaxX()), nExtentsBottom(rExtents.getMaxY());
-    sal_Int32 nWidth = cairo_image_surface_get_width(m_pSurface);
-    sal_Int32 nHeight = cairo_image_surface_get_height(m_pSurface);
+    sal_Int32 nWidth = m_aFrameSize.getX();
+    sal_Int32 nHeight = m_aFrameSize.getY();
     nExtentsLeft = std::max<sal_Int32>(nExtentsLeft, 0);
     nExtentsTop = std::max<sal_Int32>(nExtentsTop, 0);
     nExtentsRight = std::min<sal_Int32>(nExtentsRight, nWidth);
@@ -1331,21 +1337,35 @@ void SvpSalGraphics::releaseCairoContext(cairo_t* cr, bool bXorModeAllowed, cons
     //emulate it (slowly) here.
     if (m_ePaintMode == XOR && bXorModeAllowed)
     {
-        cairo_surface_t* true_surface = m_pSurface;
-        cairo_surface_flush(true_surface);
-        unsigned char *true_surface_data = cairo_image_surface_get_data(true_surface);
+        cairo_surface_t* target_surface = m_pSurface;
+        if (cairo_surface_get_type(target_surface) != CAIRO_SURFACE_TYPE_IMAGE)
+        {
+            //in the unlikely case we can't use m_pSurface directly, copy contents
+            //to another temp image surface
+            cairo_t* copycr = createTmpCompatibleCairoContext();
+            cairo_rectangle(copycr, nExtentsLeft, nExtentsTop,
+                                    nExtentsRight - nExtentsLeft,
+                                    nExtentsBottom - nExtentsTop);
+            cairo_set_source_surface(copycr, m_pSurface, 0, 0);
+            cairo_paint(copycr);
+            target_surface = cairo_get_target(copycr);
+            cairo_destroy(copycr);
+        }
+
+        cairo_surface_flush(target_surface);
+        unsigned char *target_surface_data = cairo_image_surface_get_data(target_surface);
         unsigned char *xor_surface_data = cairo_image_surface_get_data(surface);
 
-        cairo_format_t nFormat = cairo_image_surface_get_format(m_pSurface);
+        cairo_format_t nFormat = cairo_image_surface_get_format(target_surface);
         assert(nFormat == CAIRO_FORMAT_ARGB32 && "need to implement CAIRO_FORMAT_A1 after all here");
-        sal_Int32 nStride = cairo_format_stride_for_width(nFormat, nWidth);
+        sal_Int32 nStride = cairo_format_stride_for_width(nFormat, nWidth * m_fScale);
         sal_Int32 nUnscaledExtentsLeft = nExtentsLeft * m_fScale;
         sal_Int32 nUnscaledExtentsRight = nExtentsRight * m_fScale;
         sal_Int32 nUnscaledExtentsTop = nExtentsTop * m_fScale;
         sal_Int32 nUnscaledExtentsBottom = nExtentsBottom * m_fScale;
         for (sal_Int32 y = nUnscaledExtentsTop; y < nUnscaledExtentsBottom; ++y)
         {
-            unsigned char *true_row = true_surface_data + (nStride*y);
+            unsigned char *true_row = target_surface_data + (nStride*y);
             unsigned char *xor_row = xor_surface_data + (nStride*y);
             unsigned char *true_data = true_row + (nUnscaledExtentsLeft * 4);
             unsigned char *xor_data = xor_row + (nUnscaledExtentsLeft * 4);
@@ -1364,7 +1384,22 @@ void SvpSalGraphics::releaseCairoContext(cairo_t* cr, bool bXorModeAllowed, cons
                 xor_data+=4;
             }
         }
-        cairo_surface_mark_dirty(true_surface);
+        cairo_surface_mark_dirty(target_surface);
+
+        if (target_surface != m_pSurface)
+        {
+            cairo_t* copycr = cairo_create(m_pSurface);
+            //unlikely case we couldn't use m_pSurface directly, copy contents
+            //back from image surface
+            cairo_rectangle(copycr, nExtentsLeft, nExtentsTop,
+                                    nExtentsRight - nExtentsLeft,
+                                    nExtentsBottom - nExtentsTop);
+            cairo_set_source_surface(copycr, target_surface, 0, 0);
+            cairo_paint(copycr);
+            cairo_destroy(copycr);
+            cairo_surface_destroy(target_surface);
+        }
+
         cairo_surface_destroy(surface);
     }
 
diff --git a/vcl/headless/svpvd.cxx b/vcl/headless/svpvd.cxx
index ca28a52..b5ab755 100644
--- a/vcl/headless/svpvd.cxx
+++ b/vcl/headless/svpvd.cxx
@@ -38,7 +38,7 @@ SvpSalVirtualDevice::~SvpSalVirtualDevice()
 SalGraphics* SvpSalVirtualDevice::AcquireGraphics()
 {
     SvpSalGraphics* pGraphics = new SvpSalGraphics();
-    pGraphics->setSurface(m_pSurface);
+    pGraphics->setSurface(m_pSurface, m_aFrameSize);
     m_aGraphics.push_back( pGraphics );
     return pGraphics;
 }
@@ -62,12 +62,14 @@ bool SvpSalVirtualDevice::SetSizeUsingBuffer( long nNewDX, long nNewDY,
     if (nNewDY == 0)
         nNewDY = 1;
 
-    nNewDX *= m_fScale;
-    nNewDY *= m_fScale;
-
-    if (!m_pSurface || cairo_image_surface_get_width(m_pSurface) != nNewDX ||
-                       cairo_image_surface_get_height(m_pSurface) != nNewDY )
+    if (!m_pSurface || m_aFrameSize.getX() != nNewDX ||
+                       m_aFrameSize.getY() != nNewDY )
     {
+        m_aFrameSize = basegfx::B2IVector(nNewDX, nNewDY);
+
+        nNewDX *= m_fScale;
+        nNewDY *= m_fScale;
+
         if (m_pSurface)
         {
             cairo_surface_destroy(m_pSurface);
@@ -96,20 +98,19 @@ bool SvpSalVirtualDevice::SetSizeUsingBuffer( long nNewDX, long nNewDY,
         // update device in existing graphics
         for( std::list< SvpSalGraphics* >::iterator it = m_aGraphics.begin();
              it != m_aGraphics.end(); ++it )
-            (*it)->setSurface(m_pSurface);
-
+            (*it)->setSurface(m_pSurface, m_aFrameSize);
     }
     return true;
 }
 
 long SvpSalVirtualDevice::GetWidth() const
 {
-    return m_pSurface ? cairo_image_surface_get_width(m_pSurface) : 0;
+    return m_pSurface ? m_aFrameSize.getX() : 0;
 }
 
 long SvpSalVirtualDevice::GetHeight() const
 {
-    return m_pSurface ? cairo_image_surface_get_height(m_pSurface) : 0;
+    return m_pSurface ? m_aFrameSize.getY() : 0;
 }
 
 #endif
diff --git a/vcl/inc/headless/svpgdi.hxx b/vcl/inc/headless/svpgdi.hxx
index 97fd678..0f46c5f 100644
--- a/vcl/inc/headless/svpgdi.hxx
+++ b/vcl/inc/headless/svpgdi.hxx
@@ -80,6 +80,7 @@ struct VCL_DLLPUBLIC DamageHandler
 class VCL_DLLPUBLIC SvpSalGraphics : public SalGraphics
 {
     cairo_surface_t*               m_pSurface;
+    basegfx::B2IVector             m_aFrameSize;
     double                         m_fScale;
     SalColor                       m_aLineColor;
     SalColor                       m_aFillColor;
@@ -87,7 +88,7 @@ class VCL_DLLPUBLIC SvpSalGraphics : public SalGraphics
 
 public:
     static GlyphCache& getPlatformGlyphCache();
-    void setSurface(cairo_surface_t* pSurface);
+    void setSurface(cairo_surface_t* pSurface, const basegfx::B2IVector& rSize);
     static cairo_user_data_key_t* getDamageKey();
 
 private:
@@ -115,6 +116,8 @@ protected:
         const SalBitmap* pAlphaBitmap) override;
     virtual bool drawAlphaRect( long nX, long nY, long nWidth, long nHeight, sal_uInt8 nTransparency ) override;
 
+    cairo_t* createTmpCompatibleCairoContext() const;
+
 public:
     SvpSalGraphics();
     virtual ~SvpSalGraphics() override;
diff --git a/vcl/inc/headless/svpvd.hxx b/vcl/inc/headless/svpvd.hxx
index 882f36d..7ac1563 100644
--- a/vcl/inc/headless/svpvd.hxx
+++ b/vcl/inc/headless/svpvd.hxx
@@ -31,6 +31,7 @@ class VCL_DLLPUBLIC SvpSalVirtualDevice : public SalVirtualDevice
 {
     DeviceFormat                        m_eFormat;
     cairo_surface_t*                    m_pSurface;
+    basegfx::B2IVector                  m_aFrameSize;
     double                              m_fScale;
     std::list< SvpSalGraphics* >        m_aGraphics;
 
diff --git a/vcl/inc/unx/gtk/gtkframe.hxx b/vcl/inc/unx/gtk/gtkframe.hxx
index f263160..8f60671 100644
--- a/vcl/inc/unx/gtk/gtkframe.hxx
+++ b/vcl/inc/unx/gtk/gtkframe.hxx
@@ -246,6 +246,7 @@ class GtkSalFrame : public SalFrame
 #endif
 #if GTK_CHECK_VERSION(3,0,0)
     static gboolean     signalDraw( GtkWidget*, cairo_t *cr, gpointer );
+    static void         signalRealize(GtkWidget*, gpointer frame);
     static void         sizeAllocated(GtkWidget*, GdkRectangle *pAllocation, gpointer frame);
     static gboolean     signalTooltipQuery(GtkWidget*, gint x, gint y,
                                      gboolean keyboard_mode, GtkTooltip *tooltip,
@@ -346,6 +347,7 @@ class GtkSalFrame : public SalFrame
 public:
 #if GTK_CHECK_VERSION(3,0,0)
     cairo_surface_t*                m_pSurface;
+    basegfx::B2IVector              m_aFrameSize;
     DamageHandler                   m_aDamageHandler;
     std::vector<GdkEvent*>          m_aPendingScrollEvents;
     Idle                            m_aSmoothScrollIdle;
diff --git a/vcl/unx/gtk3/gtk3gtkframe.cxx b/vcl/unx/gtk3/gtk3gtkframe.cxx
index 9be38dd..dc9d83b 100644
--- a/vcl/unx/gtk3/gtk3gtkframe.cxx
+++ b/vcl/unx/gtk3/gtk3gtkframe.cxx
@@ -1045,6 +1045,7 @@ void GtkSalFrame::InitCommon()
     m_aMouseSignalIds.push_back(g_signal_connect( G_OBJECT(pEventWidget), "scroll-event", G_CALLBACK(signalScroll), this ));
 
     g_signal_connect( G_OBJECT(m_pFixedContainer), "draw", G_CALLBACK(signalDraw), this );
+    g_signal_connect( G_OBJECT(m_pFixedContainer), "realize", G_CALLBACK(signalRealize), this );
     g_signal_connect( G_OBJECT(m_pFixedContainer), "size-allocate", G_CALLBACK(sizeAllocated), this );
 #if GTK_CHECK_VERSION(3,14,0)
     GtkGesture *pSwipe = gtk_gesture_swipe_new(pEventWidget);
@@ -1340,7 +1341,7 @@ SalGraphics* GtkSalFrame::AcquireGraphics()
             AllocateFrame();
             TriggerPaintEvent();
         }
-        m_pGraphics->setSurface(m_pSurface);
+        m_pGraphics->setSurface(m_pSurface, m_aFrameSize);
     }
     m_bGraphics = true;
     return m_pGraphics;
@@ -1587,13 +1588,11 @@ void GtkSalFrame::SetMinClientSize( long nWidth, long nHeight )
     }
 }
 
-// FIXME: we should really be an SvpSalFrame sub-class, and
-// share their AllocateFrame !
 void GtkSalFrame::AllocateFrame()
 {
     basegfx::B2IVector aFrameSize( maGeometry.nWidth, maGeometry.nHeight );
-    if (!m_pSurface || cairo_image_surface_get_width(m_pSurface) != aFrameSize.getX() ||
-                       cairo_image_surface_get_height(m_pSurface) != aFrameSize.getY() )
+    if (!m_pSurface || m_aFrameSize.getX() != aFrameSize.getX() ||
+                       m_aFrameSize.getY() != aFrameSize.getY() )
     {
         if( aFrameSize.getX() == 0 )
             aFrameSize.setX( 1 );
@@ -1603,30 +1602,17 @@ void GtkSalFrame::AllocateFrame()
         if (m_pSurface)
             cairo_surface_destroy(m_pSurface);
 
-#if GTK_CHECK_VERSION(3,10,0)
-#if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 14, 0)
-        int scale = gtk_widget_get_scale_factor(m_pWindow);
-#else
-        int scale = 1;
-#endif
-        m_pSurface = gdk_window_create_similar_image_surface(widget_get_window(m_pWindow),
-                                                             CAIRO_FORMAT_ARGB32,
-                                                             aFrameSize.getX() * scale,
-                                                             aFrameSize.getY() * scale,
-                                                             scale);
-#if CAIRO_VERSION >= CAIRO_VERSION_ENCODE(1, 14, 0)
-        cairo_surface_set_device_scale(m_pSurface, scale, scale);
-#endif
-#else
-        m_pSurface = cairo_image_surface_create(CAIRO_FORMAT_ARGB32,
-                                                aFrameSize.getX(),
-                                                aFrameSize.getY());
-#endif
+        m_pSurface = gdk_window_create_similar_surface(widget_get_window(m_pWindow),
+                                                       CAIRO_CONTENT_COLOR_ALPHA,
+                                                       aFrameSize.getX(),
+                                                       aFrameSize.getY());
+        m_aFrameSize = aFrameSize;
+
         cairo_surface_set_user_data(m_pSurface, SvpSalGraphics::getDamageKey(), &m_aDamageHandler, nullptr);
         SAL_INFO("vcl.gtk3", "allocated Frame size of " << maGeometry.nWidth << " x " << maGeometry.nHeight);
 
         if (m_pGraphics)
-            m_pGraphics->setSurface(m_pSurface);
+            m_pGraphics->setSurface(m_pSurface, m_aFrameSize);
     }
 }
 
@@ -2967,13 +2953,23 @@ gboolean GtkSalFrame::signalDraw(GtkWidget*, cairo_t *cr, gpointer frame)
     return false;
 }
 
-void GtkSalFrame::sizeAllocated(GtkWidget*, GdkRectangle *pAllocation, gpointer frame)
+void GtkSalFrame::sizeAllocated(GtkWidget* pWidget, GdkRectangle *pAllocation, gpointer frame)
 {
     GtkSalFrame* pThis = static_cast<GtkSalFrame*>(frame);
     pThis->maGeometry.nWidth = pAllocation->width;
     pThis->maGeometry.nHeight = pAllocation->height;
-    pThis->AllocateFrame();
+    bool bRealized = gtk_widget_get_realized(pWidget);
+    if (bRealized)
+        pThis->AllocateFrame();
     pThis->CallCallbackExc( SalEvent::Resize, nullptr );
+    if (bRealized && !pThis->m_bSalObjectSetPosSize)
+        pThis->TriggerPaintEvent();
+}
+
+void GtkSalFrame::signalRealize(GtkWidget*, gpointer frame)
+{
+    GtkSalFrame* pThis = static_cast<GtkSalFrame*>(frame);
+    pThis->AllocateFrame();
     if (pThis->m_bSalObjectSetPosSize)
         return;
     pThis->TriggerPaintEvent();
-- 
2.13.0