kmousemanager.cpp from Spatial Knowledge Experiments at Krugle

Show kmousemanager.cpp syntax highlighted

/*
    Copyright (C) 2003, 2004, 2005 by Luca Cappa
    Written by Luca Cappa groton@users.sourceforge.net
  
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License as published by the Free Software Foundation; either
    version 2 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
    Library General Public License for more details.
  
    You should have received a copy of the GNU Library General Public
    License along with this library; if not, write to the Free
    Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/



#include "cssysdef.h"

#include "csutil/sysfunc.h"
#include "csutil/cscolor.h"
#include "csutil/cmdhelp.h"
#include "csutil/cspmeter.h"
#include "csutil/csstring.h"
#include "csutil/scfstr.h"
#include "csutil/dirtyaccessarray.h"
#include "csutil/xmltiny.h"
#include "csutil/array.h"
#include "csutil/event.h"

#include "cstool/csview.h"
#include "cstool/initapp.h"
#include "cstool/collider.h"
#include "cstool/cspixmap.h"

#include "iutil/vfs.h"
#include "iutil/eventq.h"
#include "iutil/event.h"
#include "iutil/objreg.h"
#include "iutil/csinput.h"
#include "iutil/virtclk.h"
#include "iutil/plugin.h"
#include "iutil/string.h"


#include "iengine/sector.h"
#include "iengine/engine.h"
#include "iengine/camera.h"
#include "iengine/light.h"
#include "iengine/texture.h"
#include "iengine/mesh.h"
#include "iengine/movable.h"
#include "iengine/material.h"

#include "imesh/thing.h"
#include "imesh/object.h"


#include "ivideo/graph3d.h"
#include "ivideo/graph2d.h"
#include "ivideo/natwin.h"
#include "ivideo/txtmgr.h"
#include "ivideo/texture.h"
#include "ivideo/material.h"
#include "ivideo/fontserv.h"

#include "igraphic/imageio.h"

#include "ivaria/reporter.h"
#include "ivaria/stdrep.h"
#include "ivaria/conout.h"
#include "ivaria/reporter.h"
#include "ivaria/stdrep.h"
#include "ivaria/collider.h"

#include "csgeom/quaterni.h"
#include "csgeom/transfrm.h"
#include "csgeom/math3d_d.h"
#include "csgeom/math3d.h"

#include "igeom/polymesh.h"
#include "igeom/objmodel.h"

#include "imap/loader.h"


#include "iaws/aws.h"
#include "iaws/awscnvs.h"

#include "korientation.h"
#include "kcamera.h"
#include "kblock.h"
#include "kmap.h"
#include "kblockid.h"
#include "kflags.h"
#include "ksprite3d.h"
#include "kappstate.h"
#include "ske.h"
#include "klandmark.h"
#include "klandmarklist.h"
#include "kutil.h"
#include "kpath.h"
#include "kplayer.h"
#include "kxmlhelper.h"
#include "kdragmanager.h"
#include "kwireframe.h"
#include "kcommandprocessor.h"
#include "kcursor3d.h"
//Includes for this file.
#include "kmousemanager.h"


SCF_IMPLEMENT_IBASE (KMouseManager)
  SCF_IMPLEMENTS_INTERFACE (iEventHandler)
SCF_IMPLEMENT_IBASE_END



KMouseManager::KMouseManager ()
{ 
  SCF_CONSTRUCT_IBASE (0);

  g_ske->m_g2d->SetMouseCursor (csmcNone);//hide the system mouse cursor.

  //
  //
  g_ske->m_evHndlrMan->AddEventHandler (this, 
    CSMASK_MouseMove | CSMASK_MouseDown |
    CSMASK_MouseUp | CSMASK_MouseClick | CSMASK_Broadcast | CSMASK_Nothing,
    1);

  //
  //Some initilization stuff.
  m_mouseActingMode = false;
  SetMode (PUTTING_BLOCK_MODE);
  m_mouse = CS_QUERY_REGISTRY (g_objReg, iMouseDriver);

  //
  //Load the mouse pointers from image files.
  csRef<iTextureHandle> l_txt = g_ske->MyLoadImage("/SKE/texture/mpNormal.bmp", true, 
    csRGBcolor (255, 0, 0));
  if( l_txt == NULL )
    csReport (g_objReg, CS_REPORTER_SEVERITY_WARNING,
    "crystalspace.application.SKE","Error loading the mouse pointer \"normal\"!");
  else
    m_mousePointerNormal = new csSimplePixmap (l_txt);
  
  l_txt = g_ske->MyLoadImage("/SKE/texture/mpPicking.bmp", true, 
    csRGBcolor (255, 0, 0));
  if( l_txt == NULL )
    csReport (g_objReg, CS_REPORTER_SEVERITY_WARNING,
    "crystalspace.application.SKE","Error loading the mouse pointer \"picking\"!");
  else
    m_mousePointerPicking = new csSimplePixmap (l_txt);
  
  l_txt = g_ske->MyLoadImage("/SKE/texture/mpRotating.bmp", true, 
    csRGBcolor (255, 0, 0));
  if( l_txt == NULL )
    csReport (g_objReg, CS_REPORTER_SEVERITY_WARNING,
    "crystalspace.application.SKE","Error loading the mouse pointer \"rotating\"!");
  else
    m_mousePointerRotating = new csSimplePixmap (l_txt);
  
  l_txt = g_ske->MyLoadImage("/SKE/texture/mpPath.bmp", true, 
    csRGBcolor (255, 0, 0));
  if( l_txt == NULL )
    csReport (g_objReg, CS_REPORTER_SEVERITY_WARNING,
    "crystalspace.application.SKE","Error loading the mouse pointer \"path\"!");
  else
    m_mousePointerPath = new csSimplePixmap (l_txt);  


  
}

KMouseManager::~KMouseManager ()
{   
  delete m_mousePointerRotating;
  delete m_mousePointerPicking;
  delete m_mousePointerNormal;
  delete m_mousePointerPath;
}


bool KMouseManager::HandleEvent (iEvent& p_e) 
{
  if (p_e.Type == csevBroadcast && 
    csCommandEventHelper::GetCode (&p_e) == cscmdProcess)
  {
    //
    //The drawing happens here.

    //If the app is backgrounded, dont draw the mouse pointer.
    if (g_ske->m_backgrounded)
      return false;
    
    
    switch (m_mode)
    {
    case TRANSLATING_OBJECT_MODE:
      m_mousePointerPicking->Draw (g_ske->m_g3d, m_mouse->GetLastX () - 16,
        m_mouse->GetLastY () - 16, 65);
      break;
    case ROTATING_OBJECT_MODE:
      m_mousePointerRotating->Draw (g_ske->m_g3d, m_mouse->GetLastX () - 16, 
        m_mouse->GetLastY () - 16, 65);
      break;
    case PUTTING_BLOCK_MODE:
      m_mousePointerNormal->Draw (g_ske->m_g3d, m_mouse->GetLastX (),
        m_mouse->GetLastY (), 65);
      break;
    case CREATING_PATH_MODE:
      m_mousePointerPath->Draw (g_ske->m_g3d, m_mouse->GetLastX () - 16,
        m_mouse->GetLastY () - 5, 65);
      break;
    case HIDING_MODE:
      //??UGLY! if one of the two windows is visible, display the mouse cursor
      //even if the mouse state is in HIDING_MODE
      if (!g_ske->m_plConfWnd->isHidden () ||
        !g_ske->m_replayWnd->isHidden ())
        m_mousePointerNormal->Draw (g_ske->m_g3d, m_mouse->GetLastX () - 16,
          m_mouse->GetLastY () - 16, 65);
      break;
    }//switch
    return false;
  }
  
  if (p_e.Type == csevMouseDown)
  {    
    if (csMouseEventHelper::GetButton (&p_e) == 1)
    {
      CS_ASSERT (!m_mouseActingMode);
      m_mouseActingMode = MouseButton1DownHandler (p_e);
      return m_mouseActingMode;
    }
  }//if
  else if (p_e.Type == csevMouseUp)
  {
    if (csMouseEventHelper::GetButton (&p_e) == 1)
    {
      bool l_b = MouseButton1UpHandler (p_e);
      if (l_b)
        m_mouseActingMode = false;
      
      return l_b;
    }
  }//else if
  else if (p_e.Type == csevMouseMove)
  {
    if (m_mouseActingMode)
      return MouseButtonMovingHandler (p_e);
  }//else if  
  else if (p_e.Type == csevMouseClick)
  {
    if (csMouseEventHelper::GetButton (&p_e) == 1)
      return MouseButton1ClickHandler (p_e);
    else if (csMouseEventHelper::GetButton (&p_e) == 2)
      return MouseButton2ClickHandler (p_e);
  }//else if   
  
  return false;
};






bool KMouseManager::MouseButton1DownHandler (iEvent& p_ev)
{  
  if (g_ske->m_appState != KAppState::EDITING)
    return false;

  if (!g_ske->m_aws->MouseInComponent
    (csMouseEventHelper::GetX (&p_ev), 
    csMouseEventHelper::GetY (&p_ev)) && 
    m_mode == TRANSLATING_OBJECT_MODE)
  {
    csRef<iEvent> l_e = KDragManager::CreateAnEvent (g_ske->m_eventOutlet, cscmdDragStart);
    l_e->Add (KDM_TRANSLATING_KEY, true);
    l_e->Add (KDM_XAXIS_KEY, csMouseEventHelper::GetX (&p_ev));
    l_e->Add (KDM_YAXIS_KEY, csMouseEventHelper::GetY (&p_ev));
    g_ske->m_eventOutlet->Post (l_e);
    return true;
  }//if
  else if (!g_ske->m_aws->MouseInComponent (
    csMouseEventHelper::GetX (&p_ev), 
    csMouseEventHelper::GetY (&p_ev)) &&
    m_mode == ROTATING_OBJECT_MODE)
  {
    csRef<iEvent> l_e = KDragManager::CreateAnEvent (g_ske->m_eventOutlet, cscmdDragStart);
    l_e->Add (KDM_ROTATING_KEY, true);
    l_e->Add (KDM_XAXIS_KEY, csMouseEventHelper::GetX (&p_ev));
    l_e->Add (KDM_YAXIS_KEY, csMouseEventHelper::GetY (&p_ev));
    g_ske->m_eventOutlet->Post (l_e);
    return true;
  }//else
  return false;
}

bool KMouseManager::MouseButton1UpHandler (iEvent& p_ev)
{
  if (g_ske->m_appState != KAppState::EDITING)
    return false;
  
  if (!g_ske->m_aws->MouseInComponent (
    csMouseEventHelper::GetX (&p_ev),
    csMouseEventHelper::GetY (&p_ev)) && 
    m_mode == TRANSLATING_OBJECT_MODE)
  {
    csRef<iEvent> l_e = KDragManager::CreateAnEvent (g_ske->m_eventOutlet, cscmdDragEnd);
    l_e->Add (KDM_TRANSLATING_KEY, true);
    g_ske->m_eventOutlet->Post (l_e);
    return true;
  }//if
  else if (!g_ske->m_aws->MouseInComponent (
    csMouseEventHelper::GetX (&p_ev),
    csMouseEventHelper::GetY (&p_ev)) &&
    m_mode == ROTATING_OBJECT_MODE)
  {
    csRef<iEvent> l_e = KDragManager::CreateAnEvent (g_ske->m_eventOutlet, cscmdDragEnd);
    l_e->Add (KDM_ROTATING_KEY, true);
    g_ske->m_eventOutlet->Post (l_e);
    return true;
  }//else

  return false;
}

bool KMouseManager::MouseButton1ClickHandler (iEvent& p_e) 
{
  if (g_ske->m_appState != KAppState::EDITING)
    return false;

  //if the mouse is outside any top-level window of aws, catch the click!
  if (!g_ske->m_aws->MouseInComponent (
    csMouseEventHelper::GetX (&p_e),
    csMouseEventHelper::GetY (&p_e)))
  {
    csVector3 lIntersection; 
    float lCrap;
    g_ske->CalculateIntersection (
      csMouseEventHelper::GetX (&p_e),
      csMouseEventHelper::GetY (&p_e), csPlane3 (0, 1, 0),
      lIntersection, lCrap);
    switch (m_mode)
    {
      case PUTTING_BLOCK_MODE:
      {
        char l_tmp[300];//??

        sprintf (l_tmp, "%s %d %d %s",
          (char const*)g_ske->GetSelectedBlockId (), (int)kround (lIntersection.x),
          (int)kround (lIntersection.z), 
          (char const*)KOrientation::NORTH);
        return KCommandProcessor::_Perform ("put_block", l_tmp);
      }//case
      
      case CREATING_PATH_MODE:
      {
        g_ske->m_path->AddPoint (lIntersection.x, lIntersection.z);
        return true;
      }//case
    }//switch
  }//if
  
  return false;
}

bool KMouseManager::MouseButton2ClickHandler (iEvent& p_e) 
{
  if (g_ske->m_appState != KAppState::EDITING)
    return false;
  
  //
  //dont switch the cursor shape if the mode is activated.
  if (m_mouseActingMode)
    return false;

  static int l_crap = 0;//??REMOVEME
  if (++l_crap > 2)//??REMOVEME
    l_crap = 0;//??REMOVEME
  switch (l_crap)
  {
  case 0://arrow
    SetMode (PUTTING_BLOCK_MODE);
    return true;
  case 1://picking
    g_ske->m_cursor->SetVisible (false);//??????UGLY HACK!
    SetMode (TRANSLATING_OBJECT_MODE);
    return true;
  case 2://rotating
    SetMode (ROTATING_OBJECT_MODE);
    return true;
  }//switch

  return false;
}    

bool KMouseManager::MouseButtonMovingHandler (iEvent& p_e) 
{
  if (g_ske->m_appState != KAppState::EDITING)
    return false;
  
  csRef<iEvent> l_e = KDragManager::CreateAnEvent 
    (g_ske->m_eventOutlet, cscmdDragging);
  l_e->Add (KDM_XAXIS_KEY, csMouseEventHelper::GetX (&p_e));
  l_e->Add (KDM_YAXIS_KEY, csMouseEventHelper::GetY (&p_e));  
  
  if (m_mode == ROTATING_OBJECT_MODE)
    l_e->Add (KDM_ROTATING_KEY, true);
  else if (m_mode == TRANSLATING_OBJECT_MODE)
    l_e->Add (KDM_TRANSLATING_KEY, true);
  
  g_ske->m_eventOutlet->Post (l_e);
  return true;
}

bool KMouseManager::StartCreatingPath ()
{
  if (m_mode == CREATING_PATH_MODE)
    return false;
  else
    m_mode = CREATING_PATH_MODE;
  return true;
}

bool KMouseManager::StopCreatingPath ()
{
  if (m_mode != CREATING_PATH_MODE)
    return false;
  else
    m_mode = PUTTING_BLOCK_MODE;
  return true;
}

int KMouseManager::GetLastX ()
{
  return m_mouse->GetLastX ();
}

int KMouseManager::GetLastY ()
{
  return m_mouse->GetLastY ();
}


void KMouseManager::SetMode (MOUSEMANAGER_MODE p_mode)
{
  m_mode = p_mode;
}

MOUSEMANAGER_MODE KMouseManager::GetMode ()
{
  return m_mode;
}
See more files for this project here