screen.cpp

Go to the documentation of this file.

/* *************************************************************************************
        Writer:         Sebastien Bloc
        Copyright:      2003-2004
        eMail:          sebastien.bloc@free.fr
        URL:            http://mignonsoft.free.fr

        This program is free software; you can redistribute it and/or
        modify it under the terms of the GNU General Public License
        as published by the Free Software Foundation; either version 2
        of the License, or (at your option) any later version.

        This program is distributed in the hope that it will be useful,
        but WITHOUT ANY WARRANTY; without even the implied warranty of
        MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
        GNU General Public License for more details.
        http://www.gnu.org/copyleft/gpl.html
************************************************************************************* */

#include "screen.h"
#include "MyDebug.h"
#include "openGL_tools.h"

#define DEBUG_SCREEN(methode) MyDebug::SendEvent("screen",methode##"[t:%s,style:%d,styleEx:%d,dXNorm:%d,%d,dXCli:%d,%d]",(char *)title,dwStyle,dwExStyle,dxNormal,dyNormal,dxClient,dyClient)
//#define DEBUG_SCREEN(methode) // si on ne veut pas gerer de debuger

#define TEST(varType,msg) if ((dwStyle&varType)==varType) { for (int i=0;i<level;i++) message<<"| "; message<<msg<<"\n"; }
#define TEST_EX(varType,msg) if ((dwExStyle&varType)==varType) { for (int i=0;i<level;i++) message<<"| "; message<<msg<<"\n"; }

// pour eviter des subtilité de compilation (contenu dans windef.h)
#define WS_EX_COMPOSITED        0x02000000L
#define WS_EX_NOACTIVATE        0x08000000L
#define WS_EX_LAYERED           0x00080000

void Screen::ComputeDeltaClientToWindow()
{
        RECT rectClient,rectWindow;
        GetClientRect(hWnd,&rectClient);
        GetWindowRect(hWnd,&rectWindow);

        dxWC=(rectWindow.right-rectWindow.left)-(rectClient.right-rectClient.left);
        dyWC=(rectWindow.bottom-rectWindow.top)-(rectClient.bottom-rectClient.top);
}

