nux-1.16.0
nux::GraphicsDisplay Class Reference
Inheritance diagram for nux::GraphicsDisplay:
nux::GraphicSystem nux::GraphicSystem

List of all members.

Classes

struct  _DndSourceFuncs

Public Types

typedef void(* GrabReleaseCallback )(bool replaced, void *user_data)
typedef void(* GrabReleaseCallback )(bool replaced, void *user_data)
typedef struct
nux::GraphicsDisplay::_DndSourceFuncs 
DndSourceFuncs

Public Member Functions

bool IsGfxInterfaceCreated ()
bool CreateOpenGLWindow (const TCHAR *WindowTitle, unsigned int WindowWidth, unsigned int WindowHeight, WindowStyle Style, const GraphicsDisplay *Parent, bool FullscreenFlag=false, bool create_rendering_data=true)
 Create a window with and OpenGL context.
bool CreateFromOpenGLWindow (HWND WindowHandle, HDC WindowDCHandle, HGLRC OpenGLRenderingContext)
 Create a GLWindow from a window and device context.
void DestroyOpenGLWindow ()
void SetWindowTitle (const TCHAR *Title)
void SetWindowSize (int width, int height)
void SetViewPort (int x, int y, int width, int height)
Point GetMouseScreenCoord ()
Point GetMouseWindowCoord ()
Point GetWindowCoord ()
Rect GetWindowGeometry ()
Rect GetNCWindowGeometry ()
void MakeGLContextCurrent (bool b=true)
void SwapBuffer (bool glswap=true)
void GetSystemEvent (Event *evt)
EventGetCurrentEvent ()
bool isWindowMinimized () const
void ShowWindow ()
void HideWindow ()
bool IsWindowVisible ()
void EnterMaximizeWindow ()
void ExitMaximizeWindow ()
HWND GetWindowHandle () const
HWND GetParentWindowHandle () const
HDC GetWindowHDC () const
bool IsChildWindow () const
bool HasVSyncSwapControl () const
void EnableVSyncSwapControl ()
void DisableVSyncSwapControl ()
float GetFrameTime () const
void ResetFrameTime ()
GraphicsEngineGetGraphicsEngine () const
GpuDeviceGetGpuDevice () const
bool StartOpenFileDialog (FileDialogOption &fdo)
bool StartSaveFileDialog (FileDialogOption &fdo)
bool StartColorDialog (ColorDialogOption &cdo)
void GetWindowSize (int &w, int &h)
int GetWindowWidth ()
int GetWindowHeight ()
void ResetWindowSize ()
 Get the window size and reset the GraphicsEngine and GpuDevice accordingly.
bool HasFrameBufferSupport ()
void SetWindowCursor (HCURSOR cursor)
HCURSOR GetWindowCursor () const
void ProcessForeignWin32Event (HWND hWnd, MSG msg, WPARAM wParam, LPARAM lParam, Event *event)
LRESULT ProcessWin32Event (HWND hWnd, t_u32 uMsg, WPARAM wParam, LPARAM lParam)
void PauseThreadGraphicsRendering ()
 Pause graphics rendering.
bool IsPauseThreadGraphicsRendering () const
bool GrabPointer (GrabReleaseCallback callback, void *data, bool replace_existing)
bool UngrabPointer (void *data)
bool PointerIsGrabbed ()
bool GrabKeyboard (GrabReleaseCallback callback, void *data, bool replace_existing)
bool UngrabKeyboard (void *data)
bool KeyboardIsGrabbed ()
void * KeyboardGrabData ()
void * PointerGrabData ()
GLEWContext * GetGLEWContext ()
WGLEWContext * GetWGLEWContext ()
bool HasXPendingEvent () const
Display * GetX11Display ()
bool IsGfxInterfaceCreated ()
bool CreateOpenGLWindow (const TCHAR *WindowTitle, unsigned int WindowWidth, unsigned int WindowHeight, WindowStyle Style, const GraphicsDisplay *Parent, bool FullscreenFlag=false, bool create_rendering_data=true)
 Create a window with and OpenGL context.
bool CreateFromOpenGLWindow (Display *X11Display, Window X11Window, GLXContext OpenGLContext)
 Create a GLWindow from a display and window created externally.
void DestroyOpenGLWindow ()
void SetWindowTitle (const TCHAR *Title)
void SetWindowSize (int width, int height)
 Set the window size.
void SetWindowPosition (int width, int height)
 Set the window position.
