Merge topic 'add-missing-overrides'

71131313 Add missing overrides to windows rendering classes.

Acked-by: Kitware Robot <kwrobot@kitware.com>
Merge-request: !3467

Rendering/OpenGL2/vtkWin32OpenGLRenderWindow.h

@@ -37,17 +37,17 @@ class VTKRENDERINGOPENGL2_EXPORT vtkWin32OpenGLRenderWindow : public vtkOpenGLRe
 public:
   static vtkWin32OpenGLRenderWindow *New();
   vtkTypeMacro(vtkWin32OpenGLRenderWindow,vtkOpenGLRenderWindow);
-  void PrintSelf(ostream& os, vtkIndent indent);
+  void PrintSelf(ostream& os, vtkIndent indent) override;
 
   /**
    * Begin the rendering process.
    */
-  virtual void Start(void);
+  void Start(void) override;
 
   /**
    * End the rendering process and display the image.
    */
-  void Frame(void);
+  void Frame(void) override;
 
   /**
    * Create the window
@@ -60,24 +60,24 @@ public:
    * should be possible to call them multiple times, even changing WindowId
    * in-between.  This is what WindowRemap does.
    */
-  virtual void Initialize(void);
+  void Initialize(void) override;
 
   /**
    * Finalize the rendering window.  This will shutdown all system-specific
    * resources.  After having called this, it should be possible to destroy
    * a window that was used for a SetWindowId() call without any ill effects.
    */
-  virtual void Finalize(void);
+  void Finalize(void) override;
 
   /**
    * Change the window to fill the entire screen.
    */
-  virtual void SetFullScreen(int);
+  void SetFullScreen(int) override;
 
   /**
    * Remap the window.
    */
-  virtual void WindowRemap(void);
+  void WindowRemap(void) override;
 
   /**
    * Set the preferred window size to full screen.
@@ -88,102 +88,102 @@ public:
   /**
    * Set the size of the window in pixels.
    */
-  virtual void SetSize(int,int);
-  virtual void SetSize(int a[2]) {vtkOpenGLRenderWindow::SetSize(a);};
+  void SetSize(int,int) override;
+  void SetSize(int a[2]) override {vtkOpenGLRenderWindow::SetSize(a);}
   //@}
 
   /**
    * Get the current size of the window in pixels.
    */
-  virtual int *GetSize();
+  int *GetSize() override;
 
   //@{
   /**
    * Set the position of the window.
    */
-  virtual void SetPosition(int,int);
-  virtual void SetPosition(int a[2]) {vtkOpenGLRenderWindow::SetPosition(a);};
+  void SetPosition(int,int) override;
+  void SetPosition(int a[2]) override {vtkOpenGLRenderWindow::SetPosition(a);}
   //@}
 
   /**
    * Get the current size of the screen in pixels.
    */
-  virtual int *GetScreenSize();
+  int *GetScreenSize() override;
 
   /**
    * Get the position in screen coordinates of the window.
    */
-  virtual int *GetPosition();
+  int *GetPosition() override;
 
   /**
    * Set the name of the window. This appears at the top of the window
    * normally.
    */
-  virtual void SetWindowName(const char *);
+  void SetWindowName(const char *) override;
 
   /**
    * Set this RenderWindow's window id to a pre-existing window.
    */
-  void SetWindowInfo(char *);
+  void SetWindowInfo(char *) override;
 
   /**
    * Sets the WindowInfo that will be used after a WindowRemap.
    */
-  void SetNextWindowInfo(char *);
+  void SetNextWindowInfo(char *) override;
 
   /**
    * Sets the HWND id of the window that WILL BE created.
    */
-  void SetParentInfo(char *);
+  void SetParentInfo(char *) override;
 
-  virtual void *GetGenericDisplayId() {return (void *)this->ContextId;};
-  virtual void *GetGenericWindowId()  {return (void *)this->WindowId;};
-  virtual void *GetGenericParentId()  {return (void *)this->ParentId;};
-  virtual void *GetGenericContext()   {return (void *)this->DeviceContext;};
-  virtual void *GetGenericDrawable()  {return (void *)this->WindowId;};
-  virtual void SetDisplayId(void *);
+  void *GetGenericDisplayId() override {return (void *)this->ContextId;}
+  void *GetGenericWindowId() override {return (void *)this->WindowId;}
+  void *GetGenericParentId() override {return (void *)this->ParentId;}
+  void *GetGenericContext() override {return (void *)this->DeviceContext;}
+  void *GetGenericDrawable() override {return (void *)this->WindowId;}
+  void SetDisplayId(void *) override;
 
   /**
    * Get the window id.
    */
-  virtual HWND  GetWindowId();
+  HWND GetWindowId();
 
   //@{
   /**
    * Set the window id to a pre-existing window.
    */
-  virtual void  SetWindowId(HWND);
-  void  SetWindowId(void *foo) {this->SetWindowId((HWND)foo);};
+  void SetWindowId(HWND);
+  void SetWindowId(void *foo) override {this->SetWindowId((HWND)foo);}
   //@}
 
   /**
    * Initialize the render window from the information associated
    * with the currently activated OpenGL context.
    */
-  virtual bool InitializeFromCurrentContext();
+  bool InitializeFromCurrentContext() override;
 
   //@{
   /**
    * Set the window's parent id to a pre-existing window.
    */
-  virtual void  SetParentId(HWND);
-  void  SetParentId(void *foo) {this->SetParentId((HWND)foo);};
+  void SetParentId(HWND);
+  void SetParentId(void *foo) override {this->SetParentId((HWND)foo);}
   //@}
 
-  void  SetContextId(HGLRC);    // hsr
-  void  SetDeviceContext(HDC);  // hsr
+  void SetContextId(HGLRC);    // hsr
+  void SetDeviceContext(HDC);  // hsr
 
   /**
    * Set the window id of the new window once a WindowRemap is done.
    */