#include <winuser.h>
void Screen::MsgInfoType()
{
        MyString message;

        int level=0;
        message.Format("Type=%ld, Ex=%ld\n",dwStyle,dwExStyle);
        message<<"STYLE:\n"; level++;
        BOOL overlappedWindow = (dwStyle&WS_OVERLAPPEDWINDOW)==WS_OVERLAPPEDWINDOW;
        BOOL popupWind = (dwStyle&WS_POPUPWINDOW)==WS_POPUPWINDOW;
        BOOL caption = (dwStyle&WS_CAPTION)==WS_CAPTION;
        TEST(WS_OVERLAPPEDWINDOW,"overlappedWindow: Creates an overlapped window.");
        TEST(WS_POPUPWINDOW,"popupWindow: Creates a pop-up window.");
        if (popupWind||overlappedWindow) level++;
        TEST(WS_CAPTION,"caption: title bar.");
        if (caption) level++;
        TEST(WS_BORDER,"border: thin-line border.");
        if (caption) level--;
        TEST(WS_OVERLAPPED,"overlapped: window has a title bar and a border.");
        TEST(WS_POPUP,"popupWindow: simple window (cannot used with the WS_CHILD).");
        TEST(WS_SYSMENU,"sysmenu: add menu on its title bar. (use WS_CAPTION).");
        TEST(WS_THICKFRAME,"tickFrame: add a sizing border.");
        TEST(WS_MAXIMIZEBOX,"maximizeBox: add max button. (use WS_SYSMENU , cannot WS_EX_CONTEXTHELP)");
        TEST(WS_MINIMIZEBOX,"minimizeBox: add min button. (use WS_SYSMENU , cannot WS_EX_CONTEXTHELP)"); 
        if (popupWind||overlappedWindow) level--;
        TEST(WS_CHILD ,"child: A window with this style cannot have a menu bar. (cannot used WS_POPUP)");
        TEST(WS_CLIPCHILDREN,"clipChildren: used when creating the parent window");
        TEST(WS_CLIPSIBLINGS,"clipSiblings: clips child windows relative to each other)");
        TEST(WS_DISABLED,"disable: initially disabled. He cannot receive input from the user. (cf EnableWindow)");
        TEST(WS_VISIBLE,"visible: initially visible.");
        TEST(WS_DLGFRAME,"dlgFrame: window that has a border of a style typically used with dialog boxes. (cannot have a title bar)");
        TEST(WS_GROUP,"group: Specifies the first control of a group of controls. (cf WS_TABSTOP style)");
        TEST(WS_TABSTOP,"tabStop: can receive the keyboard focus when the user presses the TAB key. (cf WS_TABSTOP style)"); 
        TEST(WS_HSCROLL,"hScroll: add horizontal scroll bar.");
        TEST(WS_VSCROLL,"vScroll: add vertical scroll bar.");
        TEST(WS_MAXIMIZE,"maxmize: initially maximized.");
        TEST(WS_MINIMIZE,"minimize: initially minimized.");

        message<<"STYLE_EX:\n"; 

        TEST_EX(WS_EX_RIGHT,"right: the window has generic.");
        TEST_EX(WS_EX_LEFT,"left: left-aligned properties.");

        DWORD paletteWindow = (dwStyle&WS_EX_PALETTEWINDOW)==WS_EX_PALETTEWINDOW;
        DWORD overlappedWindowEx = (dwStyle&WS_EX_PALETTEWINDOW)==WS_EX_PALETTEWINDOW;
        TEST_EX(WS_EX_PALETTEWINDOW,"paletteWindow: combines WS_EX_WINDOWEDGE, WS_EX_TOOLWINDOW, WS_EX_TOPMOST.");
        TEST_EX(WS_EX_OVERLAPPEDWINDOW,"overlappedWindow: combines WS_EX_CLIENTEDGE and WS_EX_WINDOWEDGE.");
        if (paletteWindow||overlappedWindowEx) level++;
        TEST_EX(WS_EX_WINDOWEDGE,"windowEdge: specifies that a window has a border with a raised edge.");
        TEST_EX(WS_EX_TOOLWINDOW,"toolWindow: creates a floating toolbar. (not appear in the taskbar.");
        TEST_EX(WS_EX_TOPMOST,"topMost: should be placed above all non-topmost windows and should stay above them.");
        TEST_EX(WS_EX_CLIENTEDGE,"clientEdge: border with a sunken edge.");
        if (paletteWindow||overlappedWindowEx) level--;
        TEST_EX(WS_EX_ACCEPTFILES,"acceptFiles: accepts drag-drop files.");
        TEST_EX(WS_EX_APPWINDOW,"appWindow: forces a top-level window onto the taskbar when the window is visible.");
        TEST_EX(WS_EX_COMPOSITED,"composited: paints all descendants of a window in bottom-to-top painting order using double-buffering. ");
        TEST_EX(WS_EX_CONTEXTHELP,"contextHelp: Add a question mark in the title bar ( cannot use WS_MAXIMIZEBOX or WS_MINIMIZEBOX)");
        TEST_EX(WS_EX_CONTROLPARENT,"controlParent: contains itself a child windows that should take part in dialog box navigation.");
        TEST_EX(WS_EX_DLGMODALFRAME,"dlgModalFrame: use double border.");
        TEST_EX(WS_EX_LAYERED,"layered: layered window. (cannot used with child)");
        TEST_EX(WS_EX_LAYOUTRTL,"layoutRTL: Arabic and Hebrew versions." );
        TEST_EX(WS_EX_LTRREADING,"ltrReading: text is displayed using left-to-right reading-order properties. This is the default.");
        TEST_EX(WS_EX_LEFTSCROLLBAR,"leftsScrollBar: use if the shell language is right-to-left reading order alignment.");
        TEST_EX(WS_EX_MDICHILD,"Creates a multiple-document interface (MDI) child window.");
        TEST_EX(WS_EX_NOACTIVATE,"noActivate: this top-level Window does not become the foreground window when the user clicks it. (does not appear on the taskbar cf.: WS_EX_APPWINDOW) [Windows 2000/XP]");
        TEST_EX(WS_EX_NOINHERITLAYOUT,"noInheritLayout: does not pass its window layout to its child windows. [Windows 2000/XP]");      
        TEST_EX(WS_EX_NOPARENTNOTIFY,"noParentNotify: specifies that a child window does not send the WM_PARENTNOTIFY message to its parent window.");
        TEST_EX(WS_EX_RIGHTSCROLLBAR,"rightsScrollBar: vertical scroll bar (if present) is to the right of the client area.");
        TEST_EX(WS_EX_STATICEDGE,"staticEdge: three-dimensional border style intended to be used for items that do not accept user input.");
        TEST_EX(WS_EX_TRANSPARENT,"transparent: appears transparent because the bits of underlying sibling windows have already been painted.");
        MessageBox(NULL,message,"Info: style window",0);
}