void SetViewPort (int x, int y, int width, int height)
 Set the OpenGL Viewport.
Point GetMouseScreenCoord ()
Point GetMouseWindowCoord ()
Point GetWindowCoord ()
Rect GetWindowGeometry ()
Rect GetNCWindowGeometry ()
void MakeGLContextCurrent ()
void SwapBuffer (bool glswap=true)
void GetSystemEvent (IEvent *evt)
int GetGlXMajor () const
int GetGlXMinor () const
IEventGetCurrentEvent ()
bool isWindowMinimized () const
void ShowWindow ()
void HideWindow ()
bool IsWindowVisible ()
void EnterMaximizeWindow ()
void ExitMaximizeWindow ()
Window GetWindowHandle () const
bool IsChildWindow () const
bool HasVSyncSwapControl () const
void EnableVSyncSwapControl ()
void DisableVSyncSwapControl ()
float GetFrameTime () const
void ResetFrameTime ()
GraphicsEngineGetGraphicsEngine () const
GpuDeviceGetGpuDevice () const
void GetDesktopSize (int &w, int &h)
void GetWindowSize (int &w, int &h)
int GetWindowWidth ()
int GetWindowHeight ()
void ResetWindowSize ()
 Get the window size and reset the GraphicsEngine and GpuDevice accordingly.
bool HasFrameBufferSupport ()
void PauseThreadGraphicsRendering ()
 Pause graphics rendering.
bool IsPauseThreadGraphicsRendering () const
void ProcessForeignX11Event (XEvent *xevent, IEvent *nux_event)
void ProcessXEvent (XEvent xevent, bool foreign)
void RecalcXYPosition (Window TheMainWindow, XEvent xevent, int &x, int &y)
void RecalcXYPosition (int x_root, int y_root, int &x_recalc, int &y_recalc)
void SendDndStatus (bool accept, DndAction action, Rect region)
void SendDndFinished (bool accepted, DndAction performed_action)
std::list< char * > GetDndMimeTypes ()
char * GetDndData (char *property)
void StartDndDrag (const DndSourceFuncs &funcs, void *user_data)
bool GrabPointer (GrabReleaseCallback callback, void *data, bool replace_existing)
bool UngrabPointer (void *data)
bool PointerIsGrabbed ()
bool GrabKeyboard (GrabReleaseCallback callback, void *data, bool replace_existing)
bool UngrabKeyboard (void *data)
bool KeyboardIsGrabbed ()
void * KeyboardGrabData ()
void * PointerGrabData ()
GLEWContext * GetGLEWContext ()
GLXEWContext * GetGLXEWContext ()
NString FindResourceLocation (const TCHAR *ResourceFileName, bool ErrorOnFail=false)
NString FindUITextureLocation (const TCHAR *ResourceFileName, bool ErrorOnFail=false)
NString FindShaderLocation (const TCHAR *ResourceFileName, bool ErrorOnFail=false)
NString FindFontLocation (const TCHAR *ResourceFileName, bool ErrorOnFail=false)
const std::vector< NString > & GetFontSearchPath () const
const std::vector< NString > & GetShaderSearchPath () const
const std::vector< NString > & GetUITextureSearchPath () const

Public Attributes

int m_num_device_modes
Eventevent_
IEventm_pEvent

Friends

class GraphicsEngine
class DisplayAccessController

Detailed Description

Definition at line 55 of file GraphicsDisplayWin.h.


Member Function Documentation

bool nux::GraphicsDisplay::CreateFromOpenGLWindow ( HWND  WindowHandle,
HDC  WindowDCHandle,
HGLRC  OpenGLRenderingContext 
)

Create a GLWindow from a window and device context.

Parameters:
WindowHandleProvided window.
WindowDCHandleProvided device context.
OpenGLRenderingContextAnd OpenGL rendering context.

Definition at line 511 of file GraphicsDisplayWin.cpp.

  {
    // Do not make the opengl context current
    // Do not swap the framebuffer
    // Do not clear the depth or color buffer
    // Do not enable/disable VSync

    m_hWnd = WindowHandle;
    _device_context = WindowDCHandle;
    _opengl_rendering_context = OpenGLRenderingContext;

    RECT rect;
    ::GetClientRect (m_hWnd, &rect);
    m_WindowSize = Size (rect.right - rect.left, rect.bottom - rect.top);
    m_ViewportSize = Size (rect.right - rect.left, rect.bottom - rect.top);

    // The opengl context should be made current by an external entity.

    m_GfxInterfaceCreated = true;
    m_DeviceFactory = new GpuDevice (m_ViewportSize.width, m_ViewportSize.height, BITFMT_R8G8B8A8,
      _device_context,
      _opengl_rendering_context);

    m_GraphicsContext = new GraphicsEngine (*this);

    InitGlobalGrabWindow ();

    return true;
  }
