vtkWin32OpenGLRenderWindow.h

Go to the documentation of this file.

/*=========================================================================

Program:   Visualization Toolkit
Module:    vtkWin32OpenGL2RenderWindow.h

Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
All rights reserved.
See Copyright.txt or http://www.kitware.com/Copyright.htm for details.

This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
PURPOSE.  See the above copyright notice for more information.

=========================================================================*/
#ifndef vtkWin32OpenGLRenderWindow_h
#define vtkWin32OpenGLRenderWindow_h

#include "vtkRenderingOpenGL2Module.h" // For export macro
#include <stack> // for ivar
#include "vtkOpenGLRenderWindow.h"

#include "vtkWindows.h" // For windows API

class vtkIdList;

class VTKRENDERINGOPENGL2_EXPORT vtkWin32OpenGLRenderWindow : public vtkOpenGLRenderWindow
{
public:
  static vtkWin32OpenGLRenderWindow *New();
  vtkTypeMacro(vtkWin32OpenGLRenderWindow,vtkOpenGLRenderWindow);
  void PrintSelf(ostream& os, vtkIndent indent) override;

  void Start(void) override;

  void Frame(void) override;

  virtual void WindowInitialize(void);

  void Initialize(void) override;

  void Finalize(void) override;

  void SetFullScreen(vtkTypeBool) override;

  void WindowRemap(void) override;

  virtual void PrefFullScreen(void);


  void SetSize(int,int) override;
  void SetSize(int a[2]) override {vtkOpenGLRenderWindow::SetSize(a);};

  int *GetSize() VTK_SIZEHINT(2) override;


  void SetPosition(int,int) override;
  void SetPosition(int a[2]) override {vtkOpenGLRenderWindow::SetPosition(a);}

  int *GetScreenSize() VTK_SIZEHINT(2) override;

  int *GetPosition() VTK_SIZEHINT(2) override;

  void SetWindowName(const char *) override;

  void SetWindowInfo(const char *) override;

  void SetNextWindowInfo(const char *) override;

  void SetParentInfo(const char *) override;

  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;

  HWND GetWindowId();


  void SetWindowId(HWND);
  void SetWindowId(void *foo) override {this->SetWindowId((HWND)foo);}

  bool InitializeFromCurrentContext() override;

  bool GetPlatformSupportsRenderWindowSharing() override { return true; };


  void SetParentId(HWND);
  void SetParentId(void *foo) override {this->SetParentId((HWND)foo);}

  void SetContextId(HGLRC);    // hsr
  void SetDeviceContext(HDC);  // hsr

  void SetNextWindowId(HWND);

  void SetNextWindowId(void *arg) override;

  void SetStereoCapableWindow(vtkTypeBool capable) override;

  void MakeCurrent() override;

  bool IsCurrent() override;

  const char *ReportCapabilities() override;

  int IsDirect() override;

  int GetEventPending() override;


  virtual void SetupPalette(HDC hDC);
  virtual void SetupPixelFormatPaletteAndContext(
    HDC hDC, DWORD dwFlags, int debug,
    int bpp=16, int zbpp=16);

  void Clean();


  void HideCursor() override;
  void ShowCursor() override;
  void SetCursorPosition(int x, int y) override;

  void SetCurrentCursor(int) override;

  bool DetectDPI() override;

  void SetOffScreenRendering(vtkTypeBool offscreen) override;


  void PushContext() override;
  void PopContext() override;

  bool SetSwapControl(int i) override;

protected:
  vtkWin32OpenGLRenderWindow();
  ~vtkWin32OpenGLRenderWindow();

  HINSTANCE ApplicationInstance;
  HPALETTE  Palette;
  HPALETTE  OldPalette;
  HGLRC     ContextId;
  HDC       DeviceContext;
  BOOL      MFChandledWindow;
  HWND      WindowId;
  HWND      ParentId;
  HWND      NextWindowId;
  int       OwnWindow;
  int       ScreenSize[2];

  std::stack<HGLRC> ContextStack;
  std::stack<HDC> DCStack;

  int CreatingOffScreenWindow; // to avoid recursion (and memory leaks...)

  // message handler
  virtual LRESULT MessageProc(HWND hWnd, UINT message,
                              WPARAM wParam, LPARAM lParam);

  static LRESULT APIENTRY WndProc(HWND hWnd, UINT message,
                                  WPARAM wParam, LPARAM lParam);
  int CursorHidden;
  int ForceMakeCurrent;

  int WindowIdReferenceCount;
  void ResizeWhileOffscreen(int xsize, int ysize);
  void CreateAWindow() override;
  void DestroyWindow() override;
  void InitializeApplication();
  void CleanUpOffScreenRendering(void);
  void CreateOffScreenWindow(int width,int height);
  void CleanUpRenderers();
  void VTKRegisterClass();

private:
  vtkWin32OpenGLRenderWindow(const vtkWin32OpenGLRenderWindow&) = delete;
  void operator=(const vtkWin32OpenGLRenderWindow&) = delete;
};


#endif