---

glutm/window.h

Go to the documentation of this file.

#ifndef GLUTM_WINDOW_H
#define GLUTM_WINDOW_H

/*

  GLT OpenGL C++ Toolkit (LGPL)
  Copyright (C) 2000-2002 Nigel Stewart  

  Email: nigels.com@gmail.com   
  WWW:   http://www.nigels.com/glt/

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

  This library 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

*/

#include <glutm/config.h>
#include <glutm/glut.h>
#include <glutm/menu.h>

#include <glt/viewport.h>

#include <string>

class GlutMaster;

// These are here for the benefit of derived classes that
// want to use the same default arguments for constructors

const std::string  titleDefault("GlutMaster");
const int          widthDefault       = 400;
const int          heightDefault      = 400;
const int          xDefault           = 10;
const int          yDefault           = 10;
const unsigned int displayModeDefault = GLUT_RGBA | GLUT_DEPTH | GLUT_DOUBLE | GLUT_STENCIL;


class GlutWindow
{
    friend class GlutMaster;

    #ifdef GLUTM_SAVER
    friend LRESULT WINAPI ScreenSaverProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam);
    #endif

public:
    GlutWindow
    (
        const std::string &title       = titleDefault,
        const int          width       = widthDefault, 
        const int          height      = heightDefault,
        const int          x           = xDefault, 
        const int          y           = yDefault,
        const unsigned int displayMode = displayModeDefault
    );

    virtual ~GlutWindow();

    //
    // Callback Functions
    // (Derived classes should implement some of these)
    //

    virtual void OnOpen();
    virtual void OnClose();
    virtual void OnDisplay();
    virtual void OnTick();
    virtual void OnIdle();
    virtual void OnTimer(unsigned char val);
    virtual void OnKeyboard(unsigned char key, int x, int y);
    virtual void OnKeyboardUp(unsigned char key, int x, int y);
    virtual void OnSpecial(int key, int x, int y);   
    virtual void OnSpecialUp(int key, int x, int y);   
    virtual void OnMouse(int button, int state, int x, int y);
    virtual void OnMotion(int x, int y);
    virtual void OnPassiveMotion(int x, int y);

    virtual void OnEntry(int state);

    virtual void OnMenu(int value);
    virtual void OnReshape(int w, int h);
    virtual void OnVisibility(int visible);

    //
    // Window manipulation
    //

    void open();
    void grab(const GlutWindow &window);
    void close();
    void position(int x,int y);
    void reshape(int width,int height);
    
    void setCursor(int cursor);

    void enterGameMode();
    void leaveGameMode();
    void toggleGameMode();
    void postRedisplay();
    void setTimer(unsigned int msecs,unsigned char val);
    void setTick(unsigned int msec);
    void setIdle(bool idle);
    void setSwapBuffers(const bool swap);

    //
    // OpenGL Frame Buffer Capture
    //

    bool captureRGB    (const std::string &filename);
    bool captureZBuffer(const std::string &filename);
    bool captureStencil(const std::string &filename);

    //
    // Window state
    //

             bool getOpen() const;
             bool getIdle() const;
     unsigned int getTick() const;
             bool getSwapBuffers() const;

              int getX()              const;
              int getY()              const;
              int getWidth()          const;
              int getHeight()         const; 

              int getBufferSize()     const;
              int getStencilSize()    const;
              int getDepthSize()      const;
              int getRedSize()        const;
              int getGreenSize()      const;
              int getBlueSize()       const;
              int getAlphaSize()      const;

              int getAccumRedSize()   const;
              int getAccumGreenSize() const;
              int getAccumBlueSize()  const;
              int getAccumAlphaSize() const;

             bool getDoubleBuffer()   const;
             bool getRGBA()           const;
             bool getStereo()         const;
                                        
             bool getTopLevel()       const;
              int getNumChildren()    const;

              int getColormapSize()   const;
              int getNumSamples()     const;
              int getCursor()         const;
                                        
             bool getShiftModifier()  const;
             bool getCtrlModifier()   const;
             bool getAltModifier()    const;

    //
    //
    //

    typedef enum
    {
        MENU_CLOSE = 0xff00,

        // Capture OpenGL frame buffer

        MENU_CAPTURE_RGB,       
        MENU_CAPTURE_STENCIL,       
        MENU_CAPTURE_ZBUFFER,       
    } MenuCallbacks;

protected:  

    virtual void OnPreDisplay();
    virtual void OnPostDisplay();
    virtual void OnPreTimer(unsigned char val);

         int &windowID();        
   const int &windowID() const;     

    GltViewport _viewport;

    GlutMenu    _leftButtonMenu;
    GlutMenu    _rightButtonMenu;

    bool _swapBuffers;

    static const unsigned char _tickVal;

    std::string nextFilename();
    int _fileIndex;

private:

    void swapBuffers();

            bool _idle;
    unsigned int _tick;         
    bool         _tickPending;
    
    int _windowID;

    bool _shiftModifier;
    bool _ctrlModifier;
    bool _altModifier;

    // These are used each time open() is called

    int          _x,_y;
    int          _width,_height;
    unsigned int _displayMode;
    bool         _gameMode;
    std::string  _title;

    // In tick-driven mode, mouse events are only
    // handled at the maximum refresh rate

    bool _mouseEvents;
    int  _mouseX,_mouseY;

    // Save the dimensions for switching 
    // between window and game mode

    bool _windowSaved;
    int  _windowX,_windowY,_windowWidth,_windowHeight;
};

#endif

---