bool nux::GraphicsDisplay::CreateFromOpenGLWindow ( Display *  X11Display,
Window  X11Window,
GLXContext  OpenGLContext 
)

Create a GLWindow from a display and window created externally.

Parameters:
X11DisplayProvided display.
X11WindowProvided window.

Definition at line 554 of file GraphicsDisplayX11.cpp.

  {
    // Do not make the opengl context current
    // Do not swap the framebuffer
    // Do not clear the depth or color buffer
    // Do not enable/disbale VSync

    m_X11Display = X11Display;
    m_X11Window = X11Window;
    m_GLCtx = OpenGLContext;

    m_X11Screen = DefaultScreen (m_X11Display);

    Window root_return;
    int x_return, y_return;
    unsigned int width_return, height_return;
    unsigned int border_width_return;
    unsigned int depth_return;

    XGetGeometry (X11Display, X11Window, &root_return, &x_return, &y_return, &width_return, &height_return, &border_width_return, &depth_return);
    m_WindowSize = Size (width_return, height_return);
    m_WindowPosition = Point (x_return, y_return);

    m_ViewportSize = Size (width_return, height_return);

    m_GfxInterfaceCreated = true;

    // m_DeviceFactory = new GpuDevice (m_ViewportSize.GetWidth(), m_ViewportSize.GetHeight(), BITFMT_R8G8B8A8);
    m_DeviceFactory = new GpuDevice (m_ViewportSize.width, m_ViewportSize.height, BITFMT_R8G8B8A8,
        m_X11Display,
        m_X11Window,
        false,
        _fb_config,
        m_GLCtx,
        1, 0, false);
    m_GraphicsContext = new GraphicsEngine (*this);

    InitGlobalGrabWindow ();

    m_CreatedFromForeignWindow = true;

    return true;
  }
bool nux::GraphicsDisplay::CreateOpenGLWindow ( const TCHAR *  WindowTitle,
unsigned int  WindowWidth,
unsigned int  WindowHeight,
WindowStyle  Style,
const GraphicsDisplay Parent,
bool  FullscreenFlag = false,
bool  create_rendering_data = true 
)

Create a window with and OpenGL context.

Parameters:
WindowTitleThe window title.
WindowWidthInitial window width.
WindowHeightInitial window height.
StyleThe window style.
ParentWindowThe parent window.
FullscreenFlagFull screen flag.

Definition at line 167 of file GraphicsDisplayWin.cpp.

