vpWin32Window.cpp

/****************************************************************************
 *
 * $Id: vpWin32Window.cpp 4574 2014-01-09 08:48:51Z fspindle $
 *
 * This file is part of the ViSP software.
 * Copyright (C) 2005 - 2014 by INRIA. All rights reserved.
 * 
 * This software is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * ("GPL") version 2 as published by the Free Software Foundation.
 * See the file LICENSE.txt at the root directory of this source
 * distribution for additional information about the GNU GPL.
 *
 * For using ViSP with software that can not be combined with the GNU
 * GPL, please contact INRIA about acquiring a ViSP Professional 
 * Edition License.
 *
 * See http://www.irisa.fr/lagadic/visp/visp.html for more information.
 * 
 * This software was developed at:
 * INRIA Rennes - Bretagne Atlantique
 * Campus Universitaire de Beaulieu
 * 35042 Rennes Cedex
 * France
 * http://www.irisa.fr/lagadic
 *
 * If you have questions regarding the use of this file, please contact
 * INRIA at visp@inria.fr
 * 
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 *
 *
 * Description:
 * Windows 32 display's window class
 *
 * Authors:
 * Bruno Renier
 * Anthony Saunier
 *
 *****************************************************************************/
#include <visp/vpConfig.h>
#include <iostream>
#include <visp/vpWin32API.h>

#if ( defined(VISP_HAVE_GDI) || defined(VISP_HAVE_D3D9) )

#define MAX_SEM_COUNT 2147483647

#ifndef DOXYGEN_SHOULD_SKIP_THIS

#include <visp/vpWin32Window.h>

//Should be already defined ...
#ifndef GET_X_LPARAM
# define GET_X_LPARAM(lp)                        ((int)(short)LOWORD(lp))
#endif

#ifndef GET_Y_LPARAM
# define GET_Y_LPARAM(lp)                        ((int)(short)HIWORD(lp))
#endif

//declares the window as thread local
//allows multiple displays
_declspec(thread) vpWin32Window * window;

bool vpWin32Window::registered = false; 
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
  //the first time this callback is executed, put the window in initialized state
  if (window != NULL)
  {
    if (!window->isInitialized())
    {
      window->initialized = true;
      vpReleaseSemaphore(window->semaInit,1,NULL);      
    }
  }

  switch (message)
  {
    case vpWM_DISPLAY:
      //redraw the whole window
      InvalidateRect(window->getHWnd(), NULL, TRUE);
      UpdateWindow(window->getHWnd());
      break;

    case vpWM_DISPLAY_ROI:
    {
      RECT rect;
      typedef struct _half_rect_t{
        unsigned short left_top;
        unsigned short right_bottom;
      } half_rect_t;

      half_rect_t hr1;
      half_rect_t hr2;
                  
      hr1 = *((half_rect_t*)(&wParam));
      hr2 = *((half_rect_t*)(&lParam));

      rect.left = hr1.left_top;
      rect.right = hr1.right_bottom;

      rect.top = hr2.left_top;
      rect.bottom = hr2.right_bottom;

      InvalidateRect(window->getHWnd(), &rect, TRUE);
      UpdateWindow(window->getHWnd());
    }
      break;

    case WM_LBUTTONDOWN:
     {
        window->clickX = GET_X_LPARAM(lParam);
        window->clickY = GET_Y_LPARAM(lParam);

        window->clickButton = vpMouseButton::button1;
        vpReleaseSemaphore(window->semaClick,1,NULL);
      }
      break;

    case WM_MBUTTONDOWN:
      {
        window->clickX = GET_X_LPARAM(lParam);
        window->clickY = GET_Y_LPARAM(lParam);

        window->clickButton = vpMouseButton::button2;
        vpReleaseSemaphore(window->semaClick,1,NULL);
      }
      break;

    case WM_RBUTTONDOWN:
      {
        window->clickX = GET_X_LPARAM(lParam);
        window->clickY = GET_Y_LPARAM(lParam);

        window->clickButton = vpMouseButton::button3;
        vpReleaseSemaphore(window->semaClick,1,NULL);
       }
      break;

    case WM_LBUTTONUP:
      {
        window->clickXUp = GET_X_LPARAM(lParam);
        window->clickYUp = GET_Y_LPARAM(lParam);

        window->clickButtonUp = vpMouseButton::button1;
        vpReleaseSemaphore(window->semaClickUp,1,NULL);
      }
      break;

    case WM_MBUTTONUP:
      {
        window->clickXUp = GET_X_LPARAM(lParam);
        window->clickYUp = GET_Y_LPARAM(lParam);

        window->clickButtonUp = vpMouseButton::button2;
        vpReleaseSemaphore(window->semaClickUp,1,NULL);
      }
      break;

    case WM_RBUTTONUP:
      {
        window->clickXUp = GET_X_LPARAM(lParam);
        window->clickYUp = GET_Y_LPARAM(lParam);

        window->clickButtonUp = vpMouseButton::button3;
        vpReleaseSemaphore(window->semaClickUp,1,NULL);
      }
      break;
    case WM_MOUSEMOVE:
      {        
        window->coordX = GET_X_LPARAM(lParam);
        window->coordY = GET_Y_LPARAM(lParam);        
            vpReleaseSemaphore(window->semaMove,1,NULL);        
      }
      break;

    case WM_SYSKEYDOWN: 
      // case WM_SYSKEYUP:
    case WM_KEYDOWN: 
      //case WM_KEYUP: 
      {
    GetKeyNameText((LONG)lParam, window->lpString, 10); // 10 is the size of lpString
    //window->key = MapVirtualKey(wParam, MAPVK_VK_TO_CHAR);
    vpReleaseSemaphore(window->semaKey,1,NULL);
    break;
      }

    case WM_COMMAND:

      break;

      //we must prevent the window from erasing the background each time a
      //repaint is needed
    case WM_ERASEBKGND:
      return (LRESULT)1;

    case WM_PAINT:
      //render the display
      window->renderer->render();
      break;

    case vpWM_CLOSEDISPLAY:
      //cleanup code here, if needed
      //destroys the window
      DestroyWindow(hWnd);
      break;

    case WM_DESTROY:
      PostQuitMessage(0);
      break;
    default:
      return DefWindowProc(hWnd, message, wParam, lParam);
  }
  return 0;
}

