al_Window.hpp

#ifndef INCLUDE_AL_WINDOW_HPP
#define INCLUDE_AL_WINDOW_HPP
 
/*  Allocore --
  Multimedia / virtual environment application class library
 
  Copyright (C) 2009. AlloSphere Research Group, Media Arts & Technology, UCSB.
  Copyright (C) 2012. The Regents of the University of California.
  All rights reserved.
 
  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
 
    Redistributions of source code must retain the above copyright notice,
    this list of conditions and the following disclaimer.
 
    Redistributions in binary form must reproduce the above copyright
    notice, this list of conditions and the following disclaimer in the
    documentation and/or other materials provided with the distribution.
 
    Neither the name of the University of California nor the names of its
    contributors may be used to endorse or promote products derived from
    this software without specific prior written permission.
 
  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  POSSIBILITY OF SUCH DAMAGE.
 
 
  File description:
  An interface to an OS window
 
  File author(s):
  Lance Putnam, 2010, putnam.lance@gmail.com
  Graham Wakefield, 2010, grrrwaaa@gmail.com
  Wesley Smith, 2010, wesley.hoke@gmail.com
  Keehong Youn, 2017, younkeehong@gmail.com
*/
 
#include <stdio.h>
 
#include <algorithm>
#include <functional>
#include <iostream>
#include <memory>
#include <string>
#include <vector>
 
#ifdef AL_WINDOWS
#undef DELETE
#endif
 
namespace al {
 
class Window;
 
// can redefine, but should be at least 4
#ifndef AL_MOUSE_MAX_BUTTONS
#define AL_MOUSE_MAX_BUTTONS 4
#endif
 
class Keyboard {
 public:
  enum Key {
 
    // Standard ASCII non-printable characters
    ENTER = 3,     
    BACKSPACE = 8, 
    TAB = 9,       
    RETURN = 13,   
    ESCAPE = 27,   
    DELETE = 127,  
    // Non-standard, but common keys
    F1 = 256,
    F2,
    F3,
    F4,
    F5,
    F6,
    F7,
    F8,
    F9,
    F10,
    F11,
    F12,
    INSERT,
    LEFT,
    UP,
    RIGHT,
    DOWN,
    PAGE_DOWN,
    PAGE_UP,
    END,
    HOME
  };
 
  Keyboard();
 
  int key() const;          
  int keyAsNumber() const;  
  bool alt() const;         
  bool caps() const;        
  bool ctrl() const;        
  bool meta() const;      
  bool shift() const;     
  bool down() const;      
  bool isNumber() const;  
  bool key(int k) const;  
 
  void alt(bool state);    
  void caps(bool state);   
  void ctrl(bool state);   
  void meta(bool state);   
  void shift(bool state);  
 
  void print(std::ostream &stream) const;  
 
 protected:
  friend class WindowImpl;
 
  int mKeycode;  // last key event key number
  bool mDown;    // last key event state (pressed or released)
  bool
      mModifiers[5];  // Modifier key state array (shift, alt, ctrl, caps, meta)
 
  void setKey(int k, bool v);
};
 
class Mouse {
 public:
  enum {
    LEFT = 0,   
    MIDDLE = 1, 
    RIGHT = 2,  
    EXTRA = 3   
  };
 
  Mouse();
 
  int x() const;   
  int y() const;   
  int dx() const;  
  int dy() const;  
  double scrollX() const;  
  double scrollY() const;  
 
  int button() const;           
  bool down() const;            
  bool down(int button) const;  
  bool left() const;            
  bool middle() const;          
  bool right() const;           
 
 protected:
  friend class WindowImpl;
 
  int mX, mY;                     // x,y positions
  int mDX, mDY;                   // change in x,y positions
  double mScrollX, mScrollY;      // scroll motion
  int mButton;                    // most recent button changed
  int mBX[AL_MOUSE_MAX_BUTTONS];  // button down xs
  int mBY[AL_MOUSE_MAX_BUTTONS];  // button down ys
  bool mB[AL_MOUSE_MAX_BUTTONS];  // button states
 
  void button(int b, bool v);
  void position(int x, int y);
  void scroll(double x, double y);
};
 
 
class WindowEventHandler {
 public:
  WindowEventHandler();
  virtual ~WindowEventHandler();
 
  virtual bool keyDown(const Keyboard &k) { return true; }
 
  virtual bool keyUp(const Keyboard &k) { return true; }
 
