diff --git a/src/Cxx/Qt/BorderWidgetQt.cxx b/src/Cxx/Qt/BorderWidgetQt.cxx
index 120bd7ab82ec0e215707ae0d5d58fa5c406e2395..1416a39095bebfee3ccd48fdb6aa4dbdfd8b003c 100644
--- a/src/Cxx/Qt/BorderWidgetQt.cxx
+++ b/src/Cxx/Qt/BorderWidgetQt.cxx
@@ -3,36 +3,33 @@
 #include <vtkBorderWidget.h>
 #include <vtkCommand.h>
 #include <vtkGenericOpenGLRenderWindow.h>
+#include <vtkNamedColors.h>
 #include <vtkNew.h>
 #include <vtkPolyDataMapper.h>
-#include <vtkRenderer.h>
+#include <vtkProperty.h>
 #include <vtkRenderWindow.h>
+#include <vtkRenderer.h>
 #include <vtkSmartPointer.h>
 #include <vtkSphereSource.h>
 
-class BorderCallback : public vtkCommand
-{
-  public:
-    BorderCallback(){}
+class BorderCallback : public vtkCommand {
+public:
+  BorderCallback() {}
 
-    static BorderCallback *New()
-    {
-      return new BorderCallback;
-    }
+  static BorderCallback *New() { return new BorderCallback; }
 
-  virtual void Execute(vtkObject *vtkNotUsed(caller), unsigned long, void*)
-  {
-//      vtkBorderWidget *borderWidget =
-//          reinterpret_cast<vtkBorderWidget*>(caller);
+  virtual void Execute(vtkObject *vtkNotUsed(caller), unsigned long, void *) {
+    //      vtkBorderWidget *borderWidget =
+    //          reinterpret_cast<vtkBorderWidget*>(caller);
   }
-
 };
 
 // Constructor
-BorderWidgetQt::BorderWidgetQt()
-{
+BorderWidgetQt::BorderWidgetQt() {
   this->setupUi(this);
 
+  vtkNew<vtkNamedColors> colors;
+
   vtkNew<vtkGenericOpenGLRenderWindow> renderWindow;
   this->qvtkWidget->SetRenderWindow(renderWindow);
 
@@ -43,10 +40,12 @@ BorderWidgetQt::BorderWidgetQt()
   sphereMapper->SetInputConnection(sphereSource->GetOutputPort());
   vtkNew<vtkActor> sphereActor;
   sphereActor->SetMapper(sphereMapper);
+  sphereActor->GetProperty()->SetColor(colors->GetColor4d("Tomato").GetData());
 
   // VTK Renderer
   vtkNew<vtkRenderer> renderer;
   renderer->AddActor(sphereActor);
+  renderer->SetBackground(colors->GetColor3d("SteelBlue").GetData());
 
   // Connect VTK with Qt
   this->qvtkWidget->GetRenderWindow()->AddRenderer(renderer);
diff --git a/src/Cxx/Qt/BorderWidgetQt.ui b/src/Cxx/Qt/BorderWidgetQt.ui
index 7c2fc86a2339f11910cb22879a33bef569d33da7..55d89da8c3f3834705aadba91f6126a9dd1f63f5 100644
--- a/src/Cxx/Qt/BorderWidgetQt.ui
+++ b/src/Cxx/Qt/BorderWidgetQt.ui
@@ -24,7 +24,7 @@
    </size>
   </property>
   <widget class="QWidget" name="centralwidget">
-   <widget class="QVTKOpenGLWidget" name="qvtkWidget" native="true">
+   <widget class="QVTKOpenGLNativeWidget" name="qvtkWidget" native="true">
     <property name="geometry">
      <rect>
       <x>10</x>
diff --git a/src/Cxx/Qt/BorderWidgetQtDriver.cxx b/src/Cxx/Qt/BorderWidgetQtDriver.cxx
index 874ce5abdf4f797d57b48d41c338b2d645ef8298..bff80974aec58309a0b7fa036f7babf758c48ed4 100644
--- a/src/Cxx/Qt/BorderWidgetQtDriver.cxx
+++ b/src/Cxx/Qt/BorderWidgetQtDriver.cxx
@@ -1,11 +1,13 @@
 #include <QApplication>
 #include <QSurfaceFormat>
+#include <QVTKOpenGLNativeWidget.h>
+
 #include "BorderWidgetQt.h"
 
 int main(int argc, char* argv[])
 {
   // needed to ensure appropriate OpenGL context is created for VTK rendering.
-  QSurfaceFormat::setDefaultFormat(QVTKOpenGLWidget::defaultFormat());
+  QSurfaceFormat::setDefaultFormat(QVTKOpenGLNativeWidget::defaultFormat());
 
   QApplication app( argc, argv );
 
diff --git a/src/Cxx/Qt/EventQtSlotConnect.cxx b/src/Cxx/Qt/EventQtSlotConnect.cxx
index a1f55c2290352ff6962f56773c2c3a3226b9bba1..40a6ae088b7aa6ad1f2ac19c9d09871448f2358f 100644
--- a/src/Cxx/Qt/EventQtSlotConnect.cxx
+++ b/src/Cxx/Qt/EventQtSlotConnect.cxx
@@ -1,19 +1,23 @@
 #include "EventQtSlotConnect.h"
 
 #include "vtkGenericOpenGLRenderWindow.h"
+#include <vtkEventQtSlotConnect.h>
+#include <vtkInteractorStyleTrackballActor.h>
+#include <vtkNamedColors.h>
 #include <vtkNew.h>
 #include <vtkPolyDataMapper.h>
-#include <vtkRenderer.h>
+#include <vtkProperty.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderWindowInteractor.h>
+#include <vtkRenderer.h>
 #include <vtkSphereSource.h>
-#include <vtkEventQtSlotConnect.h>
-#include <vtkInteractorStyleTrackballActor.h>
 
 // Constructor
-EventQtSlotConnect::EventQtSlotConnect()
-{
+EventQtSlotConnect::EventQtSlotConnect() {
   this->setupUi(this);
+
+  vtkNew<vtkNamedColors> colors;
+
   vtkNew<vtkGenericOpenGLRenderWindow> renderWindow;
   this->qvtkWidget->SetRenderWindow(renderWindow);
 
@@ -28,21 +32,22 @@ EventQtSlotConnect::EventQtSlotConnect()
 
   vtkNew<vtkActor> sphereActor;
   sphereActor->SetMapper(sphereMapper);
+  sphereActor->GetProperty()->SetColor(colors->GetColor4d("Tomato").GetData());
 
   // VTK Renderer
   vtkNew<vtkRenderer> renderer;
   renderer->AddActor(sphereActor);
+  renderer->SetBackground(colors->GetColor3d("SteelBlue").GetData());
 
   this->qvtkWidget->GetRenderWindow()->AddRenderer(renderer);
 
-  this->Connections->Connect(this->qvtkWidget->GetRenderWindow()->GetInteractor(),
-  vtkCommand::LeftButtonPressEvent,
-  this,
-  SLOT(slot_clicked(vtkObject*, unsigned long, void*, void*)));
-
+  this->Connections->Connect(
+      this->qvtkWidget->GetRenderWindow()->GetInteractor(),
+      vtkCommand::LeftButtonPressEvent, this,
+      SLOT(slot_clicked(vtkObject *, unsigned long, void *, void *)));
 };
 
-void EventQtSlotConnect::slot_clicked(vtkObject*, unsigned long, void*, void*)
-{
+void EventQtSlotConnect::slot_clicked(vtkObject *, unsigned long, void *,
+                                      void *) {
   std::cout << "Clicked." << std::endl;
 }
diff --git a/src/Cxx/Qt/ImageDataToQImage.cxx b/src/Cxx/Qt/ImageDataToQImage.cxx
index ffd26b777b02363e15afc469de04dc44a109c8cd..e498df434303ebcbb6d9748d2d46fc4bce67f429 100644
--- a/src/Cxx/Qt/ImageDataToQImage.cxx
+++ b/src/Cxx/Qt/ImageDataToQImage.cxx
@@ -1,26 +1,23 @@
 #include <vtkImageData.h>
 #include <vtkSmartPointer.h>
 
-#include <QImage>
-#include <QColor>
 #include <QApplication>
+#include <QColor>
+#include <QImage>
 
 // Create a green 50x50 imageData for demonstration purposes
-vtkSmartPointer<vtkImageData> createDemoImageData()
-{
+vtkSmartPointer<vtkImageData> createDemoImageData() {
   vtkSmartPointer<vtkImageData> image = vtkSmartPointer<vtkImageData>::New();
-  image->SetDimensions( 50, 50, 1 );
-  image->AllocateScalars( VTK_UNSIGNED_CHAR, 3 );
+  image->SetDimensions(50, 50, 1);
+  image->AllocateScalars(VTK_UNSIGNED_CHAR, 3);
 
   int width = image->GetDimensions()[0];
   int height = image->GetDimensions()[1];
 
-  for ( int y = 0; y < height; y++ )
-  {
-    for ( int x = 0; x < width; x++ )
-    {
+  for (int y = 0; y < height; y++) {
+    for (int x = 0; x < width; x++) {
       unsigned char *pixel =
-        static_cast<unsigned char *>( image->GetScalarPointer( x, y, 0 ) );
+          static_cast<unsigned char *>(image->GetScalarPointer(x, y, 0));
       pixel[0] = 0;
       pixel[1] = 255;
       pixel[2] = 0;
@@ -31,26 +28,24 @@ vtkSmartPointer<vtkImageData> createDemoImageData()
 }
 
 // The actual conversion code
-QImage vtkImageDataToQImage( vtkSmartPointer<vtkImageData> imageData )
-{
-  if ( !imageData ) { return QImage(); }
+QImage vtkImageDataToQImage(vtkSmartPointer<vtkImageData> imageData) {
+  if (!imageData) {
+    return QImage();
+  }
 
   /// \todo retrieve just the UpdateExtent
   int width = imageData->GetDimensions()[0];
   int height = imageData->GetDimensions()[1];
-  QImage image( width, height, QImage::Format_RGB32 );
-  QRgb *rgbPtr =
-    reinterpret_cast<QRgb *>( image.bits() ) + width * ( height - 1 );
+  QImage image(width, height, QImage::Format_RGB32);
+  QRgb *rgbPtr = reinterpret_cast<QRgb *>(image.bits()) + width * (height - 1);
   unsigned char *colorsPtr =
-    reinterpret_cast<unsigned char *>( imageData->GetScalarPointer() );
+      reinterpret_cast<unsigned char *>(imageData->GetScalarPointer());
 
   // Loop over the vtkImageData contents.
-  for ( int row = 0; row < height; row++ )
-  {
-    for ( int col = 0; col < width; col++ )
-    {
+  for (int row = 0; row < height; row++) {
+    for (int col = 0; col < width; col++) {
       // Swap the vtkImageData RGB values with an equivalent QColor
-      *( rgbPtr++ ) = QColor( colorsPtr[0], colorsPtr[1], colorsPtr[2] ).rgb();
+      *(rgbPtr++) = QColor(colorsPtr[0], colorsPtr[1], colorsPtr[2]).rgb();
       colorsPtr += imageData->GetNumberOfScalarComponents();
     }
 
@@ -60,12 +55,11 @@ QImage vtkImageDataToQImage( vtkSmartPointer<vtkImageData> imageData )
   return image;
 }
 
-int main( int argc, char *argv[] )
-{
-  QApplication app( argc, argv );
+int main(int argc, char *argv[]) {
+  QApplication app(argc, argv);
 
-  QImage qimage = vtkImageDataToQImage( createDemoImageData() );
-  qimage.save( "qimage.png" );
+  QImage qimage = vtkImageDataToQImage(createDemoImageData());
+  qimage.save("qimage.png");
 
   return EXIT_SUCCESS;
 }
diff --git a/src/Cxx/Qt/QImageToImageSource.cxx b/src/Cxx/Qt/QImageToImageSource.cxx
index 2ad01f95c647984f82d924f7560606e934d37e00..de6e354a8fd96b993f3de72fe9a23e1b2a1c111f 100644
--- a/src/Cxx/Qt/QImageToImageSource.cxx
+++ b/src/Cxx/Qt/QImageToImageSource.cxx
@@ -1,24 +1,23 @@
 #include <QApplication>
 #include <QPixmap>
 
-#include <vtkSmartPointer.h>
 #include <vtkQImageToImageSource.h>
+#include <vtkSmartPointer.h>
 
-int main(int argc, char *argv[])
-{
+int main(int argc, char *argv[]) {
   QApplication app(argc, argv);
-  
-  QPixmap pixmap(10,10);
-  QColor color(10,20,30);
+
+  QPixmap pixmap(10, 10);
+  QColor color(10, 20, 30);
   pixmap.fill(color);
-  
+
   vtkSmartPointer<vtkQImageToImageSource> qimageToImageSource =
-    vtkSmartPointer<vtkQImageToImageSource>::New();
+      vtkSmartPointer<vtkQImageToImageSource>::New();
   QImage qimage = pixmap.toImage();
   qimageToImageSource->SetQImage(&qimage);
   qimageToImageSource->Update();
 
-//  vtkImageData* image = qimageToImageSource->GetOutput();
+  //  vtkImageData* image = qimageToImageSource->GetOutput();
 
   return EXIT_SUCCESS;
 }
diff --git a/src/Cxx/Qt/QtBarChart.cxx b/src/Cxx/Qt/QtBarChart.cxx
index 1a1a2a640464401424275392791641c00cccdbf2..388bf1ba096697f517d1210793ac7901191e7969 100644
--- a/src/Cxx/Qt/QtBarChart.cxx
+++ b/src/Cxx/Qt/QtBarChart.cxx
@@ -72,6 +72,7 @@ int main(int, char*[] )
 
   // Finally render the scene and compare the image to a reference image
   view->GetRenderWindow()->SetMultiSamples(0);
+  view->GetRenderWindow()->SetWindowName("QtBarChart");
   view->GetInteractor()->Initialize();
   view->GetInteractor()->Start();
 
diff --git a/src/Cxx/Qt/RenderWindowNoUiFile.cxx b/src/Cxx/Qt/RenderWindowNoUiFile.cxx
index a41cb37621b64fba98dfaf282a8b5061ecce5085..4e42fc98d8f79c0dece1a7fb5509f6e14b76b0a2 100644
--- a/src/Cxx/Qt/RenderWindowNoUiFile.cxx
+++ b/src/Cxx/Qt/RenderWindowNoUiFile.cxx
@@ -2,40 +2,47 @@
 
 #include <vtkActor.h>
 #include <vtkGenericOpenGLRenderWindow.h>
+#include <vtkNamedColors.h>
 #include <vtkNew.h>
 #include <vtkPolyDataMapper.h>
+#include <vtkProperty.h>
 #include <vtkRenderWindow.h>
 #include <vtkRenderer.h>
 #include <vtkSphereSource.h>
 
-#include <QVTKOpenGLWidget.h>
 #include <QSurfaceFormat>
+#include <QVTKOpenGLNativeWidget.h>
 
-int main(int argc, char** argv)
-{
+int main(int argc, char **argv) {
   // needed to ensure appropriate OpenGL context is created for VTK rendering.
-  QSurfaceFormat::setDefaultFormat(QVTKOpenGLWidget::defaultFormat());
+  QSurfaceFormat::setDefaultFormat(QVTKOpenGLNativeWidget::defaultFormat());
 
   QApplication app(argc, argv);
 
-  QVTKOpenGLWidget widget;
+  QVTKOpenGLNativeWidget widget;
+
+  vtkNew<vtkNamedColors> colors;
+
   vtkNew<vtkGenericOpenGLRenderWindow> renderWindow;
   widget.SetRenderWindow(renderWindow);
 
-  widget.resize( 256, 256 );
+  widget.resize(600, 600);
 
   vtkNew<vtkSphereSource> sphereSource;
 
   vtkNew<vtkPolyDataMapper> sphereMapper;
-  sphereMapper->SetInputConnection( sphereSource->GetOutputPort() );
+  sphereMapper->SetInputConnection(sphereSource->GetOutputPort());
 
   vtkNew<vtkActor> sphereActor;
-  sphereActor->SetMapper( sphereMapper );
+  sphereActor->SetMapper(sphereMapper);
+  sphereActor->GetProperty()->SetColor(colors->GetColor4d("Tomato").GetData());
 
   vtkNew<vtkRenderer> renderer;
-  renderer->AddActor( sphereActor );
+  renderer->AddActor(sphereActor);
+  renderer->SetBackground(colors->GetColor3d("SteelBlue").GetData());
 
-  widget.GetRenderWindow()->AddRenderer( renderer );
+  widget.GetRenderWindow()->AddRenderer(renderer);
+  widget.GetRenderWindow()->SetWindowName("RenderWindowNoUIFile");
   widget.show();
 
   app.exec();
diff --git a/src/Cxx/Qt/RenderWindowUIMultipleInheritance.cxx b/src/Cxx/Qt/RenderWindowUIMultipleInheritance.cxx
index 6c51cf63265836a276f361e9f2332376bc343382..5d9d641d24a2eb4cb715b5150a00c7bbdeeb2b7d 100644
--- a/src/Cxx/Qt/RenderWindowUIMultipleInheritance.cxx
+++ b/src/Cxx/Qt/RenderWindowUIMultipleInheritance.cxx
@@ -1,45 +1,47 @@
 #include "RenderWindowUIMultipleInheritance.h"
 
 #include <vtkGenericOpenGLRenderWindow.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkPolyDataMapper.h>
-#include <vtkRenderer.h>
+#include <vtkProperty.h>
 #include <vtkRenderWindow.h>
-#include <vtkSphereSource.h>
+#include <vtkRenderer.h>
 #include <vtkSmartPointer.h>
+#include <vtkSphereSource.h>
 
 // Constructor
-RenderWindowUIMultipleInheritance::RenderWindowUIMultipleInheritance()
-{
+RenderWindowUIMultipleInheritance::RenderWindowUIMultipleInheritance() {
   this->setupUi(this);
 
+  vtkNew<vtkNamedColors> colors;
+
   vtkNew<vtkGenericOpenGLRenderWindow> renderWindow;
   qvtkWidget->SetRenderWindow(renderWindow);
 
   // Sphere
   vtkSmartPointer<vtkSphereSource> sphereSource =
-    vtkSmartPointer<vtkSphereSource>::New();
+      vtkSmartPointer<vtkSphereSource>::New();
   sphereSource->Update();
   vtkSmartPointer<vtkPolyDataMapper> sphereMapper =
-    vtkSmartPointer<vtkPolyDataMapper>::New();
+      vtkSmartPointer<vtkPolyDataMapper>::New();
   sphereMapper->SetInputConnection(sphereSource->GetOutputPort());
-  vtkSmartPointer<vtkActor> sphereActor =
-    vtkSmartPointer<vtkActor>::New();
+  vtkSmartPointer<vtkActor> sphereActor = vtkSmartPointer<vtkActor>::New();
   sphereActor->SetMapper(sphereMapper);
+  sphereActor->GetProperty()->SetColor(colors->GetColor4d("Tomato").GetData());
 
   // VTK Renderer
-  vtkSmartPointer<vtkRenderer> renderer =
-    vtkSmartPointer<vtkRenderer>::New();
+  vtkSmartPointer<vtkRenderer> renderer = vtkSmartPointer<vtkRenderer>::New();
   renderer->AddActor(sphereActor);
+  renderer->SetBackground(colors->GetColor3d("SteelBlue").GetData());
 
   // VTK/Qt wedded
   this->qvtkWidget->GetRenderWindow()->AddRenderer(renderer);
+  this->qvtkWidget->GetRenderWindow()->SetWindowName(
+      "RenderWindowUIMultipleInheritance");
 
   // Set up action signals and slots
   connect(this->actionExit, SIGNAL(triggered()), this, SLOT(slotExit()));
-
 };
 
-void RenderWindowUIMultipleInheritance::slotExit()
-{
-  qApp->exit();
-}
+void RenderWindowUIMultipleInheritance::slotExit() { qApp->exit(); }
diff --git a/src/Cxx/Qt/RenderWindowUIMultipleInheritanceDriver.cxx b/src/Cxx/Qt/RenderWindowUIMultipleInheritanceDriver.cxx
index e2cc345c34d0443578c90dc619d290a33d1a1728..e7b6bc6ad88f12e427bfdf9ec0e2d411c782dcda 100644
--- a/src/Cxx/Qt/RenderWindowUIMultipleInheritanceDriver.cxx
+++ b/src/Cxx/Qt/RenderWindowUIMultipleInheritanceDriver.cxx
@@ -1,12 +1,14 @@
 #include <QApplication>
 #include <QSurfaceFormat>
+#include <QVTKOpenGLNativeWidget.h>
+
 #include "RenderWindowUIMultipleInheritance.h"
 
 
 int main(int argc, char** argv)
 {
   // needed to ensure appropriate OpenGL context is created for VTK rendering.
-  QSurfaceFormat::setDefaultFormat(QVTKOpenGLWidget::defaultFormat());
+  QSurfaceFormat::setDefaultFormat(QVTKOpenGLNativeWidget::defaultFormat());
 
   QApplication app(argc, argv);
 
diff --git a/src/Cxx/Qt/RenderWindowUISingleInheritance.cxx b/src/Cxx/Qt/RenderWindowUISingleInheritance.cxx
index 736513ffcbcb8100ee946ee606465071669c5a78..7043f8c7532bbb86e4e6e1bf91a362a669b43c4c 100644
--- a/src/Cxx/Qt/RenderWindowUISingleInheritance.cxx
+++ b/src/Cxx/Qt/RenderWindowUISingleInheritance.cxx
@@ -5,22 +5,24 @@
 #include "ui_RenderWindowUISingleInheritance.h"
 
 #include <vtkGenericOpenGLRenderWindow.h>
+#include <vtkNamedColors.h>
 #include <vtkNew.h>
 #include <vtkPolyDataMapper.h>
-#include <vtkRenderer.h>
+#include <vtkProperty.h>
 #include <vtkRenderWindow.h>
+#include <vtkRenderer.h>
 #include <vtkSphereSource.h>
 
 // Constructor
-RenderWindowUISingleInheritance::RenderWindowUISingleInheritance()
-{
+RenderWindowUISingleInheritance::RenderWindowUISingleInheritance() {
   this->ui = new Ui_RenderWindowUISingleInheritance;
   this->ui->setupUi(this);
 
+  vtkNew<vtkNamedColors> colors;
+
   vtkNew<vtkGenericOpenGLRenderWindow> renderWindow;
   this->ui->qvtkWidget->SetRenderWindow(renderWindow);
 
-
   // Sphere
   vtkNew<vtkSphereSource> sphereSource;
   sphereSource->Update();
@@ -28,20 +30,19 @@ RenderWindowUISingleInheritance::RenderWindowUISingleInheritance()
   sphereMapper->SetInputConnection(sphereSource->GetOutputPort());
   vtkNew<vtkActor> sphereActor;
   sphereActor->SetMapper(sphereMapper);
+  sphereActor->GetProperty()->SetColor(colors->GetColor4d("Tomato").GetData());
 
   // VTK Renderer
   vtkNew<vtkRenderer> renderer;
   renderer->AddActor(sphereActor);
+  renderer->SetBackground(colors->GetColor3d("SteelBlue").GetData());
 
   // VTK/Qt wedded
   this->ui->qvtkWidget->GetRenderWindow()->AddRenderer(renderer);
-
+  this->ui->qvtkWidget->GetRenderWindow()->SetWindowName(
+      "RenderWindowUISingleInheritance");
   // Set up action signals and slots
   connect(this->ui->actionExit, SIGNAL(triggered()), this, SLOT(slotExit()));
-
 }
 
-void RenderWindowUISingleInheritance::slotExit()
-{
-  qApp->exit();
-}
+void RenderWindowUISingleInheritance::slotExit() { qApp->exit(); }
diff --git a/src/Cxx/Qt/ShareCameraQt.cxx b/src/Cxx/Qt/ShareCameraQt.cxx
index 4b370041459bb9b220e51b172d93de2859d343d4..762fa2a920dbe4c02eda8f9c78cf17a5611dab81 100644
--- a/src/Cxx/Qt/ShareCameraQt.cxx
+++ b/src/Cxx/Qt/ShareCameraQt.cxx
@@ -1,53 +1,67 @@
 #include "ShareCameraQt.h"
 
+#include <vtkCamera.h>
 #include <vtkCommand.h>
+#include <vtkCubeSource.h>
 #include <vtkDataObjectToTable.h>
 #include <vtkElevationFilter.h>
 #include <vtkGenericOpenGLRenderWindow.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkPolyDataMapper.h>
+#include <vtkProperty.h>
 #include <vtkQtTableView.h>
-#include <vtkRenderer.h>
 #include <vtkRenderWindow.h>
-#include <vtkSphereSource.h>
-#include <vtkCubeSource.h>
-
+#include <vtkRenderer.h>
 #include <vtkSmartPointer.h>
+#include <vtkSphereSource.h>
 
 // Constructor
-ShareCameraQt::ShareCameraQt()
-{
+ShareCameraQt::ShareCameraQt() {
   this->setupUi(this);
 
+  vtkNew<vtkNamedColors> colors;
+
   vtkNew<vtkGenericOpenGLRenderWindow> renderWindowLeft;
   this->qvtkWidgetLeft->SetRenderWindow(renderWindowLeft);
   vtkNew<vtkGenericOpenGLRenderWindow> renderWindowRight;
   this->qvtkWidgetRight->SetRenderWindow(renderWindowRight);
 
-
   // Sphere
-  vtkSmartPointer<vtkSphereSource> sphereSource = vtkSmartPointer<vtkSphereSource>::New();
+  vtkSmartPointer<vtkSphereSource> sphereSource =
+      vtkSmartPointer<vtkSphereSource>::New();
   sphereSource->Update();
-  vtkSmartPointer<vtkPolyDataMapper> sphereMapper =vtkSmartPointer<vtkPolyDataMapper>::New();
+  vtkSmartPointer<vtkPolyDataMapper> sphereMapper =
+      vtkSmartPointer<vtkPolyDataMapper>::New();
   sphereMapper->SetInputConnection(sphereSource->GetOutputPort());
   vtkSmartPointer<vtkActor> sphereActor = vtkSmartPointer<vtkActor>::New();
   sphereActor->SetMapper(sphereMapper);
+  sphereActor->GetProperty()->SetColor(colors->GetColor4d("Tomato").GetData());
 
   // Cube
-  vtkSmartPointer<vtkCubeSource> cubeSource = vtkSmartPointer<vtkCubeSource>::New();
+  vtkSmartPointer<vtkCubeSource> cubeSource =
+      vtkSmartPointer<vtkCubeSource>::New();
   cubeSource->Update();
-  vtkSmartPointer<vtkPolyDataMapper> cubeMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
+  vtkSmartPointer<vtkPolyDataMapper> cubeMapper =
+      vtkSmartPointer<vtkPolyDataMapper>::New();
   cubeMapper->SetInputConnection(cubeSource->GetOutputPort());
   vtkSmartPointer<vtkActor> cubeActor = vtkSmartPointer<vtkActor>::New();
   cubeActor->SetMapper(cubeMapper);
+  cubeActor->GetProperty()->SetColor(
+      colors->GetColor4d("MediumSeaGreen").GetData());
 
   // VTK Renderer
-  vtkSmartPointer<vtkRenderer> leftRenderer = vtkSmartPointer<vtkRenderer>::New();
+  vtkSmartPointer<vtkRenderer> leftRenderer =
+      vtkSmartPointer<vtkRenderer>::New();
   leftRenderer->AddActor(sphereActor);
+  leftRenderer->SetBackground(colors->GetColor3d("LightSteelBlue").GetData());
 
-  vtkSmartPointer<vtkRenderer> rightRenderer = vtkSmartPointer<vtkRenderer>::New();
+  vtkSmartPointer<vtkRenderer> rightRenderer =
+      vtkSmartPointer<vtkRenderer>::New();
 
   // Add Actor to renderer
   rightRenderer->AddActor(cubeActor);
+  rightRenderer->SetBackground(colors->GetColor3d("LightSteelBlue").GetData());
 
   // VTK/Qt wedded
   this->qvtkWidgetLeft->GetRenderWindow()->AddRenderer(leftRenderer);
@@ -56,22 +70,24 @@ ShareCameraQt::ShareCameraQt()
   rightRenderer->ResetCamera();
   leftRenderer->ResetCamera();
 
+  // Here we share the camera
   rightRenderer->SetActiveCamera(leftRenderer->GetActiveCamera());
 
+  // Position the cube using the left renderer active camera
+  leftRenderer->GetActiveCamera()->SetPosition(1.0, 0.8, 1.0);
+  leftRenderer->GetActiveCamera()->SetFocalPoint(0, 0, 0);
+  leftRenderer->ResetCamera();
+  leftRenderer->GetActiveCamera()->Zoom(0.8);
+
   // Set up action signals and slots
   connect(this->actionExit, SIGNAL(triggered()), this, SLOT(slotExit()));
 
-  //this->qvtkWidgetLeft->GetRenderWindow()->AddObserver(vtkCommand::ModifiedEvent, this, &ShareCameraQt::ModifiedHandler);
-  this->qvtkWidgetLeft->GetRenderWindow()->AddObserver(vtkCommand::AnyEvent, this, &ShareCameraQt::ModifiedHandler);
-
+  this->qvtkWidgetLeft->GetRenderWindow()->AddObserver(
+      vtkCommand::ModifiedEvent, this, &ShareCameraQt::ModifiedHandler);
 }
 
-void ShareCameraQt::ModifiedHandler()
-{
+void ShareCameraQt::ModifiedHandler() {
   this->qvtkWidgetRight->GetRenderWindow()->Render();
 }
 
-void ShareCameraQt::slotExit()
-{
-  qApp->exit();
-}
+void ShareCameraQt::slotExit() { qApp->exit(); }
diff --git a/src/Cxx/Qt/ShareCameraQt.ui b/src/Cxx/Qt/ShareCameraQt.ui
index cda4f248b5320c3082f40ace35815b9495413f6c..9d1837355b04a065abe815fee8270df7cbb06e20 100644
--- a/src/Cxx/Qt/ShareCameraQt.ui
+++ b/src/Cxx/Qt/ShareCameraQt.ui
@@ -24,7 +24,7 @@
    </size>
   </property>
   <widget class="QWidget" name="centralwidget">
-   <widget class="QVTKOpenGLWidget" name="qvtkWidgetLeft">
+   <widget class="QVTKOpenGLNativeWidget" name="qvtkWidgetLeft">
     <property name="geometry">
      <rect>
       <x>10</x>
@@ -34,7 +34,7 @@
      </rect>
     </property>
    </widget>
-   <widget class="QVTKOpenGLWidget" name="qvtkWidgetRight">
+   <widget class="QVTKOpenGLNativeWidget" name="qvtkWidgetRight">
     <property name="geometry">
      <rect>
       <x>540</x>
diff --git a/src/Cxx/Qt/ShareCameraQtDriver.cxx b/src/Cxx/Qt/ShareCameraQtDriver.cxx
index f8e2a8068806968d6c02aaac93d3fc2a4348847f..39c66efd5f1f8b48559cb47b860e53f186939f61 100644
--- a/src/Cxx/Qt/ShareCameraQtDriver.cxx
+++ b/src/Cxx/Qt/ShareCameraQtDriver.cxx
@@ -1,13 +1,13 @@
 #include <QApplication>
 #include <QSurfaceFormat>
-#include <QVTKOpenGLWidget.h>
+#include <QVTKOpenGLNativeWidget.h>
 
 #include "ShareCameraQt.h"
 
 int main( int argc, char** argv )
 {
   // needed to ensure appropriate OpenGL context is created for VTK rendering.
-  QSurfaceFormat::setDefaultFormat(QVTKOpenGLWidget::defaultFormat());
+  QSurfaceFormat::setDefaultFormat(QVTKOpenGLNativeWidget::defaultFormat());
 
   // QT Stuff
   QApplication app( argc, argv );
diff --git a/src/Cxx/Qt/SideBySideRenderWindowsQt.cxx b/src/Cxx/Qt/SideBySideRenderWindowsQt.cxx
index 20d4626a79a5acb0a491759f813fa75c03ab249a..cc51b677520953417ceab305056e0b7b67d47720 100644
--- a/src/Cxx/Qt/SideBySideRenderWindowsQt.cxx
+++ b/src/Cxx/Qt/SideBySideRenderWindowsQt.cxx
@@ -1,60 +1,77 @@
 #include "SideBySideRenderWindowsQt.h"
 
+#include <vtkCamera.h>
+#include <vtkCubeSource.h>
 #include <vtkDataObjectToTable.h>
 #include <vtkElevationFilter.h>
-#include "vtkGenericOpenGLRenderWindow.h"
+#include <vtkGenericOpenGLRenderWindow.h>
+#include <vtkNamedColors.h>
+#include <vtkNew.h>
 #include <vtkPolyDataMapper.h>
 #include <vtkQtTableView.h>
-#include <vtkRenderer.h>
 #include <vtkRenderWindow.h>
-#include <vtkSphereSource.h>
-#include <vtkCubeSource.h>
+#include <vtkRenderer.h>
 #include <vtkSmartPointer.h>
+#include <vtkSphereSource.h>
 
 // Constructor
-SideBySideRenderWindowsQt::SideBySideRenderWindowsQt()
-{
+SideBySideRenderWindowsQt::SideBySideRenderWindowsQt() {
   this->setupUi(this);
 
+  vtkNew<vtkNamedColors> colors;
+
   vtkNew<vtkGenericOpenGLRenderWindow> renderWindowLeft;
   this->qvtkWidgetLeft->SetRenderWindow(renderWindowLeft);
 
   vtkNew<vtkGenericOpenGLRenderWindow> renderWindowRight;
   this->qvtkWidgetRight->SetRenderWindow(renderWindowRight);
 
-
   // Sphere
   vtkSmartPointer<vtkSphereSource> sphereSource =
       vtkSmartPointer<vtkSphereSource>::New();
+  sphereSource->SetPhiResolution(30);
+  sphereSource->SetThetaResolution(30);
   sphereSource->Update();
+  vtkNew<vtkElevationFilter> sphereElev;
+  sphereElev->SetInputConnection(sphereSource->GetOutputPort());
+  sphereElev->SetLowPoint(0, -1.0, 0);
+  sphereElev->SetHighPoint(0, 1.0, 0);
   vtkSmartPointer<vtkPolyDataMapper> sphereMapper =
       vtkSmartPointer<vtkPolyDataMapper>::New();
-  sphereMapper->SetInputConnection(sphereSource->GetOutputPort());
-  vtkSmartPointer<vtkActor> sphereActor =
-      vtkSmartPointer<vtkActor>::New();
+  sphereMapper->SetInputConnection(sphereElev->GetOutputPort());
+  vtkSmartPointer<vtkActor> sphereActor = vtkSmartPointer<vtkActor>::New();
   sphereActor->SetMapper(sphereMapper);
 
   // Cube
   vtkSmartPointer<vtkCubeSource> cubeSource =
       vtkSmartPointer<vtkCubeSource>::New();
   cubeSource->Update();
+  vtkNew<vtkElevationFilter> cubeElev;
+  cubeElev->SetInputConnection(cubeSource->GetOutputPort());
+  cubeElev->SetLowPoint(0, -1.0, 0);
+  cubeElev->SetHighPoint(0, 1.0, 0);
   vtkSmartPointer<vtkPolyDataMapper> cubeMapper =
       vtkSmartPointer<vtkPolyDataMapper>::New();
-  cubeMapper->SetInputConnection(cubeSource->GetOutputPort());
-  vtkSmartPointer<vtkActor> cubeActor =
-      vtkSmartPointer<vtkActor>::New();
+  cubeMapper->SetInputConnection(cubeElev->GetOutputPort());
+  vtkSmartPointer<vtkActor> cubeActor = vtkSmartPointer<vtkActor>::New();
   cubeActor->SetMapper(cubeMapper);
 
   // VTK Renderer
   vtkSmartPointer<vtkRenderer> leftRenderer =
       vtkSmartPointer<vtkRenderer>::New();
   leftRenderer->AddActor(sphereActor);
+  leftRenderer->SetBackground(colors->GetColor3d("LightSteelBlue").GetData());
 
   vtkSmartPointer<vtkRenderer> rightRenderer =
       vtkSmartPointer<vtkRenderer>::New();
 
   // Add Actor to renderer
   rightRenderer->AddActor(cubeActor);
+  rightRenderer->GetActiveCamera()->SetPosition(1.0, 0.8, 1.0);
+  rightRenderer->GetActiveCamera()->SetFocalPoint(0, 0, 0);
+  rightRenderer->SetBackground(colors->GetColor3d("LightSteelBlue").GetData());
+  rightRenderer->ResetCamera();
+  rightRenderer->GetActiveCamera()->Zoom(0.8);
 
   // VTK/Qt wedded
   this->qvtkWidgetLeft->GetRenderWindow()->AddRenderer(leftRenderer);
@@ -64,7 +81,4 @@ SideBySideRenderWindowsQt::SideBySideRenderWindowsQt()
   connect(this->actionExit, SIGNAL(triggered()), this, SLOT(slotExit()));
 }
 
-void SideBySideRenderWindowsQt::slotExit()
-{
-  qApp->exit();
-}
+void SideBySideRenderWindowsQt::slotExit() { qApp->exit(); }
diff --git a/src/Cxx/Qt/SideBySideRenderWindowsQt.ui b/src/Cxx/Qt/SideBySideRenderWindowsQt.ui
index 442283426324a3096d4e89ecfcdf3a2d28f5f178..e57eb51a6dba21245857465645c639311235ba90 100644
--- a/src/Cxx/Qt/SideBySideRenderWindowsQt.ui
+++ b/src/Cxx/Qt/SideBySideRenderWindowsQt.ui
@@ -24,7 +24,7 @@
    </size>
   </property>
   <widget class="QWidget" name="centralwidget">
-   <widget class="QVTKOpenGLWidget" name="qvtkWidgetLeft">
+   <widget class="QVTKOpenGLNativeWidget" name="qvtkWidgetLeft">
     <property name="geometry">
      <rect>
       <x>10</x>
@@ -34,7 +34,7 @@
      </rect>
     </property>
    </widget>
-   <widget class="QVTKOpenGLWidget" name="qvtkWidgetRight">
+   <widget class="QVTKOpenGLNativeWidget" name="qvtkWidgetRight">
     <property name="geometry">
      <rect>
       <x>540</x>
diff --git a/src/Cxx/Qt/SideBySideRenderWindowsQtDriver.cxx b/src/Cxx/Qt/SideBySideRenderWindowsQtDriver.cxx
index 1a8d68bdd42e9288e6cca16cbd83b64000ffa0fc..53c2239dfaf6aded4ff1cf51cdd7353b14446566 100644
--- a/src/Cxx/Qt/SideBySideRenderWindowsQtDriver.cxx
+++ b/src/Cxx/Qt/SideBySideRenderWindowsQtDriver.cxx
@@ -1,13 +1,13 @@
 #include <QApplication>
 #include <QSurfaceFormat>
 
-#include "QVTKOpenGLWidget.h"
+#include <QVTKOpenGLNativeWidget.h>
 #include "SideBySideRenderWindowsQt.h"
 
 int main( int argc, char** argv )
 {
   // needed to ensure appropriate OpenGL context is created for VTK rendering.
-  QSurfaceFormat::setDefaultFormat(QVTKOpenGLWidget::defaultFormat());
+  QSurfaceFormat::setDefaultFormat(QVTKOpenGLNativeWidget::defaultFormat());
 
   // QT Stuff
   QApplication app( argc, argv );