Referenced by nux::DisplayAccessController::CreateGLWindow().

  {
    NScopeLock Scope (&CreateOpenGLWindow_CriticalSection);

    RECT                WindowRect;                             // Grabs Rectangle Upper Left / Lower Right Values

    m_GfxInterfaceCreated = false;

    // FIXME : put at the end
    m_ViewportSize.width = WindowWidth;
    m_ViewportSize.height = WindowHeight;
    m_WindowSize.width = WindowWidth;
    m_WindowSize.height = WindowHeight;

    // end of fixme

    WindowRect.left     = (long) 0;
    WindowRect.right    = (long) m_ViewportSize.width;
    WindowRect.top      = (long) 0;
    WindowRect.bottom   = (long) m_ViewportSize.height;

    m_fullscreen = FullscreenFlag;                                                              // Set The Global Fullscreen Flag
    m_index_of_current_mode = -1;                                                               // assume -1 if the mode is not fullscreen


    if (m_fullscreen)                                                                           // Attempt Fullscreen Mode?
    {
      // check if resolution is supported
      bool mode_supported = false;

      for (int num_modes = 0 ; num_modes < m_num_gfx_device_modes; num_modes++)
      {
        if ((m_gfx_device_modes[num_modes].width == m_ViewportSize.width)
             && (m_gfx_device_modes[num_modes].height == m_ViewportSize.height)
             && (m_gfx_device_modes[num_modes].format == m_ScreenBitDepth))
        {
          mode_supported = true;
          m_index_of_current_mode = num_modes;
          break;
        }
      }

      if (mode_supported == false)
      {
        if (inlWin32MessageBox (NULL, TEXT ("Info"), MBTYPE_Ok, MBICON_Information, MBMODAL_ApplicationModal,
                                TEXT ("The requested fullscreen mode is not supported by your monitor.\nUsing windowed mode instead.") ) == MBRES_Yes)
        {
          m_fullscreen = FALSE;         // Windowed Mode Selected.  Fullscreen = FALSE
        }
      }

      DEVMODE dmScreenSettings;                                               // Device Mode
      memset (&dmScreenSettings, 0, sizeof (dmScreenSettings));               // Makes Sure Memory's Cleared
      dmScreenSettings.dmSize = sizeof (dmScreenSettings);                    // Size Of The Devmode Structure
      dmScreenSettings.dmPelsWidth      = m_ViewportSize.width;                   // Selected Screen Width
      dmScreenSettings.dmPelsHeight     = m_ViewportSize.height;                  // Selected Screen Height
      dmScreenSettings.dmBitsPerPel     = m_ScreenBitDepth;                              // Selected Bits Per Pixel
      dmScreenSettings.dmDisplayFrequency = 60;
      dmScreenSettings.dmFields = DM_BITSPERPEL | DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY;

      // Try To Set Selected Mode And Get Results.  NOTE: CDS_FULLSCREEN Gets Rid Of Start Bar.
      if (ChangeDisplaySettings (&dmScreenSettings, CDS_FULLSCREEN) != DISP_CHANGE_SUCCESSFUL)
      {
        if (inlWin32MessageBox (NULL, TEXT ("Info"), MBTYPE_Ok, MBICON_Information, MBMODAL_ApplicationModal,
                                TEXT ("The requested fullscreen mode is not supported by your monitor.\nUsing windowed mode instead.") ) == MBRES_Yes)
        {
          m_fullscreen = FALSE;                   // Windowed Mode Selected.  Fullscreen = FALSE
        }
        else
        {
          // Pop Up A Message Box Letting User Know The Program Is Closing.
          MessageBox (NULL, "Program Will Now Close.", "ERROR", MB_OK | MB_ICONSTOP);
        }
      }
    }

    m_dwExStyle = 0;
    m_dwStyle = 0;

    if (m_fullscreen)                                   // Are We Still In Fullscreen Mode?
    {
      m_dwExStyle = WS_EX_APPWINDOW;                    // Window Extended Style
      m_dwStyle = WS_POPUP;                             // Windows Style
      ShowCursor (FALSE);                              // Hide Mouse Pointer
    }
    else
    {
      // Window Extended Style
      m_dwExStyle = WS_EX_APPWINDOW | WS_EX_WINDOWEDGE;
      // Windows Style
      m_dwStyle = WS_OVERLAPPED;    // Creates an overlapped window. An overlapped window has a title bar and a border

      // See Win32 Window Hierarchy and Styles: http://msdn.microsoft.com/en-us/library/ms997562.aspx

      //WS_EX_APPWINDOW       // Forces a top-level window onto the taskbar when the window is visible
      //WS_EX_WINDOWEDGE      // Specifies that a window has a border with a raised edge

      //WS_POPUP      // Creates a pop-up window. This style cannot be used with the WS_CHILD style.
      //WS_SYSMENU    // Creates a window that has a window menu on its title bar. The WS_CAPTION style must also be specified.
      //WS_SIZEBOX    // Creates a window that has a sizing border. Same as the WS_THICKFRAME style.
      //WS_CAPTION    // Creates a window that has a title bar (includes the WS_BORDER style).

      m_Style = Style;

      if (Style == WINDOWSTYLE_TOOL)
      {
        m_dwExStyle = WS_EX_TOOLWINDOW;
        m_dwStyle = WS_CAPTION | WS_SYSMENU;
      }
      else if (Style == WINDOWSTYLE_DIALOG)
      {
        m_dwExStyle = WS_EX_DLGMODALFRAME;
        m_dwStyle = WS_CAPTION | WS_SYSMENU;
      }
      else if (Style == WINDOWSTYLE_NOBORDER)
      {
        m_dwExStyle = WS_EX_TOPMOST | WS_EX_TOOLWINDOW;
        m_dwStyle = WS_POPUP;
      }
      else if (Style == WINDOWSTYLE_PANEL)
      {
        m_dwExStyle = 0;           // Specifies that a window has a border with a raised edge
        m_dwStyle = WS_CAPTION | WS_SYSMENU | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_SIZEBOX;
      }
      else
      {
        // Normal Window: NormalWindow
        m_dwExStyle = WS_EX_APPWINDOW |   // Forces a top-level window onto the taskbar when the window is visible
                      WS_EX_WINDOWEDGE;   // Specifies that a window has a border with a raised edge

        m_dwStyle |= WS_CAPTION |         // Creates a window that has a title bar.
                     WS_SYSMENU |         // Creates a window that has a window menu on its title bar. The WS_CAPTION style must also be specified.
                     WS_THICKFRAME |      // Creates a window that has a sizing border.
                     WS_MINIMIZEBOX |     // Creates a window that has a minimize button.
                     WS_MAXIMIZEBOX |     // Creates a window that has a maximize button.
                     WS_BORDER;           // Creates a window that has a thin-line border.
      }
    }
    // The AdjustWindowRectEx function calculates the required size of the window rectangle,
    // based on the desired size of the client rectangle. The window rectangle can then be passed to
    // the CreateWindowEx function to create a window whose client area is the desired size.
    AdjustWindowRectEx (&WindowRect, m_dwStyle, FALSE, m_dwExStyle);    // Adjust Window To True Requested Size

    RECT rect;
    rect.top = 0;
    rect.bottom = WindowRect.bottom - WindowRect.top;
    rect.left = 0;
    rect.right = WindowRect.right - WindowRect.left;
    int WindowX = 0;
    int WindowY = 0;

    if (Parent)
    {
      m_ParentWindow = Parent->GetWindowHandle();
      GetWindowRect (m_ParentWindow, &rect);

      int width = rect.right - rect.left;
      int height = rect.bottom - rect.top;

      WindowX = rect.left + (width - (WindowRect.right - WindowRect.left) ) / 2;
      WindowY = rect.top + (height - (WindowRect.bottom - WindowRect.top) ) / 2;
    }
    else if (!m_fullscreen)
    {
      ClipOrCenterRectToMonitor (&rect, 0);
      WindowX = rect.left;
      WindowY = rect.top;
    }

    m_WindowTitle = WindowTitle;

    // Create The Window
    if (! (m_hWnd = ::CreateWindowEx (m_dwExStyle,                      // Extended Style For The Window
                                      WINDOW_CLASS_NAME,                  // Class Name
                                      m_WindowTitle.GetTCharPtr(),        // Window Title
                                      m_dwStyle |                           // Defined Window Style
                                      WS_CLIPSIBLINGS |                   // Required Window Style
                                      WS_CLIPCHILDREN,                    // Required Window Style
                                      WindowX, WindowY,                   // Window Position
                                      WindowRect.right - WindowRect.left, // Calculate Window Width
                                      WindowRect.bottom - WindowRect.top, // Calculate Window Height
                                      m_ParentWindow,                     // No Parent Window
                                      NULL,                               // No Menu
                                      gGLWindowManager.GetInstance(),     // Instance
                                      NULL) ) )                           // Dont Pass Anything To WM_CREATE
    {
      DestroyOpenGLWindow();
      MessageBox (NULL, TEXT ("Window Creation Error."), TEXT ("ERROR"), MB_OK | MB_ICONERROR);
                                                 // Return FALSE
    }

    static      PIXELFORMATDESCRIPTOR pfd =                             // pfd Tells Windows How We Want Things To Be
    {
      sizeof (PIXELFORMATDESCRIPTOR),                           // Size Of This Pixel Format Descriptor
      1,                                                                                        // Version Number
      PFD_DRAW_TO_WINDOW |                                              // Format Must Support Window
      PFD_SUPPORT_OPENGL |                                              // Format Must Support OpenGL
      PFD_DOUBLEBUFFER,                             // Must Support Double Buffering
      PFD_TYPE_RGBA,                                                            // Request An RGBA Format
      24,       //        cColorBits
      //        Specifies the number of color bitplanes in each color buffer.
      //        For RGBA pixel types, it is the size of the color buffer, excluding the alpha bitplanes.
      //        For color-index pixels, it is the size of the color-index buffer.


      0, //        cRedBits
      //        Specifies the number of red bitplanes in each RGBA color buffer.
      0, //        cRedShift
      //        Specifies the shift count for red bitplanes in each RGBA color buffer.
      0, //        cGreenBits
      //        Specifies the number of green bitplanes in each RGBA color buffer.
      0, //        cGreenShift
      //        Specifies the shift count for green bitplanes in each RGBA color buffer.
      0, //        cBlueBits
      //        Specifies the number of blue bitplanes in each RGBA color buffer.
      0, //        cBlueShift
      //        Specifies the shift count for blue bitplanes in each RGBA color buffer.

      0, //        cAlphaBits
      //        Specifies the number of alpha bitplanes in each RGBA color buffer. Alpha bitplanes are not supported.
      0, //        cAlphaShift
      //        Specifies the shift count for alpha bitplanes in each RGBA color buffer. Alpha bitplanes are not supported.

      0, //        cAccumBits
      //        Specifies the total number of bitplanes in the accumulation buffer.
      0, //        cAccumRedBits
      //        Specifies the number of red bitplanes in the accumulation buffer.
      0, //        cAccumGreenBits
      //        Specifies the number of green bitplanes in the accumulation buffer.
      0, //        cAccumBlueBits
      //        Specifies the number of blue bitplanes in the accumulation buffer.
      0, //        cAccumAlphaBits
      //        Specifies the number of alpha bitplanes in the accumulation buffer.
      24,//        cDepthBits
      //        Specifies the depth of the depth (z-axis) buffer.
      8, //        cStencilBits
      //        Specifies the depth of the stencil buffer.
      0, //        cAuxBuffers
      //        Specifies the number of auxiliary buffers. Auxiliary buffers are not supported.
      PFD_MAIN_PLANE,   //        iLayerType
      //        Ignored. Earlier implementations of OpenGL used this member, but it is no longer used.
      0, //        bReserved
      //        Specifies the number of overlay and underlay planes. Bits 0 through 3 specify up to 15 overlay planes and bits 4 through 7 specify up to 15 underlay planes.
      0, //        dwLayerMask
      //        Ignored. Earlier implementations of OpenGL used this member, but it is no longer used.
      0, //        dwVisibleMask
      //        Specifies the transparent color or index of an underlay plane. When the pixel type is RGBA, dwVisibleMask is a transparent RGB color value. When the pixel type is color index, it is a transparent index value.
      0, //        dwDamageMask
      //        Ignored. Earlier implementations of OpenGL used this member, but it is no longer used.
    };

    if (! (_device_context = GetDC (m_hWnd) ) ) // Did We Get A Device Context?
    {
      DestroyOpenGLWindow();
      MessageBox (NULL, TEXT ("Can't Create A GL Device Context."), TEXT ("ERROR"), MB_OK | MB_ICONERROR);
      return FALSE;
    }

    if (! (m_PixelFormat = ChoosePixelFormat (_device_context, &pfd) ) ) // Did Windows Find A Matching Pixel Format?
    {
      DestroyOpenGLWindow();
      MessageBox (NULL, TEXT ("Can't Find A Suitable PixelFormat."), TEXT ("ERROR"), MB_OK | MB_ICONERROR);
      return FALSE;
    }

    if (!SetPixelFormat (_device_context, m_PixelFormat, &pfd) )        // Are We Able To Set The Pixel Format?
    {
      DestroyOpenGLWindow();
      MessageBox (NULL, TEXT ("Can't Set The PixelFormat."), TEXT ("ERROR"), MB_OK | MB_ICONERROR);
      return FALSE;
    }

    if (! (_opengl_rendering_context = wglCreateContext (_device_context) ) )               // Are We Able To Get A Rendering Context?
    {
      DestroyOpenGLWindow();
      MessageBox (NULL, TEXT ("Can't Create A GL Rendering Context."), TEXT ("ERROR"), MB_OK | MB_ICONERROR);
      return FALSE;
    }

    if (sMainGLRC == 0)
    {
      sMainGLRC = _opengl_rendering_context;
      sMainDC = _device_context;
    }
    else
    {
//         wglMakeCurrent(_device_context, 0);
//         // Make the newly created context share it resources with all the other OpenGL context
//         if(wglShareLists(sMainGLRC, _opengl_rendering_context) == FALSE)
//         {
//             DWORD err = GetLastError();
//             DestroyOpenGLWindow();
//             MessageBox(NULL, TEXT("Can't share GL context."), TEXT("ERROR"), MB_OK|MB_ICONERROR);
//             return FALSE;
//         }
    }

    // This creates a  warning. It is a 64-bits compatibility issue.
    // When not in 64-bit you can disable the warning:
    // Project Properties --> C/C++ tab --> General --> Select "NO" for - Detect 64-bit Portability Issues.
    // See also SetWindowLongPtr
    SetWindowLongPtr (m_hWnd, GWLP_USERDATA, (NUX_PTRSIZE_LONG) this);

    //::ShowWindow(m_hWnd,SW_SHOW);                                             // Show The Window
    ::SetForegroundWindow (m_hWnd);                                             // Slightly Higher Priority
    ::SetFocus (m_hWnd);                                                                        // Sets Keyboard Focus To The Window

    MakeGLContextCurrent();
    glClearColor (0.0, 0.0, 0.0, 0.0);
    glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
    SwapBuffer();

    m_GfxInterfaceCreated = true;

    //m_GLEWContext = new GLEWContext();
    //m_WGLEWContext = new WGLEWContext();

    HGLRC new_opengl_rendering_context = _opengl_rendering_context;
    m_DeviceFactory = new GpuDevice (m_ViewportSize.width, m_ViewportSize.height, BITFMT_R8G8B8A8,
      _device_context,
      new_opengl_rendering_context,
      1, 0, false);

    if (new_opengl_rendering_context != 0)
    {
      _opengl_rendering_context = new_opengl_rendering_context;
    }

    m_GraphicsContext = new GraphicsEngine (*this, create_rendering_data);

    //EnableVSyncSwapControl();
    //DisableVSyncSwapControl();

    InitGlobalGrabWindow ();

    return true;
  }
