ContextWX.cpp

#include "ContextWX.hh"
#include <iostream>
#include <Utils/GlewInitWrapper.hh>

using namespace BIAS;
using namespace std;

#define TIMER_ID 1967735

BEGIN_EVENT_TABLE(ContextWX, wxGLCanvas)
    EVT_PAINT       (ContextWX::OnPaint)
    EVT_LEFT_DOWN   (ContextWX::OnLeftDown)
    EVT_LEFT_UP     (ContextWX::OnLeftUp)
        EVT_MIDDLE_DOWN (ContextWX::OnMiddleDown)
        EVT_MIDDLE_UP   (ContextWX::OnMiddleUp)
        EVT_RIGHT_DOWN  (ContextWX::OnRightDown)
        EVT_RIGHT_UP    (ContextWX::OnRightUp)
    EVT_RIGHT_DOWN  (ContextWX::OnRightDown)
    EVT_LEFT_DCLICK (ContextWX::OnLeftDClick)
    EVT_RIGHT_DCLICK(ContextWX::OnRightDClick)
    EVT_MOTION      (ContextWX::OnMotion)
  EVT_SIZE        (ContextWX::OnSize)
    EVT_KEY_DOWN    (ContextWX::OnKeyDown)
  EVT_KEY_UP      (ContextWX::OnKeyUp)
    EVT_CHAR        (ContextWX::OnKey )
    EVT_TIMER       (TIMER_ID, ContextWX::OnTimer)
    EVT_ERASE_BACKGROUND(ContextWX::OnEraseBG)
    EVT_ENTER_WINDOW (ContextWX::OnEnterWindow)
    EVT_LEAVE_WINDOW (ContextWX::OnLeaveWindow)
END_EVENT_TABLE()

int ContextWX::defaultAttribs[] = {
  WX_GL_RGBA,
  WX_GL_LEVEL, 0,            //means main window, <0 underlay, >0 overlay
  WX_GL_MIN_RED, 8,
  WX_GL_MIN_GREEN, 8,
  WX_GL_MIN_BLUE, 8,
  WX_GL_MIN_ALPHA, 8,
  WX_GL_DEPTH_SIZE, 24,
  WX_GL_DOUBLEBUFFER, 1 ,    //use double buffer
  //WX_GL_SAMPLE_BUFFERS, 1, //multisampling (aliasing)
  0 //termination flag
};

// Try to comment out this line if WX crashes when trying to create context.
// This means you wont get a context with the desired attributes but
// hopefully a context which works (might have less bits or lead to strange
// behaviour because you have a strange color format).

//#define GL_USE_DEFAULT_ATTRIBS

ContextWX::ContextWX(wxWindow* parent, wxWindowID id, const wxPoint& pos,
                     const wxSize& size, long style,
                     const wxString& name, int* attribList, const wxPalette& palette) :
#if wxCHECK_VERSION(2, 9, 0)
  #ifdef GL_USE_DEFAULT_ATTRIBS
                     wxGLCanvas(parent, id, defaultAttribs, pos, size, style, name,  palette),
  #else
                     wxGLCanvas(parent, id, attribList, pos, size, style, name, palette),
  #endif
#else
  #ifdef GL_USE_DEFAULT_ATTRIBS
                     wxGLCanvas(parent, id, pos, size, style, name, defaultAttribs, palette),
  #else
                     wxGLCanvas(parent, id, pos, size, style, name, attribList, palette),
  #endif
#endif

                     initialized_(false)
{
#if wxCHECK_VERSION(2, 9, 0)
  context_ = new wxGLContext(this);
#endif
  _OldMouseX = 0;
  _OldMouseY = 0;
  _FirstPaint = true;
  //wxGLContext_ = new wxGLContext(this, NULL);
  Timer_.SetOwner(this, TIMER_ID);
}


// The shared context constructor is deprecated in wx >= 2.9
// so this constructor will / should be removed
/*
ContextWX::ContextWX(wxWindow* parent, wxGLContext* shared, wxWindowID id,
                     const wxPoint& pos, const wxSize& size, long style,
                     const wxString& name, int* attribList, const wxPalette& palette)
                     : wxGLCanvas(parent, shared, id, pos, size, style, name, attribList, palette),
                     initialized_(false)
{
  _OldMouseX = 0;
  _OldMouseY = 0;
  _FirstPaint = true;
  GlewInitWrapper::GetInstance()->Init();
  //wxGLContext_ = new wxGLContext(this, shared);
  Timer_.SetOwner(this, TIMER_ID);
}*/