Screen::Screen()
{
        DEBUG_SCREEN("Constructor");
        hWnd=NULL;
        hWndInsertAfter=NULL;
        hInst=NULL;
        dwStyle=WS_POPUP;//NULL;//WS_POPUP;// fenetre simple sans title
        dwExStyle=NULL;
        dxNormal = dyNormal = dxClient= dyClient = 0;
        dxFull = GetSystemMetrics(SM_CXSCREEN);
        dyFull = GetSystemMetrics(SM_CYSCREEN);
        xNormal=yNormal=0;
        enableTitle=FALSE;
        enableFullScreen=FALSE;
        enableFullScreenOld=-1; // oblige la remise a jour
        hDC = NULL;
        hGLRC = NULL;
}

Screen::~Screen()
{
        DEBUG_SCREEN("Destructor");
        Destroy();
}

BOOL Screen::Setup(WNDCLASS *wc,char *_className,char *_title)
{
        className=_className;
        title=_title;
        wc->lpszClassName = TEXT (className);
        if (!::RegisterClass(wc))
        {
                MyString msg;
                msg<<"Can't register window \""<<className<<"\"";
                MessageBox (NULL,msg,"RegisterClass - Failed",MB_OK); 
                return FALSE;
        }
        DEBUG_SCREEN("Setup");
        return TRUE;
}

BOOL Screen::SwapBuffers()
{
        return ::SwapBuffers(hDC); 
}

BOOL Screen::Create(HINSTANCE hInstance)
{
        hInst = hInstance;
        SetFullScreen();
        //MsgInfoType();
        hWnd = CreateWindowEx(dwExStyle,className,title, dwStyle,0,0,dxClient,dyClient,NULL, NULL, hInst,NULL);
        if (!hWnd) 
        {
                MyString msg;
                msg<<"Can't create window \""<<title<<"\"";
                MessageBox (NULL,msg,"CreateWindow - Failed",MB_OK); 
                return FALSE;
        }
        if (!enableFullScreen) ApplySize();
        SetTopMost();
        DEBUG_SCREEN("Create");
        return TRUE;
}

void Screen::Destroy()
{
        DEBUG_SCREEN("Destroy");
        SendMessage(hWnd,WM_QUIT,0,0);
        if (hWnd) UnregisterClass(className,hInst);
        hWnd=NULL;
        if (hGLRC)
        {
                wglMakeCurrent(NULL, NULL);     // Makes current RC no longer current
                wglDeleteContext(hGLRC);        // Deletes OpenGL rendering context
        }
        if (hDC) { ReleaseDC(hWnd, hDC); hDC = NULL; } // Releases a DC, freeing it for other apps

}

void Screen::Show(BOOL enable)
{
        if (enable) ShowWindow(hWnd,SW_SHOW);
        else ShowWindow(hWnd,SW_HIDE);
        DEBUG_SCREEN("Show");
}

void Screen::Update(BOOL applySize)
{
        SetFullScreen();
        ApplyStyles();
        if (enableTitle) SetWindowText(hWnd,title);                     
        SetTopMost();
        if (applySize) ApplySize();
        DEBUG_SCREEN("Update");
}

void Screen::ApplySize()
{
        ComputeDeltaClientToWindow();
        int dx,dy;
        dx=dxClient+dxWC;
        dy=dyClient+dyWC;
        SetWindowPos(hWnd,NULL,0,0,dx,dy,SWP_NOZORDER|(enableFullScreen?0:SWP_NOMOVE));
        DEBUG_SCREEN("ApplySize");
}

#include "windowTools.h"

void Screen::SetFullScreen()
{
        BOOL result=FALSE;

        if (enableFullScreenOld!=enableFullScreen) 
        {
                enableFullScreenOld=enableFullScreen;
                if (enableFullScreen) 
                {
                        dxNormal=dxClient;
                        dyNormal=dyClient;
                        dxClient=dxFull;
                        dyClient=dyFull;
                        // sauve la position initial de la fenetre avant le fullscreen
                        GetWindowPos(hWnd,&xNormal,&yNormal);
                }
                else 
                {
                        dxClient=dxNormal;
                        dyClient=dyNormal;
                        // replacer la fenetre a sa position d'origine
                        SetWindowPos(hWnd,NULL,xNormal,yNormal,0,0,SWP_NOZORDER|SWP_NOSIZE);
                }
        }
        if (enableFullScreen||!enableTitle) SetStyle(WS_POPUP);
        else SetStyle (WS_OVERLAPPEDWINDOW); 

        //ChangeStyle(TRUE,WS_BORDER|WS_CAPTION|WS_DLGFRAME|WS_SIZEBOX|WS_SYSMENU);
        DEBUG_SCREEN("SetFullScreen");
}