bool nux::GraphicsDisplay::CreateOpenGLWindow ( const TCHAR *  WindowTitle,
unsigned int  WindowWidth,
unsigned int  WindowHeight,
WindowStyle  Style,
const GraphicsDisplay Parent,
bool  FullscreenFlag = false,
bool  create_rendering_data = true 
)

Create a window with and OpenGL context.

Parameters:
WindowTitleThe window title.
WindowWidthInitial window width.
WindowHeightInitial window height.
StyleThe window style.
ParentWindowThe parent window.
FullscreenFlagFull screen flag.
void nux::GraphicsDisplay::PauseThreadGraphicsRendering ( )

Pause graphics rendering.

Pause graphics rendering. This function also sets the current openGL context to 0 for this window. This is useful while a child window is being created and is sharing openGL objects with this context. For wglShareLists to work, both OpenGL context must be set to 0 in their respective thread. Send NUX_THREADMSG_START_RENDERING (PostThreadMessage) to this window to reactivate rendering.

Never call this function while doing rendering. Call it only when processing events.

Definition at line 2365 of file GraphicsDisplayWin.cpp.

  {
    m_PauseGraphicsRendering = true;
    MakeGLContextCurrent (false);
  }
void nux::GraphicsDisplay::PauseThreadGraphicsRendering ( )