int ContextWX::
FindWorkingDisplayConfiguration()
{
//only in wxwidgets >2.9.0
//  if(this->IsDisplaySupported(defaultAttribs)){
//      cout<<"Default Attributes are supported"<<endl;
//      return 0;
//  }
//  else{
//      BIASERR("No working opengl display mode could be found.");
//  }
    return -1;
}

void ContextWX::OnPaint(wxPaintEvent & /*event*/)
{
  wxPaintDC dc(this);
  #if wxCHECK_VERSION(2, 9, 0)
    SetCurrent(*context_);
  #else
    SetCurrent();
  #endif

  static bool firstCall = true;
  if (_FirstPaint && firstCall)
    {
      firstCall = false; 
      GlewInitWrapper::GetInstance()->Init();
      _FirstPaint = false;
    }

  if(initialized_) {
    Render();
    SwapBuffers();
  }
}

void ContextWX::OnTimer(wxTimerEvent & /*event*/)
{
  if (TimerExpired())  Refresh();
  if (TimerInterval_ >0)
    Timer_.Start(TimerInterval_, true);

}

void ContextWX::OnLeftUp(wxMouseEvent& event)
{  
  LeftMouseUp(event.GetX(),event.GetY());
  Refresh();
}

void ContextWX::OnLeftDown(wxMouseEvent& event)
{
  SetFocus();
  LeftMouseDown(event.GetX(), event.GetY());
  Refresh();
}

void ContextWX::OnMiddleUp(wxMouseEvent& event)
{
  MiddleMouseUp(event.GetX(),event.GetY());
  Refresh();
}

void ContextWX::OnMiddleDown(wxMouseEvent& event)
{
  //SetFocus();
  MiddleMouseDown(event.GetX(), event.GetY());
  Refresh();
}

void ContextWX::OnRightUp(wxMouseEvent& event)
{
  RightMouseUp(event.GetX(),event.GetY());
  Refresh();
}


void ContextWX::OnRightDown(wxMouseEvent& event)
{
  RightMouseSingleClicked(event.GetX(), event.GetY());
  RightMouseDown(event.GetX(), event.GetY());
  Refresh();
}

void ContextWX::OnLeftDClick(wxMouseEvent& event)
{
  modifiers m=NONE;
  if (event.MetaDown()) m=ALT;
  if (event.ShiftDown()) m=SHIFT;
  LeftMouseDoubleClicked(event.GetX(), event.GetY(),m);
  Refresh();
}

void ContextWX::OnRightDClick(wxMouseEvent & event)
{
  RightMouseDoubleClicked(event.GetX(), event.GetY());
  Refresh();
}

void ContextWX::OnLeaveWindow(wxMouseEvent& event)
{
  MouseLeftWindow();
  Refresh();
}

void ContextWX::OnEnterWindow(wxMouseEvent& event)
{
  SetFocus();
}

void ContextWX::OnMotion(wxMouseEvent& event)
{

    bool caught = false;
  if( event.LeftIsDown() && event.RightIsDown() ) {
    caught =  LeftAndRightMouseMoved(_OldMouseX, event.GetX(), _OldMouseY, event.GetY());     
    Refresh();
  }
  else {
    if (event.LeftIsDown())
    {
        caught =  LeftMouseMoved(_OldMouseX, event.GetX(), _OldMouseY, event.GetY());
      Refresh();
    }

    if (event.RightIsDown())
    {
        caught =  RightMouseMoved(_OldMouseX, event.GetX(), _OldMouseY, event.GetY());
      Refresh();
    }
  }
  if (event.MiddleIsDown())
  {
    caught =  MiddleMouseMoved(_OldMouseX, event.GetX(), _OldMouseY, event.GetY());
    Refresh();
  }
  if(!caught){
    caught =  MouseMoved(event.GetX(), event.GetY());
    Refresh();
  }
  
  _OldMouseX = event.GetX();
  _OldMouseY = event.GetY();
  //cout<<"CWX OnMotion:"<<_OldMouseX<<","<<_OldMouseY<<endl;
  event.Skip();
}

