diff --git a/Qt/Components/pqMultiView.cxx b/Qt/Components/pqMultiView.cxx
index 12b9cc2..9197561 100644
--- a/Qt/Components/pqMultiView.cxx
+++ b/Qt/Components/pqMultiView.cxx
@@ -495,6 +495,129 @@ QWidget* pqMultiView::widgetOfIndex(Index index)
 }
 
 //-----------------------------------------------------------------------------
+//
+// This method computes values of ViewPosition and ViewSize for each
+// frame in the multiview.  The values are computed so that gaps
+// created by splitter handles and view titlebars are eliminated. 
+// This method calls the recursive method computeCompactSizesHelper.
+//
+// ViewPosition is stored as a QPoint and ViewSize is stored as a QSize.
+//
+void pqMultiView::computeCompactSizes(
+  QMap<pqMultiViewFrame*, QPair<QPoint,QSize> >& ViewInfo) const
+{
+  // Call the recursive helper method
+  this->computeCompactSizesHelper(
+    ViewInfo,
+    qobject_cast<QSplitter*>(this->getMultiViewWidget()),
+    0, 0, 0, 0);
+}
+
+//-----------------------------------------------------------------------------
+//
+// A recursive method to compute ViewSize and ViewPosition for each frame
+// in the multiview.  The multiview contains nested splitters which can
+// be thought of as a tree.  The strategy is to keep track of splitter handle
+// locations while visiting each node in depth first order.
+//
+// If there is a splitter handle on the right or bottom, then padding is added
+// to the right or bottom side.  If there is a splitter handle on the left
+// or top, then padding is added on the left or top and ViewPosition is adjusted
+// the same number of pixels as the padding.
+//
+void pqMultiView::computeCompactSizesHelper(
+  QMap<pqMultiViewFrame*, QPair<QPoint,QSize> >& ViewInfo,
+  QSplitter* splitter, int lflag, int rflag, int tflag, int bflag) const
+{
+  if (!splitter) // Check for null just in case
+    {
+    return;
+    }
+
+  // Get info about this splitter
+  int numFrames = splitter->count();
+  int handlePadding = splitter->handleWidth()/2;
+  Qt::Orientation orientation = splitter->orientation();
+
+  // For each widget in the splitter
+  for (int i = 0; i < numFrames; ++i)
+    {
+
+    // This is the logic that tracks splitter handle
+    // locations.  The flags rflag and bflag are
+    // incremented/decremented, while lflag and bflag
+    // are either 1 or 0.
+    if (i == 0)
+      {
+      if (orientation == Qt::Horizontal) rflag++;
+      if (orientation == Qt::Vertical) bflag++;
+      }
+    else if (i == 1)
+      {
+      if (orientation == Qt::Horizontal) lflag=1;
+      if (orientation == Qt::Vertical) tflag=1;
+      }
+    if (i == numFrames-1)
+      {
+      if (orientation == Qt::Horizontal) rflag--;
+      if (orientation == Qt::Vertical) bflag--;
+      }
+
+    // Get the child widget
+    QWidget * child = splitter->widget(i);
+
+    // The widget is either a splitter of a multi view frame
+    QSplitter * childSplitter = qobject_cast<QSplitter*>(child);
+    pqMultiViewFrame * childFrame = qobject_cast<pqMultiViewFrame*>(child);
+
+    if (childSplitter) // It's a splitter
+      {
+      // Recurse!
+      this->computeCompactSizesHelper(ViewInfo, childSplitter, lflag, rflag, tflag, bflag);
+      }
+    else if (childFrame)  // It's a multi view frame
+      {
+      // Get size of frame
+      QSize size = childFrame->size();
+
+      // Get the position of the frame
+      QPoint position =
+        childFrame->mapTo(this->getMultiViewWidget(), QPoint(0,0));
+
+      // Expand size and adjust position as needed
+      if (rflag)
+        {
+        size.rwidth() += handlePadding;
+        }
+      if (bflag)
+        {
+        size.rheight() += handlePadding;
+        }
+      if (lflag)
+        {
+        size.rwidth() += handlePadding;
+        position.rx() -= handlePadding;
+        }
+      if (tflag)
+        {
+        size.rheight() += handlePadding;
+        position.ry() -= handlePadding;
+        }
+
+      // Store the size and position in the map
+      ViewInfo[childFrame] = qMakePair(position, size);
+      }
+    }
+}
+
+//-----------------------------------------------------------------------------
+// Returns the top level splitter widget
+QWidget* pqMultiView::getMultiViewWidget() const
+{
+  return this->SplitterFrame->layout()->itemAt(0)->widget();
+}
+
+//-----------------------------------------------------------------------------
 Qt::Orientation pqMultiView::widgetOrientation(QWidget* _widget) const
 {
   QSplitter *splitter = qobject_cast<QSplitter *>(_widget->parentWidget());
diff --git a/Qt/Components/pqMultiView.h b/Qt/Components/pqMultiView.h
index 73ec68f..664cdb8 100644
--- a/Qt/Components/pqMultiView.h
+++ b/Qt/Components/pqMultiView.h
@@ -152,6 +152,11 @@ protected:
   QFrame* MaximizeFrame;
   pqMultiViewFrame* FillerFrame;
 
+  QWidget* getMultiViewWidget() const;
+  void computeCompactSizes(QMap<pqMultiViewFrame*, QPair<QPoint,QSize> >&) const;
+  void computeCompactSizesHelper(QMap<pqMultiViewFrame*, QPair<QPoint,QSize> >&,
+    QSplitter*, int, int, int, int) const;
+
 private:
   void saveSplitter(vtkPVXMLElement *element, QSplitter *splitter, int index);
   void restoreSplitter(QWidget *widget, vtkPVXMLElement *element);
diff --git a/Qt/Components/pqViewManager.cxx b/Qt/Components/pqViewManager.cxx
index b59e679..30e55f0 100644
--- a/Qt/Components/pqViewManager.cxx
+++ b/Qt/Components/pqViewManager.cxx
@@ -1016,6 +1016,66 @@ void pqViewManager::updateViewPositions()
     }
 
   emit this->endNonUndoableChanges();
