window.H

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#ifndef ARCHON_UTILITIES_WINDOW_H
#define ARCHON_UTILITIES_WINDOW_H

#include <string>

#include <archon/util/exception.H>
#include <archon/util/ref.H>
#include <archon/util/window_keys.H>

namespace Archon
{
  namespace Utilities
  {
    using namespace std;

    class Window
    {
    public:
      struct KeyboardHandler
      {
        virtual void press(Key, unsigned long milliSecondTime) = 0;
        virtual void release(Key) = 0;
        virtual ~KeyboardHandler() {}
      };

      struct MouseHandler
      {
        virtual void press(unsigned button, unsigned x, unsigned y, unsigned long milliSecondTime) = 0;
        virtual void release(unsigned button, unsigned x, unsigned y) = 0;
        virtual void motion(unsigned xAbs, unsigned yAbs, int xRel, int yRel) = 0;
        virtual ~MouseHandler() {}
      };

      struct WindowHandler
      {
        virtual void quit() = 0;
        virtual ~WindowHandler() {}
      };

      enum DrawMode { set, add, sub };

      /* Mouse cursor example:

      //XPM

      static const char *arrow[] =
      {
      //width height num_colors chars_per_pixel
      "    32    32        3            1",
      //colors
      "X c #000000",
      ". c #ffffff",
      "  c None",
      //pixels
      "X                               ",
      "XX                              ",
      "X.X                             ",
      "X..X                            ",
      "X...X                           ",
      "X....X                          ",
      "X.....X                         ",
      "X......X                        ",
      "X.......X                       ",
      "X........X                      ",
      "X.....XXXXX                     ",
      "X..X..X                         ",
      "X.X X..X                        ",
      "XX  X..X                        ",
      "X    X..X                       ",
      "     X..X                       ",
      "      X..X                      ",
      "      X..X                      ",
      "       XX                       ",
      "                                ",
      "                                ",
      "                                ",
      "                                ",
      "                                ",
      "                                ",
      "                                ",
      "                                ",
      "                                ",
      "                                ",
      "                                ",
      "                                ",
      "                                ",
      "0,0"
      };

      */

      class MouseCursor: public virtual RefObjectBase
      {
        friend class Window;
        void *data; // SDL_Cursor
        MouseCursor(const char *image[]); // See example
      public:
        ~MouseCursor();
      };

    private:
      void *dataHolder;
      DrawMode drawMode;
      unsigned long drawColor;
      Key *keyXlat;
      KeyboardHandler *keyboardHandler;
      MouseHandler *mouseHandler;
      WindowHandler *windowHandler;
      void *defaultMouseCursor;
      int mouseX;
      int mouseY;
    
      unsigned long combineRGBA(unsigned r, unsigned g,
                                unsigned b, unsigned a);

      void initializeKeyXlat();

    public:
      Window(unsigned width,
             unsigned height,
             unsigned bitsPerPixel = 24,
             bool fullScreen = false,
             bool openGlSupport = false,
             KeyboardHandler * = 0,
             MouseHandler * = 0,
             WindowHandler * = 0);
      ~Window();

      Ref<MouseCursor> newMouseCursor(const char *image[]);
      void setMouseCursor(Ref<MouseCursor>);
      void setDefaultMouseCursor();
      void showMouseCursor();
      void hideMouseCursor();


      // The mouse position is only updated when calling executeEventQueue
      int getMouseX() const { return mouseX; }
      int getMouseY() const { return mouseY; }

      void swapBuffers(); // Use in open GL context

      void discardEventQueue();
      void executeEventQueue(unsigned long milliSecondTime);

      unsigned getWidth()  const;
      unsigned getHeight() const;

      void setDrawMode(DrawMode mode) { drawMode = mode; }
      void setColor(unsigned red,
                    unsigned green,
                    unsigned blue,
                    unsigned alpha = 255)
      {
        drawColor = combineRGBA(red, green, blue, alpha);
      }

      struct Update
      {
        Update(Window *);
        ~Update();

        void clear();



        void drawPoint(unsigned x, unsigned y)
        {
          if(x >= width || y >= height)
            ARCHON_THROW1(ArgumentException,
                          "coordinates out of range");
          drawPoint(x, y, drawMode, drawColor);
        }

        void drawPoint(unsigned x, unsigned y, DrawMode mode)
        {
          if(x >= width || y >= height)
            ARCHON_THROW1(ArgumentException,
                          "coordinates out of range");
          drawPoint(x, y, mode, drawColor);
        }

        void drawPoint(unsigned x, unsigned y, DrawMode mode,
                       unsigned red, unsigned green,
                       unsigned blue, unsigned alpha = 255)
        {
          if(x >= width || y >= height)
            ARCHON_THROW1(ArgumentException,
                          "coordinates out of range");
          drawPoint(x, y, mode, frame->combineRGBA(red, green, blue, alpha));
        }



        void drawLine(unsigned x1, unsigned y1, unsigned x2, unsigned y2)
        {
          if(x1 >= width || y1 >= height || x2 >= width || y2 >= height)
            ARCHON_THROW1(ArgumentException,
                          "coordinates out of range");
          drawLine(x1, y1, x2, y2, drawMode, drawColor);
        }

        void drawLine(unsigned x1, unsigned y1, unsigned x2, unsigned y2,
                      DrawMode mode)
        {
          if(x1 >= width || y1 >= height || x2 >= width || y2 >= height)
            ARCHON_THROW1(ArgumentException,
                          "coordinates out of range");
          drawLine(x1, y1, x2, y2, mode, drawColor);
        }

        void drawLine(unsigned x1, unsigned y1, unsigned x2, unsigned y2,
                      unsigned red, unsigned green,
                      unsigned blue, unsigned alpha = 255)
        {
          if(x1 >= width || y1 >= height || x2 >= width || y2 >= height)
            ARCHON_THROW1(ArgumentException,
                          "coordinates out of range");
          drawLine(x1, y1, x2, y2, drawMode,
                   frame->combineRGBA(red, green, blue, alpha));
        }

      private:
        const unsigned bytesPerPixel;
        const unsigned bytesPerScanline;
        void *const pixels;
        const unsigned width;
        const unsigned height;
        const DrawMode drawMode;
        const unsigned long drawColor;
        Window *const frame;

        void drawPoint(unsigned x, unsigned y,
                       DrawMode mode, unsigned long color);
        void drawLine(unsigned x1, unsigned y1, unsigned x2, unsigned y2,
                      DrawMode mode, unsigned long color);
      };

      friend struct Update;
    };
  }
}

#endif // ARCHON_UTILITIES_WINDOW_H

---