  virtual bool mouseDown(const Mouse &m) { return true; }
 
  virtual bool mouseDrag(const Mouse &m) { return true; }
 
  virtual bool mouseMove(const Mouse &m) { return true; }
 
  virtual bool mouseUp(const Mouse &m) { return true; }
 
  virtual bool mouseScroll(const Mouse &m) { return true; }
 
  virtual bool resize(int dw, int dh) { return true; }
 
  virtual bool visibility(bool v) { return true; }
 
  WindowEventHandler &windowEventHandler() { return *this; }
 
  bool attached() const { return NULL != mWindow; }
  Window &window() { return *mWindow; }
  const Window &window() const { return *mWindow; }
 
  Window *mWindow;
 
 private:
  friend class Window;
  WindowEventHandler &window(Window *v) {
    mWindow = v;
    return *this;
  }
  void removeFromWindow();
};
 
 
// class Window : public InputEventHandler, public WindowEventHandler {
class Window {
 public:
  typedef std::vector<WindowEventHandler *> WindowEventHandlers;
 
  enum DisplayMode : unsigned int {
    SINGLE_BUF = 1 << 0,  
    DOUBLE_BUF = 1 << 1,  
    STEREO_BUF = 1 << 2,  
    ACCUM_BUF = 1 << 3,   
    ALPHA_BUF = 1 << 4,   
    DEPTH_BUF = 1 << 5,   
    STENCIL_BUF = 1 << 6, 
    MULTISAMPLE = 1 << 7, 
    DEFAULT_BUF =
        DOUBLE_BUF | ALPHA_BUF | DEPTH_BUF 
  };
 
  enum Cursor {
    NONE = 0,    
    POINTER = 1, 
    CROSSHAIR    
  };
 
  struct Dim {
    int l, t, w, h;
    Dim(int v = 0) : l(0), t(0), w(v), h(v) {}
    Dim(int w_, int h_) : l(0), t(0), w(w_), h(h_) {}
    Dim(int l_, int t_, int w_, int h_) : l(l_), t(t_), w(w_), h(h_) {}
    void set(int l_, int t_, int w_, int h_) {
      l = l_;
      t = t_;
      w = w_;
      h = h_;
    }
 
    float aspect() const { return (w != 0 && h != 0) ? float(w) / h : 1; }
    void print() const { printf("Dim: %4d x %4d @ (%4d, %4d)\n", w, h, l, t); }
  };
 
  Window();
  virtual ~Window();
 
  bool create(bool is_verbose = false);
 
  void makeCurrent();
  // refresh window (swap buffers, poll events, etc.)
  void refresh();
 
  void close();
  bool shouldClose();
 
  void destroy();
 
  const Keyboard &keyboard() const {
    return mKeyboard;
  }                                              
  const Mouse &mouse() const { return mMouse; }  
 
  double aspect() const;  
  bool created() const;   
  Cursor cursor() const;  
  bool cursorHide() const;            
  Dim dimensions() const;             
  DisplayMode displayMode() const;    
  bool enabled(DisplayMode v) const;  
  bool fullScreen() const;            
  const std::string &title() const;   
  bool visible() const;               
  bool vsync() const;                 
 
  int height() const;  
  int width() const;   
 
  // get frambuffer size
  // it will be different from window widht and height
  // if the display is a high resolution one (ex: RETINA display)
  int fbHeight() const;
  int fbWidth() const;
 
  float highres_factor() { return mHighresFactor; }
 
  bool decorated() const;
 
  void cursor(Cursor v);                        
  void cursorHide(bool v);                      
  void cursorHideToggle();                      
  void dimensions(const Dim &v);                
  void dimensions(int w, int h);                
  void dimensions(int x, int y, int w, int h);  
  void displayMode(DisplayMode v);  
 
  void fullScreen(bool on, int monitorIndex = 0);
  void fullScreenToggle();  
  void hide();              
  void iconify();           
  // void show(); ///< Show window (if hidden)
  void title(const std::string &v);  
  void vsync(bool v);  
  void decorated(bool b);
 
  // callbacks from window class, will call user event functions like `on***`
  // return false is the event has been consumed and should not propagate
  // further.
 