Pause graphics rendering.

Pause graphics rendering. This function also sets the current openGL context to 0 for this window. This is useful while a child window is being created and is sharing openGL objects with this context. For wglShareLists to work, both OpenGL context must be set to 0 in their respective thread. Send NUX_THREADMSG_START_RENDERING (PostThreadMessage) to this window to reactivate rendering.

Never call this function while doing rendering. Call it only when processing events.

void nux::GraphicsDisplay::ResetWindowSize ( )

Get the window size and reset the GraphicsEngine and GpuDevice accordingly.

This is a passive way to set the window size through out the NuxGraphics system. This call gets the current window size and sets its accordingly to all sub-system.

See also:
SetWindowSize
void nux::GraphicsDisplay::ResetWindowSize ( )

Get the window size and reset the GraphicsEngine and GpuDevice accordingly.

This is a passive way to set the window size through out the NuxGraphics system. This call gets the current window size and sets its accordingly to all sub-system.

Definition at line 577 of file GraphicsDisplayWin.cpp.

  {
    RECT rect;
    ::GetClientRect (m_hWnd, &rect);
    m_WindowSize = Size (rect.right - rect.left, rect.bottom - rect.top);
    m_ViewportSize = Size (rect.right - rect.left, rect.bottom - rect.top);
  }
void nux::GraphicsDisplay::SetWindowSize ( int  width,
int  height 
)

Set the window size.

Actively set the window size to the provided parameters.

See also:
ResetWindowSize

The documentation for this class was generated from the following files:
 All Classes Namespaces Functions Variables Typedefs Enumerations Enumerator Friends