+  this->updateCompactViewPositions();
+}
+
+
+//-----------------------------------------------------------------------------
+//
+// This method is called at the end of updateViewPositions().
+// This method tries to set the properties GUISizeCompact,
+// ViewPositionCompact, and ViewSizeCompact.  For now, only the
+// vtkSMIceTMultiDisplayRenderViewProxy has these properties.
+//
+void pqViewManager::updateCompactViewPositions()
+{
+  QMap<pqMultiViewFrame*, QPair<QPoint, QSize> > ViewInfo;
+  this->computeCompactSizes(ViewInfo);
+  QSize totalGUISize = this->getMultiViewWidget()->size();
+
+  /// GUISize, ViewSize and ViewPosition properties are managed
+  /// by the GUI, the undo/redo stack should not worry about 
+  /// the changes made to them.
+  emit this->beginNonUndoableChanges();
+
+  // Loop for each view
+  QList<pqMultiViewFrame*> frames = ViewInfo.keys();
+  foreach(pqMultiViewFrame* frame, frames)
+    {
+    pqView * view = this->getView(frame);
+    if (!view)
+      {
+      continue;
+      }
+    vtkSMIntVectorProperty* prop = 0;
+
+    // Set GUISize
+    prop = vtkSMIntVectorProperty::SafeDownCast(
+      view->getProxy()->GetProperty("GUISizeCompact"));
+    if(prop)
+      {
+      prop->SetElements2(totalGUISize.width(), totalGUISize.height());
+      }
+
+    // Set ViewPosition
+    prop = vtkSMIntVectorProperty::SafeDownCast(
+      view->getProxy()->GetProperty("ViewPositionCompact"));
+    if(prop)
+      {
+      QPoint pos = ViewInfo[frame].first;
+      prop->SetElements2(pos.x(), pos.y());
+      }
+
+    // Set ViewSize
+    prop = vtkSMIntVectorProperty::SafeDownCast(
+      view->getProxy()->GetProperty("ViewSizeCompact"));
+    if (prop)
+      {
+      QSize size = ViewInfo[frame].second;
+      prop->SetElements2(size.width(), size.height());
+      }
+    }
+  emit this->endNonUndoableChanges();
 }
 
 //-----------------------------------------------------------------------------