  std::function<bool(Keyboard const &)> onKeyDown = [](Keyboard const &) {
    return true;
  };
  std::function<bool(Keyboard const &)> onKeyUp = [](Keyboard const &) {
    return true;
  };
  std::function<bool(Mouse const &)> onMouseDown = [](Mouse const &) {
    return true;
  };
  std::function<bool(Mouse const &)> onMouseUp = [](Mouse const &) {
    return true;
  };
  std::function<bool(Mouse const &)> onMouseDrag = [](Mouse const &) {
    return true;
  };
  std::function<bool(Mouse const &)> onMouseMove = [](Mouse const &) {
    return true;
  };
  std::function<bool(Mouse const &)> onMouseScroll = [](Mouse const &) {
    return true;
  };
  std::function<void(int, int)> onResize = [](int, int) {};
 
  WindowEventHandlers &windowEventHandlers() { return mWindowEventHandlers; }
 
  Window &append(WindowEventHandler &v);
 
  Window &prepend(WindowEventHandler &v);
 
  Window &remove(WindowEventHandler &v);
 
  static void destroyAll();
 
  Keyboard mKeyboard;
  Mouse mMouse;
  WindowEventHandlers mWindowEventHandlers;
  Dim mDim{50, 50, 640, 480};
  Dim mFullScreenDim{0};
  DisplayMode mDisplayMode = DEFAULT_BUF;
  std::string mTitle = "allolib";
  Cursor mCursor = POINTER;
  bool mCursorHide = false;
  bool mFullScreen = false;
  bool mVisible = false;
  bool mVSync = true;
  bool mDecorated = true;
 
  // for high pixel density monitors (RETINA, etc.)
  float mHighresFactor = 0;
  int mFramebufferWidth = 0;
  int mFramebufferHeight = 0;
 
 protected:
  friend class WindowImpl;
 
  // class WindowImpl * mImpl;
  std::unique_ptr<class WindowImpl> mImpl;
 
  // Must be defined in pimpl-specific file
  bool implCreate(bool is_verbose = false);
  bool implCreated() const;
  void implMakeCurrent();
  void implRefresh();
  void implDestroy();
  void implSetCursor();
  void implSetCursorHide();
  void implSetDimensions();
  void implSetFullScreen(int monitorIndex = 0);
  void implSetTitle();
  void implSetVSync();
  void implHide();
  void implIconify();
  void implSetDecorated(bool decorated);
  bool implShouldClose();
  void implClose();
 
  Window &insert(WindowEventHandler &v, int i);
 
#define CALL(e)                                                  \
  {                                                              \
    for (unsigned i = 0; i < mWindowEventHandlers.size(); ++i) { \
      if (false == mWindowEventHandlers[i]->e) break;            \
    }                                                            \
  }
  void callHandlersMouseDown() {
    CALL(mouseDown(mMouse));
    onMouseDown(mMouse);
  }
  void callHandlersMouseDrag() {
    CALL(mouseDrag(mMouse));
    onMouseDrag(mMouse);
  }
  void callHandlersMouseMove() {
    CALL(mouseMove(mMouse));
    onMouseMove(mMouse);
  }
  void callHandlersMouseUp() {
    CALL(mouseUp(mMouse));
    onMouseUp(mMouse);
  }
  void callHandlersMouseScroll() {
    CALL(mouseScroll(mMouse));
    onMouseScroll(mMouse);
  }
  void callHandlersKeyDown() {
    CALL(keyDown(mKeyboard));
    onKeyDown(mKeyboard);
  }
  void callHandlersKeyUp() {
    CALL(keyUp(mKeyboard));
    onKeyUp(mKeyboard);
  }
  void callHandlersResize(int w, int h) {
    CALL(resize(w, h));
    onResize(w, h);
  }
  void callHandlersVisibility(bool v) { CALL(visibility(v)); }
#undef CALL
 
 public:
  //  [[deprecated]] Window& add(WindowEventHandler* v) { return append(*v); }
  //  [[deprecated]] Window& prepend(WindowEventHandler* v) { return
  //  prepend(*v); }
  //  [[deprecated]] Window& remove(WindowEventHandler* v) { return remove(*v);
  //  }
};
 
inline Window::DisplayMode operator|(const Window::DisplayMode &a,
                                     const Window::DisplayMode &b) {
  return Window::DisplayMode(+a | +b);
}
 
inline Window::DisplayMode operator&(const Window::DisplayMode &a,
                                     const Window::DisplayMode &b) {
  return Window::DisplayMode(+a & +b);
}
 
void initializeWindowManager();
void terminateWindowManager();
float getCurrentWindowPixelDensity();
 
}  // namespace al
 
#endif