void ContextWX::OnSize(wxSizeEvent& event)
{
  if (_FirstPaint) return;  
  WindowReshape(event.GetSize().GetWidth(), event.GetSize().GetHeight());
  event.Skip();
}


void ContextWX::OnKeyDown(wxKeyEvent& event)
{
  //keydown may be needed in the parent window
  event.ResumePropagation(wxEVENT_PROPAGATE_MAX);
  event.Skip();
}


void ContextWX::OnKey(wxKeyEvent& event)
{

  int key = event.GetKeyCode();
  if (key<300) {
    StandardKeyPressed(key,event.GetX(),event.GetY());
  }
  else
    switch(key)
  {
    case WXK_F1:
      SpecialKeyPressed(KEY_F1);
      break;
    case WXK_F2:
      SpecialKeyPressed(KEY_F2);
      break;
    case WXK_F3:
      SpecialKeyPressed(KEY_F3);
      break;
    case WXK_F4:
      SpecialKeyPressed(KEY_F4);
      break;
    case WXK_F5:
      SpecialKeyPressed(KEY_F5);
      break;
    case WXK_F6:
      SpecialKeyPressed(KEY_F6);
      break;
    case WXK_F7:
      SpecialKeyPressed(KEY_F7);
      break;
    case WXK_F8:
      SpecialKeyPressed(KEY_F8);
      break;
    case WXK_F9:
      SpecialKeyPressed(KEY_F9);
      break;
    case WXK_F10:
      SpecialKeyPressed(KEY_F10);
      break;
    case WXK_F11:
      SpecialKeyPressed(KEY_F11);
      break;
    case WXK_F12:
      SpecialKeyPressed(KEY_F12);
      break;

    case WXK_HOME:
      SpecialKeyPressed(KEY_HOME);
      break;
  }
  //cerr <<"ContextWX::OnKeyPress\n";
  event.ResumePropagation(wxEVENT_PROPAGATE_MAX);
  event.Skip();
}

void ContextWX::OnKeyUp(wxKeyEvent& event)
{

  int key = event.GetKeyCode();
  if (key<300) {
    StandardKeyUp(key,event.GetX(),event.GetY());
  }
  else
    switch(key)
  {
    case WXK_F1:
      SpecialKeyUp(KEY_F1);
      break;
    case WXK_F2:
      SpecialKeyUp(KEY_F2);
      break;
    case WXK_F3:
      SpecialKeyUp(KEY_F3);
      break;
    case WXK_F4:
      SpecialKeyUp(KEY_F4);
      break;
    case WXK_F5:
      SpecialKeyUp(KEY_F5);
      break;
    case WXK_F6:
      SpecialKeyUp(KEY_F6);
      break;
    case WXK_F7:
      SpecialKeyUp(KEY_F7);
      break;
    case WXK_F8:
      SpecialKeyUp(KEY_F8);
      break;
    case WXK_F9:
      SpecialKeyUp(KEY_F9);
      break;
    case WXK_F10:
      SpecialKeyUp(KEY_F10);
      break;
    case WXK_F11:
      SpecialKeyUp(KEY_F11);
      break;
    case WXK_F12:
      SpecialKeyUp(KEY_F12);
      break;

    case WXK_HOME:
      SpecialKeyUp(KEY_HOME);
      break;
  }
  //cerr <<"ContextWX::OnKeyPress\n";
  event.ResumePropagation(wxEVENT_PROPAGATE_MAX);
  event.Skip();
}

void ContextWX::SetTimer(unsigned int interval)
{
  //cout <<"Timer: "<<interval<<endl;
  if (interval <10) {
    BIASERR("Timer smaller then 10ms are prohibited");
    return;
  }
  // cout <<interval<<endl;
  TimerInterval_ = interval;
  if (TimerInterval_ >0)
    Timer_.Start(TimerInterval_, true);
}

void ContextWX::DeactivateTimer()
{
  Timer_.Stop();
}

void ContextWX::MakeGLContextCurrent() {  
  if (this->GetParent() && this->GetParent()->IsShown()) {
    #if wxCHECK_VERSION(2, 9, 0)
      SetCurrent(*context_);
    #else
      SetCurrent();
    #endif
  } else {
    if (this->GetParent()){
      BIASWARN("trying to make hidden context current!");
    } else {
      BIASWARN("trying to make context without parent current!");
    }
  }
}

void ContextWX::OnEraseBG(wxEraseEvent& event)
{
}