diff --git a/Qt/Components/pqViewManager.h b/Qt/Components/pqViewManager.h
index 1f6ebcf..2f6f72f 100644
--- a/Qt/Components/pqViewManager.h
+++ b/Qt/Components/pqViewManager.h
@@ -229,6 +229,11 @@ protected:
   /// on all view modules.
   void updateViewPositions();
 
+  /// Update the GUISize/WindowPosition properties
+  /// using compact values to produce gapless multi views
+  /// on the render server.
+  void updateCompactViewPositions();
+
   /// Updates the context menu.
   void updateConversionActions(pqMultiViewFrame* frame);
 
diff --git a/Servers/Filters/vtkPVDesktopDeliveryClient.cxx b/Servers/Filters/vtkPVDesktopDeliveryClient.cxx
index 8afa1b6..e4f662f 100644
--- a/Servers/Filters/vtkPVDesktopDeliveryClient.cxx
+++ b/Servers/Filters/vtkPVDesktopDeliveryClient.cxx
@@ -64,6 +64,10 @@ vtkPVDesktopDeliveryClient::vtkPVDesktopDeliveryClient()
   this->RemoteImageProcessingTime = 0.0;
   this->TransferTime = 0.0;
 
+  this->GUISizeCompact[0] = this->GUISizeCompact[1] = 0;
+  this->ViewSizeCompact[0] = this->ViewSizeCompact[1] = 0;
+  this->ViewPositionCompact[0] = this->ViewPositionCompact[1] = 0;
+
   vtkCallbackCommand *cbc = vtkCallbackCommand::New();
   cbc->SetClientData(this);
   cbc->SetCallback(vtkPVDesktopDeliveryClientReceiveImageCallback);
