Now rfb_win32::ScaledDIBSectionBuffer is an universal class which consist

of source image buffer and destination (scaled) image buffer. It automatically
scale the image data from source buffer to destination when data was
changed in the input buffer.
Overrided methods in the ScaledDIBSectionBuffer class: fillRect(), imageRect(),
copyRect(), maskRect().

git-svn-id: svn://svn.code.sf.net/p/tigervnc/code/trunk@516 3789f03b-4d11-0410-bbf8-ca57d06f2519

diff --git a/rfb_win32/ScaledDIBSectionBuffer.cxx b/rfb_win32/ScaledDIBSectionBuffer.cxx
index 5b6f248c406b2983a94cf5feaddd3b9f81fb3953..e6c15b8eb2376bc3d3e809f3205211740f64cc32 100644 (file)
--- a/rfb_win32/ScaledDIBSectionBuffer.cxx
+++ b/rfb_win32/ScaledDIBSectionBuffer.cxx
@@ -29,27 +29,46 @@ using namespace rfb;
 using namespace win32;
 
 ScaledDIBSectionBuffer::ScaledDIBSectionBuffer(HWND window) 
-  : DIBSectionBuffer(window) {
+  : src_buffer(0), scaling(false), DIBSectionBuffer(window) {
   scaled_data = data;
 }
 
-void ScaledDIBSectionBuffer::setSrcPixelBuffer(U8 **src_data_, int w, int h, PixelFormat pf) {
-  src_data = src_data_;
-  src_width  = w;
-  src_height = h;
-  scaled_width  = width_  = (int)ceil(src_width  * scale_ratio);
-  scaled_height = height_ = (int)ceil(src_height * scale_ratio);
-  setPF(pf);
+ScaledDIBSectionBuffer::~ScaledDIBSectionBuffer() {
+  if (src_buffer) delete src_buffer;
+}
+
+void ScaledDIBSectionBuffer::setScale(int scale_) {
+  if (scale_ == getScale()) return;
+
+  if (src_buffer) {
+    delete src_buffer;
+    src_buffer = 0;
+  }
+  if (scale_ != 100) {
+    scaling = true;
+    src_buffer = new ManagedPixelBuffer(format, src_width, src_height);
+    src_data = &(src_buffer->data);
+  } else {
+    scaling = false;
+  }
+  ScaledPixelBuffer::setScale(scale_);
 }
 
 void ScaledDIBSectionBuffer::setPF(const PixelFormat &pf) {
+  if (scaling) src_buffer->setPF(pf);
   DIBSectionBuffer::setPF(pf);
+  scaled_data = data;
 }
 
 void ScaledDIBSectionBuffer::setSize(int src_width_, int src_height_) {
   src_width = src_width_;
   src_height = src_height_;
-  setScale(scale_ratio * 100);
+  if (scaling) {
+    src_buffer->setSize(src_width, src_height);
+  }
+  calculateScaledBufferSize();
+  recreateScaledBuffer();
+  scaled_data = data;
 }
 
 void ScaledDIBSectionBuffer::recreateScaledBuffer() {
@@ -58,3 +77,48 @@ void ScaledDIBSectionBuffer::recreateScaledBuffer() {
   DIBSectionBuffer::recreateBuffer();
   scaled_data = data;
 }
+
+void ScaledDIBSectionBuffer::fillRect(const Rect &dest, Pixel pix) {
+  if (scaling) {
+    src_buffer->fillRect(dest, pix);
+    scaleRect(dest);
+  } else {
+    DIBSectionBuffer::fillRect(dest, pix);
+  }
+}
+
+void ScaledDIBSectionBuffer::imageRect(const Rect &dest, const void* pixels, int stride) {
+  if (scaling) {
+    src_buffer->imageRect(dest, pixels, stride);
+    scaleRect(dest);
+  } else {
+    DIBSectionBuffer::imageRect(dest, pixels, stride);
+  }
+}
+
+void ScaledDIBSectionBuffer::copyRect(const Rect &dest, const Point &move_by_delta) {
+  if (scaling) {
+    src_buffer->copyRect(dest, move_by_delta);
+    scaleRect(dest);
+  } else {
+    DIBSectionBuffer::copyRect(dest, move_by_delta);
+  }
+}
+      
+void ScaledDIBSectionBuffer::maskRect(const Rect& r, const void* pixels, const void* mask_) {
+  if (scaling) {
+    src_buffer->maskRect(r, pixels, mask_);
+    scaleRect(r);
+  } else {
+    DIBSectionBuffer::maskRect(r, pixels, mask_);
+  }
+}
+
+void ScaledDIBSectionBuffer::maskRect(const Rect& r, Pixel pixel, const void* mask_) {
+  if (scaling) {
+    src_buffer->maskRect(r, pixel, mask_);
+    scaleRect(r);
+  } else {
+    DIBSectionBuffer::maskRect(r, pixel, mask_);
+  }
+}

diff --git a/rfb_win32/ScaledDIBSectionBuffer.h b/rfb_win32/ScaledDIBSectionBuffer.h
index c0dd5868b8c11eda430cd625e30b61286429f8ad..3cc267b2a3a4afb9714cf4bc244cc3f7042f934a 100644 (file)
--- a/rfb_win32/ScaledDIBSectionBuffer.h
+++ b/rfb_win32/ScaledDIBSectionBuffer.h
@@ -36,18 +36,30 @@ namespace rfb {
     // -=- ScaledDIBSectionBuffer
     //
 
-    class ScaledDIBSectionBuffer : public ScaledPixelBuffer, DIBSectionBuffer {
+    class ScaledDIBSectionBuffer : public ScaledPixelBuffer, public DIBSectionBuffer {
     public:
       ScaledDIBSectionBuffer(HWND window);
-      virtual ~ScaledDIBSectionBuffer() {};
+      virtual ~ScaledDIBSectionBuffer();
 
       int width()  const { return scaled_width; }
       int height() const { return scaled_height; }
       bool isScaling() const { return scaling; }
 
-      virtual void setSrcPixelBuffer(U8 **src_data, int w, int h, PixelFormat pf=PixelFormat());
       virtual void setPF(const PixelFormat &pf);
       virtual void setSize(int w, int h);
+      virtual void setScale(int scale);
+
+      Rect getRect() const { return ScaledPixelBuffer::getRect(); }
+      Rect getRect(const Point& pos) const { return ScaledPixelBuffer::getRect(pos); }
+
+      // -=- Overrides basic rendering operations of 
+      //     FullFramePixelBuffer class
+
+      virtual void fillRect(const Rect &dest, Pixel pix);
+      virtual void imageRect(const Rect &dest, const void* pixels, int stride=0);
+      virtual void copyRect(const Rect &dest, const Point &move_by_delta);
+      virtual void maskRect(const Rect& r, const void* pixels, const void* mask_);
+      virtual void maskRect(const Rect& r, Pixel pixel, const void* mask_);
 
     protected:
       virtual void recreateScaledBuffer();
@@ -55,6 +67,7 @@ namespace rfb {
         recreateScaledBuffer();
       };
 
+      ManagedPixelBuffer *src_buffer;
       bool scaling;
     };