You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
154 lines
6.0 KiB
154 lines
6.0 KiB
/*
|
|
Copyright 2005-2014 Intel Corporation. All Rights Reserved.
|
|
|
|
This file is part of Threading Building Blocks.
|
|
|
|
Threading Building Blocks is free software; you can redistribute it
|
|
and/or modify it under the terms of the GNU General Public License
|
|
version 2 as published by the Free Software Foundation.
|
|
|
|
Threading Building Blocks 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 General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with Threading Building Blocks; if not, write to the Free Software
|
|
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
|
|
|
As a special exception, you may use this file as part of a free software
|
|
library without restriction. Specifically, if other files instantiate
|
|
templates or use macros or inline functions from this file, or you compile
|
|
this file and link it with other files to produce an executable, this
|
|
file does not by itself cause the resulting executable to be covered by
|
|
the GNU General Public License. This exception does not however
|
|
invalidate any other reasons why the executable file might be covered by
|
|
the GNU General Public License.
|
|
*/
|
|
|
|
// common Windows parts
|
|
#include "winvideo.h"
|
|
// include GDI+ headers
|
|
#include <gdiplus.h>
|
|
// and another headers
|
|
#include <stdio.h>
|
|
|
|
// tag linking library
|
|
#pragma comment(lib, "gdiplus.lib")
|
|
|
|
// global specific variables
|
|
Gdiplus::Bitmap * g_pBitmap; // main drawing bitmap
|
|
ULONG_PTR gdiplusToken;
|
|
Gdiplus::GdiplusStartupInput gdiplusStartupInput;// GDI+
|
|
|
|
//! display system error
|
|
bool DisplayError(LPSTR lpstrErr, HRESULT hres)
|
|
{
|
|
static bool InError = false;
|
|
int retval = 0;
|
|
if (!InError)
|
|
{
|
|
InError = true;
|
|
LPCSTR lpMsgBuf;
|
|
if(!hres) hres = GetLastError();
|
|
FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
|
|
NULL, hres, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL );
|
|
retval = MessageBox(g_hAppWnd, lpstrErr, lpMsgBuf, MB_OK|MB_ICONERROR);
|
|
LocalFree( (HLOCAL)lpMsgBuf );
|
|
InError = false;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//! Win event processing function
|
|
LRESULT CALLBACK InternalWndProc(HWND hwnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
switch (iMsg)
|
|
{
|
|
case WM_MOVE:
|
|
// Check to make sure our window exists before we tell it to repaint.
|
|
// This will fail the first time (while the window is being created).
|
|
if (hwnd) {
|
|
InvalidateRect(hwnd, NULL, FALSE);
|
|
UpdateWindow(hwnd);
|
|
}
|
|
return 0L;
|
|
|
|
case WM_PAINT:
|
|
{
|
|
PAINTSTRUCT ps;
|
|
Gdiplus::Graphics graphics( BeginPaint(hwnd, &ps) );
|
|
// redraw just requested area. This call is as fast as simple DrawImage() call.
|
|
if(g_video->updating) graphics.DrawImage(g_pBitmap, ps.rcPaint.left, ps.rcPaint.top, ps.rcPaint.left, ps.rcPaint.top,
|
|
ps.rcPaint.right, ps.rcPaint.bottom, Gdiplus::UnitPixel);
|
|
EndPaint(hwnd, &ps);
|
|
}
|
|
return 0L;
|
|
|
|
// Proccess all mouse and keyboard events
|
|
case WM_LBUTTONDOWN: g_video->on_mouse( (int)LOWORD(lParam), (int)HIWORD(lParam), 1); break;
|
|
case WM_LBUTTONUP: g_video->on_mouse( (int)LOWORD(lParam), (int)HIWORD(lParam), -1); break;
|
|
case WM_RBUTTONDOWN: g_video->on_mouse( (int)LOWORD(lParam), (int)HIWORD(lParam), 2); break;
|
|
case WM_RBUTTONUP: g_video->on_mouse( (int)LOWORD(lParam), (int)HIWORD(lParam), -2); break;
|
|
case WM_MBUTTONDOWN: g_video->on_mouse( (int)LOWORD(lParam), (int)HIWORD(lParam), 3); break;
|
|
case WM_MBUTTONUP: g_video->on_mouse( (int)LOWORD(lParam), (int)HIWORD(lParam), -3); break;
|
|
case WM_CHAR: g_video->on_key( (int)wParam); break;
|
|
|
|
// some useless stuff
|
|
case WM_ERASEBKGND: return 1; // keeps erase-background events from happening, reduces chop
|
|
case WM_DISPLAYCHANGE: return 0;
|
|
|
|
// Now, shut down the window...
|
|
case WM_DESTROY: PostQuitMessage(0); return 0;
|
|
}
|
|
// call user defined proc, if exists
|
|
return g_pUserProc? g_pUserProc(hwnd, iMsg, wParam, lParam) : DefWindowProc(hwnd, iMsg, wParam, lParam);
|
|
}
|
|
|
|
///////////// video functions ////////////////
|
|
|
|
bool video::init_window(int sizex, int sizey)
|
|
{
|
|
assert(win_hInstance != 0);
|
|
g_sizex = sizex; g_sizey = sizey;
|
|
if (!WinInit(win_hInstance, win_iCmdShow, gWndClass, title, true)) {
|
|
DisplayError("Unable to initialize the program's window.");
|
|
return false;
|
|
}
|
|
ShowWindow(g_hAppWnd, SW_SHOW);
|
|
Gdiplus::GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
|
|
g_pImg = new unsigned int[sizex*sizey];
|
|
g_pBitmap = new Gdiplus::Bitmap(g_sizex, g_sizey, 4*g_sizex, PixelFormat32bppRGB, (BYTE*)g_pImg );
|
|
running = true;
|
|
return true;
|
|
}
|
|
|
|
void video::terminate()
|
|
{
|
|
if(g_pBitmap) { delete g_pBitmap; g_pBitmap = 0; }
|
|
Gdiplus::GdiplusShutdown(gdiplusToken);
|
|
g_video = 0; running = false;
|
|
if(g_pImg) { delete[] g_pImg; g_pImg = 0; }
|
|
}
|
|
|
|
//////////// drawing area constructor & destructor /////////////
|
|
|
|
drawing_area::drawing_area(int x, int y, int sizex, int sizey)
|
|
: start_x(x), start_y(y), size_x(sizex), size_y(sizey), pixel_depth(24),
|
|
base_index(y*g_sizex + x), max_index(g_sizex*g_sizey), index_stride(g_sizex), ptr32(g_pImg)
|
|
{
|
|
assert(x < g_sizex); assert(y < g_sizey);
|
|
assert(x+sizex <= g_sizex); assert(y+sizey <= g_sizey);
|
|
|
|
index = base_index; // current index
|
|
}
|
|
|
|
void drawing_area::update()
|
|
{
|
|
if(g_video->updating) {
|
|
RECT r;
|
|
r.left = start_x; r.right = start_x + size_x;
|
|
r.top = start_y; r.bottom = start_y + size_y;
|
|
InvalidateRect(g_hAppWnd, &r, false);
|
|
}
|
|
}
|