@@ -155,6 +159,9 @@ void vtkPVDesktopDeliveryClient::ComputeVisiblePropBounds(vtkRenderer *ren,
 //----------------------------------------------------------------------------
 void vtkPVDesktopDeliveryClient::CollectWindowInformation(vtkMultiProcessStream& stream)
 {
+  this->CollectWindowInformation2(stream);
+  return;
+/*
   this->Superclass::CollectWindowInformation(stream);
   vtkPVDesktopDeliveryServer::WindowGeometry winGeoInfo;
   if ((this->GUISize[0] == 0) || (this->GUISize[1] == 0))
@@ -180,6 +187,72 @@ void vtkPVDesktopDeliveryClient::CollectWindowInformation(vtkMultiProcessStream&
   squirtOptions.Enabled = this->Squirt;
   squirtOptions.CompressLevel = this->SquirtCompressionLevel;
   squirtOptions.Save(stream);
+*/
+}
+
+//----------------------------------------------------------------------------
+//
+// This method replaces the original SendWindowInformation.
+//
+// This method checks to see if GUISizeCompact has been set.
+// If it has been set, then this method sends GUISizeCompact,
+// ViewSizeCompact, and ViewPositionCompact to the server.
+//
+// If GUISizeCompact has not been set, this method will act
+// exactly as the original did. (sends GUISize and WindowPosition)
+//
+void vtkPVDesktopDeliveryClient::CollectWindowInformation2(vtkMultiProcessStream& stream)
+{
+  this->Superclass::CollectWindowInformation(stream);
+
+  vtkPVDesktopDeliveryServer::WindowGeometry winGeoInfo;
+
+  // If GUISizeCompact has been set to a non-zero value
+  // then we are using multi display, so we'll use the
+  // compact values to eliminate gaps on the server tile display.
+  if (this->GUISizeCompact[0] != 0 && this->GUISizeCompact[1] != 0)
+    {
+    winGeoInfo.GUISize[0] = this->GUISizeCompact[0];
+    winGeoInfo.GUISize[1] = this->GUISizeCompact[1];
+    winGeoInfo.ViewSize[0] = this->ViewSizeCompact[0];
+    winGeoInfo.ViewSize[1] = this->ViewSizeCompact[1];
+    winGeoInfo.Position[0] = this->ViewPositionCompact[0];
+    winGeoInfo.Position[1] = this->ViewPositionCompact[1];
+    }
+  else  // Use regular values
+    {
+    winGeoInfo.GUISize[0] = this->GUISize[0];
+    winGeoInfo.GUISize[1] = this->GUISize[1];
+    winGeoInfo.ViewSize[0] = this->RenderWindow->GetActualSize()[0];
+    winGeoInfo.ViewSize[1] = this->RenderWindow->GetActualSize()[0];
+    winGeoInfo.Position[0] = this->WindowPosition[0];
+    winGeoInfo.Position[1] = this->WindowPosition[1];
+    }
+
+  // Flip Y possition to lower left to make things easier for server.
+  winGeoInfo.Position[1] =
+    winGeoInfo.GUISize[1] - winGeoInfo.Position[1] - winGeoInfo.ViewSize[1];
+
+  // I'm not sure if this block is ever triggered, but for now lets leave it.
+  if ((winGeoInfo.GUISize[0] == 0) || (winGeoInfo.GUISize[1] == 0))
+    {
+    winGeoInfo.GUISize[0] = winGeoInfo.ViewSize[0];
+    winGeoInfo.GUISize[1] = winGeoInfo.ViewSize[1];
+    }
+
+  //printf("-----SendingWindowInformation-----\n");
+  //printf("  GuiSize: %d %d\n", winGeoInfo.GUISize[0], winGeoInfo.GUISize[1]);
+  //printf("  ViewPos: %d %d\n", winGeoInfo.Position[0], winGeoInfo.Position[1]);
+  //printf("  ViewSize: %d %d\n", winGeoInfo.ViewSize[0], winGeoInfo.ViewSize[1]);
+
+  winGeoInfo.Id = this->Id;
+  winGeoInfo.AnnotationLayer = this->AnnotationLayer;
+  winGeoInfo.Save(stream);
+
+  vtkPVDesktopDeliveryServer::SquirtOptions squirtOptions;
+  squirtOptions.Enabled = this->Squirt;
+  squirtOptions.CompressLevel = this->SquirtCompressionLevel;
+  squirtOptions.Save(stream);
 }
 
 //-----------------------------------------------------------------------------
diff --git a/Servers/Filters/vtkPVDesktopDeliveryClient.h b/Servers/Filters/vtkPVDesktopDeliveryClient.h
index 9ab89e6..b0a8564 100644
--- a/Servers/Filters/vtkPVDesktopDeliveryClient.h
+++ b/Servers/Filters/vtkPVDesktopDeliveryClient.h
@@ -153,6 +153,13 @@ public:
   vtkGetVector2Macro(GUISize, int);
   vtkSetVector2Macro(GUISize, int);
 
+  vtkGetVector2Macro(GUISizeCompact, int);
+  vtkSetVector2Macro(GUISizeCompact, int);
+  vtkGetVector2Macro(ViewSizeCompact, int);
+  vtkSetVector2Macro(ViewSizeCompact, int);
+  vtkGetVector2Macro(ViewPositionCompact, int);
+  vtkSetVector2Macro(ViewPositionCompact, int);
+
   virtual void SetImageReductionFactorForUpdateRate(double desiredUpdateRate);
   float GetZBufferValue(int x, int y);
 
@@ -175,6 +182,7 @@ protected:
   double TransferTime;
 
   virtual void CollectWindowInformation(vtkMultiProcessStream& stream);
+  virtual void CollectWindowInformation2(vtkMultiProcessStream& stream);
   virtual void CollectRendererInformation(vtkRenderer *, vtkMultiProcessStream&);
 
   // Squirt options (probably to be replaced later).
@@ -192,6 +200,10 @@ protected:
   int WindowPosition[2];
   int GUISize[2];
 
+  int GUISizeCompact[2];
+  int ViewSizeCompact[2];
+  int ViewPositionCompact[2];
+
   int ReceivedImageFromServer;
   vtkCommand *ReceiveImageCallback;
   
diff --git a/Servers/Filters/vtkPVDesktopDeliveryServer.cxx b/Servers/Filters/vtkPVDesktopDeliveryServer.cxx
index f23ecd4..a08950b 100644
--- a/Servers/Filters/vtkPVDesktopDeliveryServer.cxx
+++ b/Servers/Filters/vtkPVDesktopDeliveryServer.cxx
@@ -310,6 +310,8 @@ void vtkPVDesktopDeliveryServer::UseRendererSet(int id)
 bool vtkPVDesktopDeliveryServer::ProcessWindowInformation(
   vtkMultiProcessStream& stream)
 {
+  return this->ProcessWindowInformation2(stream);
+/*
   if (!this->Superclass::ProcessWindowInformation(stream))
     {
     return false;
@@ -351,6 +353,74 @@ bool vtkPVDesktopDeliveryServer::ProcessWindowInformation(
   this->Squirt = squirtOptions.Enabled;
   this->SquirtCompressionLevel = squirtOptions.CompressLevel;
   return true;
+*/
+}
+
+//----------------------------------------------------------------------------
+//
+// This method replaces the original ProcessWindowInformation(vtkMultiProcessStream&).
+//
+// In the original, this->ClientWindowSize is set to this->FullImageSize,
+// where this->FullImageSize was equal to client_render_window->GetActualSize()
+//
+// In this method, this->ClientWindowSize is set to winGeoInfo.ViewSize,
+// where winGeoInfo.ViewSize is sent by vtkPVDesktopDeliveryClient.
+// vtkPVDesktopDeliveryClient sets winGeoInfo.Viewsize to either
+// to client_render_window->GetActualSize(), or to the ivar
+// CompactViewSize if the ivar is available.  The ivar is only
+// available when using tile display (icetmultidisplay)
+// 
+//
+bool vtkPVDesktopDeliveryServer::ProcessWindowInformation2(
+  vtkMultiProcessStream& stream)
+{
+
+  if (!this->Superclass::ProcessWindowInformation(stream))
+    {
+    return false;
+    }
+
+  vtkPVDesktopDeliveryServer::WindowGeometry winGeoInfo;
+  if (!winGeoInfo.Restore(stream))
+    {
+    vtkErrorMacro("Failed to read WindowGeometry info.");
+    return false;
+    }
+
+  // Correct window size.
+  this->ClientWindowSize[0] = winGeoInfo.ViewSize[0];
+  this->ClientWindowSize[1] = winGeoInfo.ViewSize[1];
+  this->ClientRequestedImageSize[0] = this->ReducedImageSize[0];
+  this->ClientRequestedImageSize[1] = this->ReducedImageSize[1];
+  this->FullImageSize[0] = winGeoInfo.GUISize[0];
+  this->FullImageSize[1] = winGeoInfo.GUISize[1];
+  this->ReducedImageSize[0]
+    = (int)(this->FullImageSize[0]/this->ImageReductionFactor);
+  this->ReducedImageSize[1]
+    = (int)(this->FullImageSize[1]/this->ImageReductionFactor);
+  this->ClientWindowPosition[0] = winGeoInfo.Position[0];
+  this->ClientWindowPosition[1] = winGeoInfo.Position[1];
+  this->ClientGUISize[0] = winGeoInfo.GUISize[0];
+  this->ClientGUISize[1] = winGeoInfo.GUISize[1];
+
+  //printf("-----ReceiveWindowInformation-----\n");
+  //printf("  ViewSize: %d %d\n", this->ClientWindowSize[0], this->ClientWindowSize[1]);
+  //printf("  ViewPos: %d %d\n", this->ClientWindowPosition[0], this->ClientWindowPosition[1]);
+  //printf("  GuiSize: %d %d\n", this->ClientGUISize[0], this->ClientGUISize[1]);
+
+  this->AnnotationLayer = winGeoInfo.AnnotationLayer;
+
+  this->UseRendererSet(winGeoInfo.Id);
+
+  vtkPVDesktopDeliveryServer::SquirtOptions squirtOptions;
+  if (!squirtOptions.Restore(stream))
+    {
+    vtkErrorMacro("Failed to read SquirtOptions.");
+    return false;
+    }
+  this->Squirt = squirtOptions.Enabled;
+  this->SquirtCompressionLevel = squirtOptions.CompressLevel;
+  return true;
 }
 
 //-----------------------------------------------------------------------------
@@ -783,6 +853,7 @@ void vtkPVDesktopDeliveryServer::WindowGeometry::Save(vtkMultiProcessStream& str
   stream << vtkPVDesktopDeliveryServer::WINDOW_GEOMETRY_TAG;
   stream << this->Position[0] << this->Position[1]
     << this->GUISize[0] << this->GUISize[1]
+    << this->ViewSize[0] << this->ViewSize[1]
     << this->Id
     << this->AnnotationLayer;
 }
@@ -798,6 +869,7 @@ bool vtkPVDesktopDeliveryServer::WindowGeometry::Restore(vtkMultiProcessStream&
     }
   stream >> this->Position[0] >> this->Position[1]
     >> this->GUISize[0] >> this->GUISize[1]
+    >> this->ViewSize[0] >> this->ViewSize[1]
     >> this->Id
     >> this->AnnotationLayer;
   return true;
diff --git a/Servers/Filters/vtkPVDesktopDeliveryServer.h b/Servers/Filters/vtkPVDesktopDeliveryServer.h
index ed209c2..57d5879 100644
--- a/Servers/Filters/vtkPVDesktopDeliveryServer.h
+++ b/Servers/Filters/vtkPVDesktopDeliveryServer.h
@@ -134,6 +134,7 @@ public:
   struct WindowGeometry {
     int Position[2];
     int GUISize[2];
+    int ViewSize[2];
     int Id;
     int AnnotationLayer;
     void Save(vtkMultiProcessStream& stream);
@@ -185,6 +186,7 @@ protected:
   virtual void ReadReducedImage();
 
   virtual bool ProcessWindowInformation(vtkMultiProcessStream&);
+  virtual bool ProcessWindowInformation2(vtkMultiProcessStream&);
   virtual bool ProcessRendererInformation(vtkRenderer *, vtkMultiProcessStream&);
 
   int Squirt;
diff --git a/Servers/ServerManager/Resources/rendering.xml b/Servers/ServerManager/Resources/rendering.xml
index 87f51e9..97e67ad 100644
--- a/Servers/ServerManager/Resources/rendering.xml
+++ b/Servers/ServerManager/Resources/rendering.xml
@@ -4415,6 +4415,46 @@
         </Documentation>
       </DoubleVectorProperty>
 
+      <IntVectorProperty
+        name="ViewPositionCompact"
+        command="SetViewPositionCompact"
+        number_of_elements="2"
+        default_values="0 0"
+        update_self="1"
+        immediate_update="1">
+        <IntRangeDomain name="range" min="0 0" />
+        <Documentation>
+          Position of the view. This is useful in multiview configurations.
+        </Documentation>
+      </IntVectorProperty>
+
+      <IntVectorProperty
+        name="GUISizeCompact"
+        command="SetGUISizeCompact"
+        number_of_elements="2"
+        default_values="0 0"
+        update_self="1"
+        immediate_update="1">
+        <IntRangeDomain name="range" min="0 0" />
+        <Documentation>
+          Total GUI size when using mutliple views. This includes the sizes of
+          all view modules.
+        </Documentation>
+      </IntVectorProperty>
+
+      <IntVectorProperty
+        name="ViewSizeCompact"
+        command="SetViewSizeCompact"
+        number_of_elements="2"
+        default_values="0 0"
+        update_self="1"
+        immediate_update="1">
+        <IntRangeDomain name="range" min="0 0" />
+        <Documentation>
+          The ViewSize to use for gapless multi display on the server.
+        </Documentation>
+      </IntVectorProperty>
+
       <!-- End of IceTMultiDisplayRenderView -->
     </IceTMultiDisplayRenderViewProxy>
 
diff --git a/Servers/ServerManager/vtkSMIceTMultiDisplayRenderViewProxy.cxx b/Servers/ServerManager/vtkSMIceTMultiDisplayRenderViewProxy.cxx
index e16a031..e138f93 100644
--- a/Servers/ServerManager/vtkSMIceTMultiDisplayRenderViewProxy.cxx
+++ b/Servers/ServerManager/vtkSMIceTMultiDisplayRenderViewProxy.cxx
@@ -39,6 +39,10 @@ vtkSMIceTMultiDisplayRenderViewProxy::vtkSMIceTMultiDisplayRenderViewProxy()
   this->LastClientCollectionDecision = false;
   this->Information->Set(CLIENT_RENDER(), 1);
   this->Information->Set(CLIENT_COLLECT(), 0);
+
+  this->GUISizeCompact[0] = this->GUISizeCompact[1] = 0;
+  this->ViewSizeCompact[0] = this->ViewSizeCompact[1] = 0;
+  this->ViewPositionCompact[0] = this->ViewPositionCompact[1] = 0;
 }
 
 //-----------------------------------------------------------------------------
@@ -178,6 +182,43 @@ NewStrategyInternal(int dataType)
 }
 
 