vpWin32Window::vpWin32Window(vpWin32Renderer * rend): initialized(false)
{
  renderer = rend;
  
  //registered is static member class and is initialized at the beginning of this file (registered = false)
  
  //creates the semaphores
  semaInit = CreateSemaphore(NULL,0,1,NULL);
  semaClick = CreateSemaphore(NULL,0,MAX_SEM_COUNT,NULL);
  semaClickUp = CreateSemaphore(NULL,0,MAX_SEM_COUNT,NULL);
  semaKey = CreateSemaphore(NULL,0,MAX_SEM_COUNT,NULL);
  semaMove = CreateSemaphore(NULL,0,MAX_SEM_COUNT,NULL);

}

vpWin32Window::~vpWin32Window()
{
  delete renderer;
  CloseHandle(semaInit);
  CloseHandle(semaClick);
  CloseHandle(semaClickUp);
  CloseHandle(semaKey);
  CloseHandle(semaMove);
}


void vpWin32Window::initWindow(const char* title, int posx, int posy, unsigned int w, unsigned int h)
{
  //the window's style
  DWORD style = WS_OVERLAPPEDWINDOW | WS_VISIBLE;
  const char g_szClassName[] = "ViSPWindowClass";

  RECT rect;
  rect.left=0;
  rect.right=static_cast<int>(w);
  rect.top=0;
  rect.bottom=static_cast<int>(h);

  //now we register the window's class
  WNDCLASSEX wcex;

  wcex.cbSize = sizeof(WNDCLASSEX);

  wcex.style   = CS_HREDRAW | CS_VREDRAW | CS_NOCLOSE ;
  wcex.lpfnWndProc = (WNDPROC)WndProc;
  wcex.cbClsExtra  = 0;
  wcex.cbWndExtra  = 0;
  wcex.hInstance  = hInst;
  wcex.hIcon   = LoadIcon(NULL, IDI_APPLICATION);
  wcex.hCursor  = LoadCursor(NULL, IDC_ARROW);
  wcex.hbrBackground =(HBRUSH)(COLOR_WINDOW+1);
  wcex.lpszMenuName = NULL;
  wcex.lpszClassName = g_szClassName;
  wcex.hIconSm  = LoadIcon(NULL, IDI_APPLICATION);
  
  RegisterClassEx(&wcex);

  AdjustWindowRectEx(&rect, style, false, style);
  // std::cout << "win client size  (orig)(w,h): " << rect.left << " " << rect.top << " " << rect.right << " " << rect.bottom << std::endl;

  //creates the window
  hWnd = CreateWindowEx(WS_EX_APPWINDOW, g_szClassName, title, style,
                        posx, posy, rect.right-rect.left, rect.bottom-rect.top, NULL, NULL, hInst, NULL);
  if (hWnd == NULL)
  {
      DWORD err= GetLastError();
      std::cout << "err CreateWindowEx=" << err << std::endl;
    throw vpDisplayException(vpDisplayException::cannotOpenWindowError,
                             "Can't create the window!");
  }
  SetWindowPos(hWnd, NULL, 0, 0, rect.right - rect.left, rect.bottom - rect.top, SWP_NOZORDER | SWP_NOMOVE);     

  //needed if we want to access it from the callback method (message handler)
  window = this;

  //initialize the renderer
  renderer->init(hWnd, w, h);

  //displays the window
  ShowWindow(hWnd, SW_SHOWDEFAULT);
  //ShowWindow(hWnd, SW_SHOW);
  UpdateWindow(hWnd);

  MSG msg;

  //starts the message loop
  while (true)
  {
    BOOL val = GetMessage(&msg, NULL, 0, 0);
    if(val==-1){
      std::cout << "GetMessage error:" << GetLastError() << std::endl;
      break;
    }else if(val==0){      
      break;
    }else{
      if (!TranslateAccelerator(msg.hwnd, NULL, &msg))
      {        
        TranslateMessage(&msg);        
        DispatchMessage(&msg);
      }
    }
  }
}

#endif
#endif