void Screen::BindOpenGL(BOOL useAccumulation)
{
        // Next define pixelformat...we use stuct PIXELFORMATDESCRIPTOR
        // This is straight out of NeHe’s framework
        static PIXELFORMATDESCRIPTOR pfd =       // static ensures data is stored between calls
        {
                sizeof(PIXELFORMATDESCRIPTOR),
                        1,                     // nVersion should be set to 1
                        PFD_DRAW_TO_WINDOW |   // buffer can draw to window
                        PFD_SUPPORT_OPENGL |   // buffer supports OpenGL drawing
                        PFD_DOUBLEBUFFER,     // buffer is double buffered
                        PFD_TYPE_RGBA,         // rgba pixels
                        24,                    // 24-bit color depth
                        0, 0, 0, 0, 0, 0,      // look up rest at MSDN, color bits ignored
                        0,                     // no alpha buffer
                        0,                     // shift bit ignored
                        useAccumulation?24:0,  // accumulation buffer total size
                        useAccumulation?8:0,   // accumulation bits R
                        useAccumulation?8:0,   // accumulation bits G
                        useAccumulation?8:0,   // accumulation bits B
                        0,                                         // accumulation bits A
                        24,                    // 24 bit z buffer (16 do somme deformations)
                        0,                     // no stencil buffer
                        0,                     // no auxiliary buffer
                        PFD_MAIN_PLANE,        // main drawing layer
                        0,                     // reserved
                        0, 0, 0                // layer mask ignored
        };

        hDC = GetDC(hWnd);  // Retrieves a handle to a

        // display device context
        int pixelFormat = OpenGL_InitMultisample(hWnd); // supporté par nvidia uniquement sur gFoce3Fx minimum
        if (!pixelFormat) pixelFormat = ChoosePixelFormat(hDC, &pfd);  // Try and match a pixel format 

        SetPixelFormat(hDC, pixelFormat, &pfd); // supported by DC
        hGLRC = wglCreateContext(hDC);     // Create a new OpenGL rendering context
        wglMakeCurrent(hDC, hGLRC);        // Makes OpenGL hRC the calling threads current RC
}

void Screen::SetTitle(char *_title)
{
        title=_title;
}

void Screen::SetTopMost()
{
        hWndInsertAfter = enableFullScreen? HWND_TOPMOST : NULL;
        SetWindowPos(hWnd,hWndInsertAfter,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE); 
}

void Screen::SetSize(int dx,int dy,BOOL always)
{
        if (!enableFullScreen||always)
        {
                dxClient = dx;
                dyClient = dy;
                dxNormal = dx;
                dyNormal = dy;
                DEBUG_SCREEN("SetSize");
        }
}

void Screen::ChangeStyle(int set,DWORD dwStyleChange)
{
        dwStyle|=dwStyleChange;
        if (!set) dwStyle-=dwStyleChange;
}

void Screen::ChangeStyleEx(int set,DWORD dwStyleChange)
{
        dwExStyle|=dwStyleChange;
        if (!set) dwExStyle-=dwStyleChange;
}

void Screen::ApplyStyles()
{
        ApplyStyle();
        ApplyStyleEx();
        SetWindowPos(hWnd,NULL,0,0,0,0,SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER|SWP_FRAMECHANGED); 
}

void Screen::SetStyle(DWORD _dwStyle)
{
        dwStyle=_dwStyle;
}

void Screen::ApplyStyle()
{
        SetWindowLong(hWnd,GWL_STYLE,dwStyle);
}

void Screen::ApplyStyleEx()
{
        SetWindowLong(hWnd,GWL_EXSTYLE,dwExStyle);
}

void Screen::RegionReset()
{
        region.Reset(dxClient,dyClient);
}

void Screen::RegionUse()
{
        region.Use(hWnd);
}

// obsolete ****************************************************************

//Ajust la taille de la fenetre par rapport a la taille du client
//Cette fontion ne marche visiblement pas dans tout les cas !
/*
void Screen::Adjust()
{
        RECT rect;
        rect.left=0;
        rect.right=dxClient;
        rect.top=0;
        rect.bottom=dyClient;
        BOOL res= dwStyle&WS_OVERLAPPED;
        AdjustWindowRectEx(&rect,dwStyle,FALSE,dwExStyle);
        dxWindow = rect.right;
        dyWindow = rect.bottom;
}
*/

---