+//----------------------------------------------------------------------------
+void vtkSMIceTMultiDisplayRenderViewProxy::SetGUISizeCompact(int x, int y)
+{
+  vtkProcessModule* pm = vtkProcessModule::GetProcessModule();
+  vtkClientServerStream stream;
+  stream  << vtkClientServerStream::Invoke 
+          << this->RenderSyncManager->GetID()
+          << "SetGUISizeCompact" << x << y
+          << vtkClientServerStream::End;
+  pm->SendStream(this->ConnectionID, vtkProcessModule::CLIENT, stream);
+}
+
+//----------------------------------------------------------------------------
+void vtkSMIceTMultiDisplayRenderViewProxy::SetViewPositionCompact(int x, int y)
+{
+  vtkProcessModule* pm = vtkProcessModule::GetProcessModule();
+  vtkClientServerStream stream;
+  stream  << vtkClientServerStream::Invoke 
+          << this->RenderSyncManager->GetID()
+          << "SetViewPositionCompact" << x << y
+          << vtkClientServerStream::End;
+  pm->SendStream(this->ConnectionID, vtkProcessModule::CLIENT, stream);
+}
+
+//----------------------------------------------------------------------------
+void vtkSMIceTMultiDisplayRenderViewProxy::SetViewSizeCompact(int x, int y)
+{
+  vtkProcessModule* pm = vtkProcessModule::GetProcessModule();
+  vtkClientServerStream stream;
+  stream  << vtkClientServerStream::Invoke 
+          << this->RenderSyncManager->GetID()
+          << "SetViewSizeCompact" << x << y
+          << vtkClientServerStream::End;
+  pm->SendStream(this->ConnectionID, vtkProcessModule::CLIENT, stream);
+}
+
+
 //-----------------------------------------------------------------------------
 void vtkSMIceTMultiDisplayRenderViewProxy::SetGUISize(int x, int y)
 {
@@ -219,3 +260,4 @@ void vtkSMIceTMultiDisplayRenderViewProxy::PrintSelf(ostream& os, vtkIndent inde
   os << indent << "TileDisplayCompositeThreshold: " 
     << this->TileDisplayCompositeThreshold << endl;
 }
+
diff --git a/Servers/ServerManager/vtkSMIceTMultiDisplayRenderViewProxy.h b/Servers/ServerManager/vtkSMIceTMultiDisplayRenderViewProxy.h
index 830b009..5d66ca4 100644
--- a/Servers/ServerManager/vtkSMIceTMultiDisplayRenderViewProxy.h
+++ b/Servers/ServerManager/vtkSMIceTMultiDisplayRenderViewProxy.h
@@ -68,6 +68,21 @@ public:
   // Overridden to pass the ViewPosition to the RenderSyncManager.
   virtual void SetViewPosition(int x, int y);
 
+  // Description:
+  //
+  virtual void SetGUISizeCompact(int x, int y);
+  vtkGetVector2Macro(GUISizeCompact, int);
+
+  // Description:
+  //
+  virtual void SetViewPositionCompact(int x, int y);
+  vtkGetVector2Macro(ViewPositionCompact, int);
+
+  // Description:
+  //
+  virtual void SetViewSizeCompact(int x, int y);
+  vtkGetVector2Macro(ViewSizeCompact, int);
+
 //BTX
 protected:
   vtkSMIceTMultiDisplayRenderViewProxy();
@@ -115,6 +130,11 @@ protected:
   double TileDisplayCompositeThreshold;
 
   bool LastClientCollectionDecision;
+
+  int GUISizeCompact[2];
+  int ViewSizeCompact[2];
+  int ViewPositionCompact[2];
+
 private:
   vtkSMIceTMultiDisplayRenderViewProxy(const vtkSMIceTMultiDisplayRenderViewProxy&); // Not implemented.
   void operator=(const vtkSMIceTMultiDisplayRenderViewProxy&); // Not implemented.