-  virtual void  SetNextWindowId(HWND);
+  void SetNextWindowId(HWND);
 
   /**
    * Set the window id of the new window once a WindowRemap is done.
    * This is the generic prototype as required by the vtkRenderWindow
    * parent.
    */
-  virtual void SetNextWindowId(void *arg);
+  void SetNextWindowId(void *arg) override;
 
   /**
    * Prescribe that the window be created in a stereo-capable mode. This
@@ -191,34 +191,34 @@ public:
    * overrides the superclass method since this class can actually check
    * whether the window has been realized yet.
    */
-  virtual void SetStereoCapableWindow(int capable);
+  void SetStereoCapableWindow(int capable) override;
 
   /**
    * Make this windows OpenGL context the current context.
    */
-  void MakeCurrent();
+  void MakeCurrent() override;
 
   /**
    * Tells if this window is the current OpenGL context for the calling thread.
    */
-  virtual bool IsCurrent();
+  bool IsCurrent() override;
 
   /**
    * Get report of capabilities for the render window
    */
-  const char *ReportCapabilities();
+  const char *ReportCapabilities() override;
 
   /**
    * Is this render window using hardware acceleration? 0-false, 1-true
    */
-  int IsDirect();
+  int IsDirect() override;
 
   /**
    * Check to see if a mouse button has been pressed or mouse wheel activated.
    * All other events are ignored by this method.
    * This is a useful check to abort a long render.
    */
-  virtual  int GetEventPending();
+  int GetEventPending() override;
 
   //@{
   /**
@@ -242,23 +242,23 @@ public:
    * Set cursor position in window (note that (0,0) is the lower left
    * corner).
    */
-  void HideCursor();
-  void ShowCursor();
-  void SetCursorPosition(int x, int y);
+  void HideCursor() override;
+  void ShowCursor() override;
+  void SetCursorPosition(int x, int y) override;
   //@}
 
   /**
    * Change the shape of the cursor
    */
-  virtual void SetCurrentCursor(int);
+  void SetCurrentCursor(int) override;
 
-  virtual bool DetectDPI();
+  bool DetectDPI() override;
 
   /**
    * Override the default implementation so that we can actively switch between
    * on and off screen rendering.
    */
-  virtual void SetOffScreenRendering(int offscreen);
+  void SetOffScreenRendering(int offscreen) override;
 
   //@{
   /**
@@ -268,8 +268,8 @@ public:
    * and when done releasing resources restore
    * the prior context
    */
-  virtual void PushContext();
-  virtual void PopContext();
+  void PushContext() override;
+  void PopContext() override;
   //@}
 
   /**
@@ -315,8 +315,8 @@ protected:
 
   int WindowIdReferenceCount;
   void ResizeWhileOffscreen(int xsize, int ysize);
-  virtual void CreateAWindow();
-  virtual void DestroyWindow();
+  void CreateAWindow() override;
+  void DestroyWindow() override;
   void InitializeApplication();
   void CleanUpOffScreenRendering(void);
   void CreateOffScreenWindow(int width,int height);

Rendering/OpenGL2/vtkWin32RenderWindowInteractor.h

@@ -48,12 +48,12 @@ public:
   static vtkWin32RenderWindowInteractor *New();
 
   vtkTypeMacro(vtkWin32RenderWindowInteractor,vtkRenderWindowInteractor);
-  void PrintSelf(ostream& os, vtkIndent indent);
+  void PrintSelf(ostream& os, vtkIndent indent) override;
 
   /**
    * Initialize the event handler
    */
-  virtual void Initialize();
+  void Initialize() override;
 
   //@{
   /**
@@ -65,8 +65,8 @@ public:
    * and all other interactors associated with the widget are disabled
    * when their data is not displayed.
    */
-  virtual void Enable();
-  virtual void Disable();
+  void Enable() override;
+  void Disable() override;
   //@}
 
   //@{
@@ -86,7 +86,7 @@ public:
    * calls PostQuitMessage(0) to terminate the application. An application can Specify
    * ExitMethod for alternative behavior (i.e. suppression of keyboard exit)
    */
-  void TerminateApp(void);
+  void TerminateApp(void) override;
 
   friend VTKRENDERINGOPENGL2_EXPORT LRESULT CALLBACK vtkHandleMessage(HWND hwnd,UINT uMsg, WPARAM w, LPARAM l);
   friend VTKRENDERINGOPENGL2_EXPORT LRESULT CALLBACK vtkHandleMessage2(HWND hwnd,UINT uMsg, WPARAM w, LPARAM l, vtkWin32RenderWindowInteractor *me);
@@ -131,7 +131,7 @@ public:
    * These methods correspond to the the Exit, User and Pick
    * callbacks. They allow for the Style to invoke them.
    */
-  virtual void ExitCallback();
+  void ExitCallback() override;
 
 protected:
   vtkWin32RenderWindowInteractor();
@@ -159,8 +159,8 @@ protected:
    * Win32-specific internal timer methods. See the superclass for detailed
    * documentation.
    */
-  virtual int InternalCreateTimer(int timerId, int timerType, unsigned long duration);
-  virtual int InternalDestroyTimer(int platformTimerId);
+  int InternalCreateTimer(int timerId, int timerType, unsigned long duration) override;
+  int InternalDestroyTimer(int platformTimerId) override;
   //@}
 
   /**
@@ -168,7 +168,7 @@ protected:
    * call this method it will loop processing events until the
    * application is exited.
    */
-  virtual void StartEventLoop();
+  void StartEventLoop() override;
 
 #ifdef VTK_USE_TDX
   vtkTDxWinDevice *Device;