2010-05-12 01:44:00 +08:00
|
|
|
/*M///////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
// IMPORTANT: READ BEFORE DOWNLOADING, COPYING, INSTALLING OR USING.
|
|
|
|
//
|
|
|
|
// By downloading, copying, installing or using the software you agree to this license.
|
|
|
|
// If you do not agree to this license, do not download, install,
|
|
|
|
// copy or use the software.
|
|
|
|
//
|
|
|
|
//
|
|
|
|
// Intel License Agreement
|
|
|
|
// For Open Source Computer Vision Library
|
|
|
|
//
|
|
|
|
// Copyright (C) 2000, Intel Corporation, all rights reserved.
|
|
|
|
// Third party copyrights are property of their respective owners.
|
|
|
|
//
|
|
|
|
// Redistribution and use in source and binary forms, with or without modification,
|
|
|
|
// are permitted provided that the following conditions are met:
|
|
|
|
//
|
|
|
|
// * Redistribution's of source code must retain the above copyright notice,
|
|
|
|
// this list of conditions and the following disclaimer.
|
|
|
|
//
|
|
|
|
// * Redistribution's 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.
|
|
|
|
//
|
|
|
|
// * The name of Intel Corporation may not 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 Intel Corporation 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.
|
|
|
|
//
|
|
|
|
//M*/
|
|
|
|
|
|
|
|
#include "precomp.hpp"
|
2019-09-05 18:55:17 +08:00
|
|
|
|
|
|
|
using namespace cv;
|
|
|
|
|
2014-01-16 17:09:25 +08:00
|
|
|
#include <windowsx.h> // required for GET_X_LPARAM() and GET_Y_LPARAM() macros
|
2010-05-12 01:44:00 +08:00
|
|
|
|
2017-07-25 18:23:44 +08:00
|
|
|
#if defined _WIN32
|
2010-05-12 01:44:00 +08:00
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
#ifdef __GNUC__
|
|
|
|
# pragma GCC diagnostic ignored "-Wmissing-declarations"
|
|
|
|
#endif
|
2012-05-18 04:19:48 +08:00
|
|
|
|
2014-12-31 17:15:48 +08:00
|
|
|
#if (_WIN32_IE < 0x0500)
|
|
|
|
#pragma message("WARNING: Win32 UI needs to be compiled with _WIN32_IE >= 0x0500 (_WIN32_IE_IE50)")
|
|
|
|
#define _WIN32_IE 0x0500
|
|
|
|
#endif
|
|
|
|
|
2010-05-12 01:44:00 +08:00
|
|
|
#include <commctrl.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <assert.h>
|
|
|
|
|
2011-11-21 19:58:52 +08:00
|
|
|
#ifdef HAVE_OPENGL
|
|
|
|
#include <memory>
|
2011-11-28 19:50:46 +08:00
|
|
|
#include <algorithm>
|
|
|
|
#include <vector>
|
|
|
|
#include <functional>
|
2013-03-13 20:22:44 +08:00
|
|
|
#include "opencv2/highgui.hpp"
|
2017-02-06 01:15:10 +08:00
|
|
|
#include <GL/gl.h>
|
2018-12-16 12:50:32 +08:00
|
|
|
#include "opencv2/core/opengl.hpp"
|
2011-11-21 19:58:52 +08:00
|
|
|
#endif
|
|
|
|
|
2010-05-12 01:44:00 +08:00
|
|
|
static const char* trackbar_text =
|
|
|
|
" ";
|
|
|
|
|
2019-12-17 05:23:30 +08:00
|
|
|
#if defined _M_X64 || defined __x86_64 || defined _M_ARM64
|
2010-05-12 01:44:00 +08:00
|
|
|
|
|
|
|
#define icvGetWindowLongPtr GetWindowLongPtr
|
|
|
|
#define icvSetWindowLongPtr( hwnd, id, ptr ) SetWindowLongPtr( hwnd, id, (LONG_PTR)(ptr) )
|
|
|
|
#define icvGetClassLongPtr GetClassLongPtr
|
|
|
|
|
|
|
|
#define CV_USERDATA GWLP_USERDATA
|
|
|
|
#define CV_WNDPROC GWLP_WNDPROC
|
|
|
|
#define CV_HCURSOR GCLP_HCURSOR
|
|
|
|
#define CV_HBRBACKGROUND GCLP_HBRBACKGROUND
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
|
|
#define icvGetWindowLongPtr GetWindowLong
|
|
|
|
#define icvSetWindowLongPtr( hwnd, id, ptr ) SetWindowLong( hwnd, id, (size_t)ptr )
|
|
|
|
#define icvGetClassLongPtr GetClassLong
|
|
|
|
|
|
|
|
#define CV_USERDATA GWL_USERDATA
|
|
|
|
#define CV_WNDPROC GWL_WNDPROC
|
|
|
|
#define CV_HCURSOR GCL_HCURSOR
|
|
|
|
#define CV_HBRBACKGROUND GCL_HBRBACKGROUND
|
|
|
|
|
|
|
|
#endif
|
|
|
|
|
2014-01-19 22:32:22 +08:00
|
|
|
#ifndef WM_MOUSEHWHEEL
|
|
|
|
#define WM_MOUSEHWHEEL 0x020E
|
|
|
|
#endif
|
|
|
|
|
2012-11-01 16:44:10 +08:00
|
|
|
static void FillBitmapInfo( BITMAPINFO* bmi, int width, int height, int bpp, int origin )
|
2010-05-12 01:44:00 +08:00
|
|
|
{
|
|
|
|
assert( bmi && width >= 0 && height >= 0 && (bpp == 8 || bpp == 24 || bpp == 32));
|
|
|
|
|
|
|
|
BITMAPINFOHEADER* bmih = &(bmi->bmiHeader);
|
|
|
|
|
|
|
|
memset( bmih, 0, sizeof(*bmih));
|
|
|
|
bmih->biSize = sizeof(BITMAPINFOHEADER);
|
|
|
|
bmih->biWidth = width;
|
|
|
|
bmih->biHeight = origin ? abs(height) : -abs(height);
|
|
|
|
bmih->biPlanes = 1;
|
|
|
|
bmih->biBitCount = (unsigned short)bpp;
|
|
|
|
bmih->biCompression = BI_RGB;
|
|
|
|
|
|
|
|
if( bpp == 8 )
|
|
|
|
{
|
|
|
|
RGBQUAD* palette = bmi->bmiColors;
|
|
|
|
int i;
|
|
|
|
for( i = 0; i < 256; i++ )
|
|
|
|
{
|
|
|
|
palette[i].rgbBlue = palette[i].rgbGreen = palette[i].rgbRed = (BYTE)i;
|
|
|
|
palette[i].rgbReserved = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
struct CvWindow;
|
|
|
|
|
|
|
|
typedef struct CvTrackbar
|
|
|
|
{
|
|
|
|
int signature;
|
|
|
|
HWND hwnd;
|
|
|
|
char* name;
|
|
|
|
CvTrackbar* next;
|
|
|
|
CvWindow* parent;
|
|
|
|
HWND buddy;
|
|
|
|
int* data;
|
|
|
|
int pos;
|
|
|
|
int maxval;
|
2015-10-19 18:58:43 +08:00
|
|
|
int minval;
|
2010-05-12 01:44:00 +08:00
|
|
|
void (*notify)(int);
|
|
|
|
void (*notify2)(int, void*);
|
|
|
|
void* userdata;
|
|
|
|
int id;
|
|
|
|
}
|
|
|
|
CvTrackbar;
|
|
|
|
|
2011-11-28 19:50:46 +08:00
|
|
|
|
2010-05-12 01:44:00 +08:00
|
|
|
typedef struct CvWindow
|
|
|
|
{
|
|
|
|
int signature;
|
|
|
|
HWND hwnd;
|
|
|
|
char* name;
|
|
|
|
CvWindow* prev;
|
|
|
|
CvWindow* next;
|
|
|
|
HWND frame;
|
|
|
|
|
|
|
|
HDC dc;
|
|
|
|
HGDIOBJ image;
|
|
|
|
int last_key;
|
|
|
|
int flags;
|
2012-06-08 11:15:08 +08:00
|
|
|
int status;//0 normal, 1 fullscreen (YV)
|
2010-05-12 01:44:00 +08:00
|
|
|
|
|
|
|
CvMouseCallback on_mouse;
|
|
|
|
void* on_mouse_param;
|
|
|
|
|
|
|
|
struct
|
|
|
|
{
|
|
|
|
HWND toolbar;
|
|
|
|
int pos;
|
|
|
|
int rows;
|
|
|
|
WNDPROC toolBarProc;
|
|
|
|
CvTrackbar* first;
|
|
|
|
}
|
|
|
|
toolbar;
|
2011-11-21 19:58:52 +08:00
|
|
|
|
|
|
|
int width;
|
|
|
|
int height;
|
|
|
|
|
|
|
|
// OpenGL support
|
|
|
|
|
|
|
|
#ifdef HAVE_OPENGL
|
|
|
|
bool useGl;
|
|
|
|
HGLRC hGLRC;
|
|
|
|
|
2011-12-12 20:52:06 +08:00
|
|
|
CvOpenGlDrawCallback glDrawCallback;
|
2011-11-21 19:58:52 +08:00
|
|
|
void* glDrawData;
|
|
|
|
#endif
|
2010-05-12 01:44:00 +08:00
|
|
|
}
|
|
|
|
CvWindow;
|
|
|
|
|
|
|
|
#define HG_BUDDY_WIDTH 130
|
|
|
|
|
|
|
|
#ifndef TBIF_SIZE
|
|
|
|
#define TBIF_SIZE 0x40
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef TB_SETBUTTONINFO
|
|
|
|
#define TB_SETBUTTONINFO (WM_USER + 66)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef TBM_GETTOOLTIPS
|
|
|
|
#define TBM_GETTOOLTIPS (WM_USER + 30)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
static LRESULT CALLBACK HighGUIProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
|
|
static LRESULT CALLBACK WindowProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
|
|
static LRESULT CALLBACK MainWindowProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
|
|
|
|
static void icvUpdateWindowPos( CvWindow* window );
|
|
|
|
|
|
|
|
static CvWindow* hg_windows = 0;
|
2011-05-14 04:00:58 +08:00
|
|
|
|
|
|
|
typedef int (CV_CDECL * CvWin32WindowCallback)(HWND, UINT, WPARAM, LPARAM, int*);
|
2010-05-12 01:44:00 +08:00
|
|
|
static CvWin32WindowCallback hg_on_preprocess = 0, hg_on_postprocess = 0;
|
|
|
|
static HINSTANCE hg_hinstance = 0;
|
|
|
|
|
|
|
|
static const char* highGUIclassName = "HighGUI class";
|
|
|
|
static const char* mainHighGUIclassName = "Main HighGUI class";
|
|
|
|
|
|
|
|
static void icvCleanupHighgui()
|
|
|
|
{
|
|
|
|
cvDestroyAllWindows();
|
|
|
|
UnregisterClass(highGUIclassName, hg_hinstance);
|
|
|
|
UnregisterClass(mainHighGUIclassName, hg_hinstance);
|
|
|
|
}
|
|
|
|
|
|
|
|
CV_IMPL int cvInitSystem( int, char** )
|
|
|
|
{
|
|
|
|
static int wasInitialized = 0;
|
|
|
|
|
|
|
|
// check initialization status
|
|
|
|
if( !wasInitialized )
|
|
|
|
{
|
|
|
|
// Initialize the stogare
|
|
|
|
hg_windows = 0;
|
|
|
|
|
|
|
|
// Register the class
|
|
|
|
WNDCLASS wndc;
|
2012-02-06 16:13:11 +08:00
|
|
|
wndc.style = CS_OWNDC | CS_VREDRAW | CS_HREDRAW | CS_DBLCLKS;
|
2010-05-12 01:44:00 +08:00
|
|
|
wndc.lpfnWndProc = WindowProc;
|
|
|
|
wndc.cbClsExtra = 0;
|
|
|
|
wndc.cbWndExtra = 0;
|
|
|
|
wndc.hInstance = hg_hinstance;
|
|
|
|
wndc.lpszClassName = highGUIclassName;
|
|
|
|
wndc.lpszMenuName = highGUIclassName;
|
|
|
|
wndc.hIcon = LoadIcon(0, IDI_APPLICATION);
|
|
|
|
wndc.hCursor = (HCURSOR)LoadCursor(0, (LPSTR)(size_t)IDC_CROSS );
|
2020-09-30 02:50:06 +08:00
|
|
|
wndc.hbrBackground = (HBRUSH)GetStockObject(DKGRAY_BRUSH);
|
2010-05-12 01:44:00 +08:00
|
|
|
|
|
|
|
RegisterClass(&wndc);
|
|
|
|
|
|
|
|
wndc.lpszClassName = mainHighGUIclassName;
|
|
|
|
wndc.lpszMenuName = mainHighGUIclassName;
|
2020-09-30 02:50:06 +08:00
|
|
|
wndc.hbrBackground = (HBRUSH)GetStockObject(DKGRAY_BRUSH);
|
2010-05-12 01:44:00 +08:00
|
|
|
wndc.lpfnWndProc = MainWindowProc;
|
|
|
|
|
|
|
|
RegisterClass(&wndc);
|
|
|
|
atexit( icvCleanupHighgui );
|
|
|
|
|
|
|
|
wasInitialized = 1;
|
|
|
|
}
|
|
|
|
|
2015-03-06 19:59:26 +08:00
|
|
|
setlocale(LC_NUMERIC,"C");
|
|
|
|
|
2010-05-12 01:44:00 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
CV_IMPL int cvStartWindowThread(){
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static CvWindow* icvFindWindowByName( const char* name )
|
|
|
|
{
|
|
|
|
CvWindow* window = hg_windows;
|
|
|
|
|
|
|
|
for( ; window != 0 && strcmp( name, window->name) != 0; window = window->next )
|
|
|
|
;
|
|
|
|
|
|
|
|
return window;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static CvWindow* icvWindowByHWND( HWND hwnd )
|
|
|
|
{
|
|
|
|
CvWindow* window = (CvWindow*)icvGetWindowLongPtr( hwnd, CV_USERDATA );
|
|
|
|
return window != 0 && hg_windows != 0 &&
|
|
|
|
window->signature == CV_WINDOW_MAGIC_VAL ? window : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static CvTrackbar* icvTrackbarByHWND( HWND hwnd )
|
|
|
|
{
|
|
|
|
CvTrackbar* trackbar = (CvTrackbar*)icvGetWindowLongPtr( hwnd, CV_USERDATA );
|
|
|
|
return trackbar != 0 && trackbar->signature == CV_TRACKBAR_MAGIC_VAL &&
|
|
|
|
trackbar->hwnd == hwnd ? trackbar : 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static const char* icvWindowPosRootKey = "Software\\OpenCV\\HighGUI\\Windows\\";
|
|
|
|
|
|
|
|
// Window positions saving/loading added by Philip Gruebele.
|
|
|
|
//<a href="mailto:pgruebele@cox.net">pgruebele@cox.net</a>
|
|
|
|
// Restores the window position from the registry saved position.
|
|
|
|
static void
|
|
|
|
icvLoadWindowPos( const char* name, CvRect& rect )
|
|
|
|
{
|
|
|
|
HKEY hkey;
|
|
|
|
char szKey[1024];
|
2018-07-27 23:25:55 +08:00
|
|
|
strcpy_s( szKey, 1024, icvWindowPosRootKey );
|
|
|
|
strcat_s( szKey, 1024, name );
|
2010-05-12 01:44:00 +08:00
|
|
|
|
|
|
|
rect.x = rect.y = CW_USEDEFAULT;
|
|
|
|
rect.width = rect.height = 320;
|
|
|
|
|
|
|
|
if( RegOpenKeyEx(HKEY_CURRENT_USER,szKey,0,KEY_QUERY_VALUE,&hkey) == ERROR_SUCCESS )
|
|
|
|
{
|
|
|
|
// Yes we are installed.
|
|
|
|
DWORD dwType = 0;
|
|
|
|
DWORD dwSize = sizeof(int);
|
|
|
|
|
|
|
|
RegQueryValueEx(hkey, "Left", NULL, &dwType, (BYTE*)&rect.x, &dwSize);
|
|
|
|
RegQueryValueEx(hkey, "Top", NULL, &dwType, (BYTE*)&rect.y, &dwSize);
|
|
|
|
RegQueryValueEx(hkey, "Width", NULL, &dwType, (BYTE*)&rect.width, &dwSize);
|
|
|
|
RegQueryValueEx(hkey, "Height", NULL, &dwType, (BYTE*)&rect.height, &dwSize);
|
|
|
|
|
2017-08-25 19:25:16 +08:00
|
|
|
// Snap rect into closest monitor in case it falls outside it. // Adi Shavit
|
|
|
|
// set WIN32 RECT to be the loaded size
|
|
|
|
POINT tl_w32 = { rect.x, rect.y };
|
|
|
|
POINT tr_w32 = { rect.x + rect.width, rect.y };
|
|
|
|
|
|
|
|
// find monitor containing top-left and top-right corners, or NULL
|
|
|
|
HMONITOR hMonitor_l = MonitorFromPoint(tl_w32, MONITOR_DEFAULTTONULL);
|
|
|
|
HMONITOR hMonitor_r = MonitorFromPoint(tr_w32, MONITOR_DEFAULTTONULL);
|
|
|
|
|
|
|
|
// if neither are contained - the move window to origin of closest.
|
|
|
|
if (NULL == hMonitor_l && NULL == hMonitor_r)
|
|
|
|
{
|
|
|
|
// find monitor nearest to top-left corner
|
|
|
|
HMONITOR hMonitor_closest = MonitorFromPoint(tl_w32, MONITOR_DEFAULTTONEAREST);
|
|
|
|
|
|
|
|
// get coordinates of nearest monitor
|
|
|
|
MONITORINFO mi;
|
|
|
|
mi.cbSize = sizeof(mi);
|
|
|
|
GetMonitorInfo(hMonitor_closest, &mi);
|
|
|
|
|
|
|
|
rect.x = mi.rcWork.left;
|
|
|
|
rect.y = mi.rcWork.top;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (rect.width != (int)CW_USEDEFAULT && (rect.width < 0 || rect.width > 3000))
|
|
|
|
rect.width = 100;
|
|
|
|
if (rect.height != (int)CW_USEDEFAULT && (rect.height < 0 || rect.height > 3000))
|
|
|
|
rect.height = 100;
|
2010-05-12 01:44:00 +08:00
|
|
|
|
|
|
|
RegCloseKey(hkey);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Window positions saving/loading added by Philip Gruebele.
|
|
|
|
//<a href="mailto:pgruebele@cox.net">pgruebele@cox.net</a>
|
|
|
|
// philipg. Saves the window position in the registry
|
|
|
|
static void
|
|
|
|
icvSaveWindowPos( const char* name, CvRect rect )
|
|
|
|
{
|
|
|
|
static const DWORD MAX_RECORD_COUNT = 100;
|
|
|
|
HKEY hkey;
|
|
|
|
char szKey[1024];
|
|
|
|
char rootKey[1024];
|
2018-07-27 23:25:55 +08:00
|
|
|
strcpy_s( szKey, 1024, icvWindowPosRootKey );
|
|
|
|
strcat_s( szKey, 1024, name );
|
2012-06-08 11:15:08 +08:00
|
|
|
|
2010-05-12 01:44:00 +08:00
|
|
|
if( RegOpenKeyEx( HKEY_CURRENT_USER,szKey,0,KEY_READ,&hkey) != ERROR_SUCCESS )
|
|
|
|
{
|
|
|
|
HKEY hroot;
|
|
|
|
DWORD count = 0;
|
|
|
|
FILETIME oldestTime = { UINT_MAX, UINT_MAX };
|
|
|
|
char oldestKey[1024];
|
|
|
|
char currentKey[1024];
|
|
|
|
|
2018-07-27 23:25:55 +08:00
|
|
|
strcpy_s( rootKey, 1024, icvWindowPosRootKey );
|
2010-05-12 01:44:00 +08:00
|
|
|
rootKey[strlen(rootKey)-1] = '\0';
|
|
|
|
if( RegCreateKeyEx(HKEY_CURRENT_USER, rootKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_READ+KEY_WRITE, 0, &hroot, NULL) != ERROR_SUCCESS )
|
|
|
|
//RegOpenKeyEx( HKEY_CURRENT_USER,rootKey,0,KEY_READ,&hroot) != ERROR_SUCCESS )
|
|
|
|
return;
|
|
|
|
|
|
|
|
for(;;)
|
|
|
|
{
|
|
|
|
DWORD csize = sizeof(currentKey);
|
|
|
|
FILETIME accesstime = { 0, 0 };
|
|
|
|
LONG code = RegEnumKeyEx( hroot, count, currentKey, &csize, NULL, NULL, NULL, &accesstime );
|
|
|
|
if( code != ERROR_SUCCESS && code != ERROR_MORE_DATA )
|
|
|
|
break;
|
|
|
|
count++;
|
|
|
|
if( oldestTime.dwHighDateTime > accesstime.dwHighDateTime ||
|
|
|
|
(oldestTime.dwHighDateTime == accesstime.dwHighDateTime &&
|
|
|
|
oldestTime.dwLowDateTime > accesstime.dwLowDateTime) )
|
|
|
|
{
|
|
|
|
oldestTime = accesstime;
|
2018-07-27 23:25:55 +08:00
|
|
|
strcpy_s( oldestKey, 1024, currentKey );
|
2010-05-12 01:44:00 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if( count >= MAX_RECORD_COUNT )
|
|
|
|
RegDeleteKey( hroot, oldestKey );
|
|
|
|
RegCloseKey( hroot );
|
|
|
|
|
|
|
|
if( RegCreateKeyEx(HKEY_CURRENT_USER,szKey,0,NULL,REG_OPTION_NON_VOLATILE, KEY_WRITE, 0, &hkey, NULL) != ERROR_SUCCESS )
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
RegCloseKey( hkey );
|
|
|
|
if( RegOpenKeyEx( HKEY_CURRENT_USER,szKey,0,KEY_WRITE,&hkey) != ERROR_SUCCESS )
|
|
|
|
return;
|
|
|
|
}
|
2012-06-08 11:15:08 +08:00
|
|
|
|
2010-05-12 01:44:00 +08:00
|
|
|
RegSetValueEx(hkey, "Left", 0, REG_DWORD, (BYTE*)&rect.x, sizeof(rect.x));
|
|
|
|
RegSetValueEx(hkey, "Top", 0, REG_DWORD, (BYTE*)&rect.y, sizeof(rect.y));
|
|
|
|
RegSetValueEx(hkey, "Width", 0, REG_DWORD, (BYTE*)&rect.width, sizeof(rect.width));
|
|
|
|
RegSetValueEx(hkey, "Height", 0, REG_DWORD, (BYTE*)&rect.height, sizeof(rect.height));
|
|
|
|
RegCloseKey(hkey);
|
|
|
|
}
|
|
|
|
|
2018-01-18 12:49:47 +08:00
|
|
|
CvRect cvGetWindowRect_W32(const char* name)
|
|
|
|
{
|
2020-09-02 06:18:20 +08:00
|
|
|
RECT rect = { 0 };
|
2018-01-18 12:49:47 +08:00
|
|
|
CvRect result = cvRect(-1, -1, -1, -1);
|
|
|
|
|
|
|
|
CV_FUNCNAME( "cvGetWindowRect_W32" );
|
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
CvWindow* window;
|
|
|
|
|
|
|
|
if (!name)
|
|
|
|
CV_ERROR( CV_StsNullPtr, "NULL name string" );
|
|
|
|
window = icvFindWindowByName( name );
|
|
|
|
if (!window)
|
|
|
|
EXIT; // keep silence here
|
|
|
|
|
|
|
|
GetClientRect(window->hwnd, &rect);
|
|
|
|
{
|
|
|
|
POINT pt = {rect.left, rect.top};
|
|
|
|
ClientToScreen(window->hwnd, &pt);
|
|
|
|
result = cvRect(pt.x, pt.y, rect.right - rect.left, rect.bottom - rect.top);
|
|
|
|
}
|
|
|
|
__END__;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2010-06-13 00:56:01 +08:00
|
|
|
double cvGetModeWindow_W32(const char* name)//YV
|
2010-05-12 01:44:00 +08:00
|
|
|
{
|
2012-06-08 11:15:08 +08:00
|
|
|
double result = -1;
|
|
|
|
|
|
|
|
CV_FUNCNAME( "cvGetModeWindow_W32" );
|
2010-05-12 01:44:00 +08:00
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
CvWindow* window;
|
|
|
|
|
2011-11-23 18:05:24 +08:00
|
|
|
if (!name)
|
2010-05-12 01:44:00 +08:00
|
|
|
CV_ERROR( CV_StsNullPtr, "NULL name string" );
|
|
|
|
|
|
|
|
window = icvFindWindowByName( name );
|
2011-11-23 18:05:24 +08:00
|
|
|
if (!window)
|
|
|
|
EXIT; // keep silence here
|
2012-06-08 11:15:08 +08:00
|
|
|
|
2010-05-12 01:44:00 +08:00
|
|
|
result = window->status;
|
2012-06-08 11:15:08 +08:00
|
|
|
|
2010-05-12 01:44:00 +08:00
|
|
|
__END__;
|
2012-06-08 11:15:08 +08:00
|
|
|
return result;
|
2010-05-12 01:44:00 +08:00
|
|
|
}
|
|
|
|
|
2010-06-13 00:56:01 +08:00
|
|
|
void cvSetModeWindow_W32( const char* name, double prop_value)//Yannick Verdie
|
2010-05-12 01:44:00 +08:00
|
|
|
{
|
2012-06-08 11:15:08 +08:00
|
|
|
CV_FUNCNAME( "cvSetModeWindow_W32" );
|
2010-05-12 01:44:00 +08:00
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
__BEGIN__;
|
2010-05-12 01:44:00 +08:00
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
CvWindow* window;
|
2010-05-12 01:44:00 +08:00
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
if(!name)
|
|
|
|
CV_ERROR( CV_StsNullPtr, "NULL name string" );
|
2010-05-12 01:44:00 +08:00
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
window = icvFindWindowByName( name );
|
|
|
|
if( !window )
|
|
|
|
CV_ERROR( CV_StsNullPtr, "NULL window" );
|
2010-05-12 01:44:00 +08:00
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
if(window->flags & CV_WINDOW_AUTOSIZE)//if the flag CV_WINDOW_AUTOSIZE is set
|
|
|
|
EXIT;
|
2010-05-12 01:44:00 +08:00
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
{
|
|
|
|
DWORD dwStyle = (DWORD)GetWindowLongPtr(window->frame, GWL_STYLE);
|
|
|
|
CvRect position;
|
2010-05-12 01:44:00 +08:00
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
if (window->status==CV_WINDOW_FULLSCREEN && prop_value==CV_WINDOW_NORMAL)
|
|
|
|
{
|
|
|
|
icvLoadWindowPos(window->name,position );
|
|
|
|
SetWindowLongPtr(window->frame, GWL_STYLE, dwStyle | WS_CAPTION | WS_THICKFRAME);
|
2010-05-12 01:44:00 +08:00
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
SetWindowPos(window->frame, HWND_TOP, position.x, position.y , position.width,position.height, SWP_NOZORDER | SWP_FRAMECHANGED);
|
|
|
|
window->status=CV_WINDOW_NORMAL;
|
2010-05-12 01:44:00 +08:00
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
EXIT;
|
|
|
|
}
|
2010-05-12 01:44:00 +08:00
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
if (window->status==CV_WINDOW_NORMAL && prop_value==CV_WINDOW_FULLSCREEN)
|
|
|
|
{
|
|
|
|
//save dimension
|
2020-09-02 06:18:20 +08:00
|
|
|
RECT rect = { 0 };
|
2012-06-08 11:15:08 +08:00
|
|
|
GetWindowRect(window->frame, &rect);
|
|
|
|
CvRect RectCV = cvRect(rect.left, rect.top,rect.right - rect.left, rect.bottom - rect.top);
|
|
|
|
icvSaveWindowPos(window->name,RectCV );
|
2010-05-12 01:44:00 +08:00
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
//Look at coordinate for fullscreen
|
|
|
|
HMONITOR hMonitor;
|
|
|
|
MONITORINFO mi;
|
|
|
|
hMonitor = MonitorFromRect(&rect, MONITOR_DEFAULTTONEAREST);
|
2010-05-12 01:44:00 +08:00
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
mi.cbSize = sizeof(mi);
|
|
|
|
GetMonitorInfo(hMonitor, &mi);
|
2010-05-12 01:44:00 +08:00
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
//fullscreen
|
|
|
|
position.x=mi.rcMonitor.left;position.y=mi.rcMonitor.top;
|
|
|
|
position.width=mi.rcMonitor.right - mi.rcMonitor.left;position.height=mi.rcMonitor.bottom - mi.rcMonitor.top;
|
|
|
|
SetWindowLongPtr(window->frame, GWL_STYLE, dwStyle & ~WS_CAPTION & ~WS_THICKFRAME);
|
2010-05-12 01:44:00 +08:00
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
SetWindowPos(window->frame, HWND_TOP, position.x, position.y , position.width,position.height, SWP_NOZORDER | SWP_FRAMECHANGED);
|
|
|
|
window->status=CV_WINDOW_FULLSCREEN;
|
2010-05-12 01:44:00 +08:00
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
EXIT;
|
|
|
|
}
|
|
|
|
}
|
2010-05-12 01:44:00 +08:00
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
__END__;
|
2010-05-12 01:44:00 +08:00
|
|
|
}
|
|
|
|
|
2019-09-05 18:55:17 +08:00
|
|
|
double cvGetPropTopmost_W32(const char* name)
|
|
|
|
{
|
|
|
|
double result = -1;
|
|
|
|
|
|
|
|
CV_Assert(name);
|
|
|
|
|
|
|
|
CvWindow* window = icvFindWindowByName(name);
|
|
|
|
if (!window)
|
|
|
|
CV_Error(Error::StsNullPtr, "NULL window");
|
|
|
|
|
|
|
|
LONG style = GetWindowLongA(window->frame, GWL_EXSTYLE); // -20
|
|
|
|
if (!style)
|
|
|
|
{
|
|
|
|
std::ostringstream errorMsg;
|
|
|
|
errorMsg << "window(" << name << "): failed to retrieve extended window style using GetWindowLongA(); error code: " << GetLastError();
|
|
|
|
CV_Error(Error::StsError, errorMsg.str().c_str());
|
|
|
|
}
|
|
|
|
|
|
|
|
result = (style & WS_EX_TOPMOST) == WS_EX_TOPMOST;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
void cvSetPropTopmost_W32(const char* name, const bool topmost)
|
|
|
|
{
|
|
|
|
CV_Assert(name);
|
|
|
|
|
|
|
|
CvWindow* window = icvFindWindowByName(name);
|
|
|
|
if (!window)
|
|
|
|
CV_Error(Error::StsNullPtr, "NULL window");
|
|
|
|
|
|
|
|
HWND flag = topmost ? HWND_TOPMOST : HWND_TOP;
|
|
|
|
BOOL success = SetWindowPos(window->frame, flag, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
|
|
|
|
|
|
|
|
if (!success)
|
|
|
|
{
|
|
|
|
std::ostringstream errorMsg;
|
|
|
|
errorMsg << "window(" << name << "): error reported by SetWindowPos(" << (topmost ? "HWND_TOPMOST" : "HWND_TOP") << "), error code: " << GetLastError();
|
|
|
|
CV_Error(Error::StsError, errorMsg.str().c_str());
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-11-18 07:27:02 +08:00
|
|
|
void cv::setWindowTitle(const String& winname, const String& title)
|
|
|
|
{
|
|
|
|
CvWindow* window = icvFindWindowByName(winname.c_str());
|
|
|
|
|
|
|
|
if (!window)
|
|
|
|
{
|
|
|
|
namedWindow(winname);
|
|
|
|
window = icvFindWindowByName(winname.c_str());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!window)
|
|
|
|
CV_Error(Error::StsNullPtr, "NULL window");
|
|
|
|
|
|
|
|
if (!SetWindowText(window->frame, title.c_str()))
|
|
|
|
CV_Error_(Error::StsError, ("Failed to set \"%s\" window title to \"%s\"", winname.c_str(), title.c_str()));
|
|
|
|
}
|
|
|
|
|
2011-11-21 19:58:52 +08:00
|
|
|
double cvGetPropWindowAutoSize_W32(const char* name)
|
|
|
|
{
|
|
|
|
double result = -1;
|
|
|
|
|
|
|
|
CV_FUNCNAME( "cvSetCloseCallback" );
|
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
CvWindow* window;
|
|
|
|
|
|
|
|
if (!name)
|
|
|
|
CV_ERROR( CV_StsNullPtr, "NULL name string" );
|
|
|
|
|
|
|
|
window = icvFindWindowByName( name );
|
|
|
|
if (!window)
|
2011-11-23 18:05:24 +08:00
|
|
|
EXIT; // keep silence here
|
2011-11-21 19:58:52 +08:00
|
|
|
|
|
|
|
result = window->flags & CV_WINDOW_AUTOSIZE;
|
|
|
|
|
|
|
|
__END__;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
double cvGetRatioWindow_W32(const char* name)
|
|
|
|
{
|
2012-06-08 11:15:08 +08:00
|
|
|
double result = -1;
|
|
|
|
|
|
|
|
CV_FUNCNAME( "cvGetRatioWindow_W32" );
|
2011-11-21 19:58:52 +08:00
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
CvWindow* window;
|
|
|
|
|
|
|
|
if (!name)
|
|
|
|
CV_ERROR( CV_StsNullPtr, "NULL name string" );
|
|
|
|
|
|
|
|
window = icvFindWindowByName( name );
|
|
|
|
if (!window)
|
2011-11-23 18:05:24 +08:00
|
|
|
EXIT; // keep silence here
|
2012-06-08 11:15:08 +08:00
|
|
|
|
2011-11-21 19:58:52 +08:00
|
|
|
result = static_cast<double>(window->width) / window->height;
|
2012-06-08 11:15:08 +08:00
|
|
|
|
2011-11-21 19:58:52 +08:00
|
|
|
__END__;
|
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
return result;
|
2011-11-21 19:58:52 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
double cvGetOpenGlProp_W32(const char* name)
|
|
|
|
{
|
2012-06-08 11:15:08 +08:00
|
|
|
double result = -1;
|
2011-11-21 19:58:52 +08:00
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
#ifdef HAVE_OPENGL
|
|
|
|
CV_FUNCNAME( "cvGetOpenGlProp_W32" );
|
2011-11-21 19:58:52 +08:00
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
CvWindow* window;
|
|
|
|
|
|
|
|
if (!name)
|
|
|
|
CV_ERROR( CV_StsNullPtr, "NULL name string" );
|
|
|
|
|
|
|
|
window = icvFindWindowByName( name );
|
|
|
|
if (!window)
|
2011-11-23 18:05:24 +08:00
|
|
|
EXIT; // keep silence here
|
2012-06-08 11:15:08 +08:00
|
|
|
|
2011-11-21 19:58:52 +08:00
|
|
|
result = window->useGl;
|
2012-06-08 11:15:08 +08:00
|
|
|
|
2011-11-21 19:58:52 +08:00
|
|
|
__END__;
|
|
|
|
#endif
|
2018-09-07 19:33:52 +08:00
|
|
|
CV_UNUSED(name);
|
2011-11-21 19:58:52 +08:00
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
return result;
|
2011-11-21 19:58:52 +08:00
|
|
|
}
|
|
|
|
|
2018-11-21 22:04:23 +08:00
|
|
|
double cvGetPropVisible_W32(const char* name)
|
|
|
|
{
|
|
|
|
double result = -1;
|
|
|
|
|
|
|
|
CV_FUNCNAME( "cvGetPropVisible_W32" );
|
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
if (!name)
|
|
|
|
CV_ERROR( CV_StsNullPtr, "NULL name string" );
|
|
|
|
|
|
|
|
result = (icvFindWindowByName( name ) != NULL);
|
|
|
|
|
|
|
|
__END__;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2011-11-21 19:58:52 +08:00
|
|
|
|
|
|
|
// OpenGL support
|
|
|
|
|
|
|
|
#ifdef HAVE_OPENGL
|
|
|
|
|
|
|
|
namespace
|
|
|
|
{
|
|
|
|
void createGlContext(HWND hWnd, HDC& hGLDC, HGLRC& hGLRC, bool& useGl)
|
|
|
|
{
|
|
|
|
CV_FUNCNAME( "createGlContext" );
|
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
useGl = false;
|
|
|
|
|
|
|
|
int PixelFormat;
|
|
|
|
|
|
|
|
static PIXELFORMATDESCRIPTOR pfd =
|
|
|
|
{
|
|
|
|
sizeof(PIXELFORMATDESCRIPTOR), // Size Of This Pixel Format Descriptor
|
|
|
|
1, // Version Number
|
|
|
|
PFD_DRAW_TO_WINDOW | // Format Must Support Window
|
|
|
|
PFD_SUPPORT_OPENGL | // Format Must Support OpenGL
|
|
|
|
PFD_DOUBLEBUFFER, // Must Support Double Buffering
|
|
|
|
PFD_TYPE_RGBA, // Request An RGBA Format
|
|
|
|
32, // Select Our Color Depth
|
|
|
|
0, 0, 0, 0, 0, 0, // Color Bits Ignored
|
|
|
|
0, // No Alpha Buffer
|
|
|
|
0, // Shift Bit Ignored
|
|
|
|
0, // No Accumulation Buffer
|
|
|
|
0, 0, 0, 0, // Accumulation Bits Ignored
|
2012-06-08 11:15:08 +08:00
|
|
|
32, // 32 Bit Z-Buffer (Depth Buffer)
|
2011-11-21 19:58:52 +08:00
|
|
|
0, // No Stencil Buffer
|
|
|
|
0, // No Auxiliary Buffer
|
|
|
|
PFD_MAIN_PLANE, // Main Drawing Layer
|
|
|
|
0, // Reserved
|
2012-06-08 11:15:08 +08:00
|
|
|
0, 0, 0 // Layer Masks Ignored
|
2011-11-21 19:58:52 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
hGLDC = GetDC(hWnd);
|
|
|
|
if (!hGLDC)
|
|
|
|
CV_ERROR( CV_OpenGlApiCallError, "Can't Create A GL Device Context" );
|
|
|
|
|
|
|
|
PixelFormat = ChoosePixelFormat(hGLDC, &pfd);
|
|
|
|
if (!PixelFormat)
|
|
|
|
CV_ERROR( CV_OpenGlApiCallError, "Can't Find A Suitable PixelFormat" );
|
|
|
|
|
|
|
|
if (!SetPixelFormat(hGLDC, PixelFormat, &pfd))
|
|
|
|
CV_ERROR( CV_OpenGlApiCallError, "Can't Set The PixelFormat" );
|
|
|
|
|
|
|
|
hGLRC = wglCreateContext(hGLDC);
|
|
|
|
if (!hGLRC)
|
|
|
|
CV_ERROR( CV_OpenGlApiCallError, "Can't Create A GL Rendering Context" );
|
|
|
|
|
|
|
|
if (!wglMakeCurrent(hGLDC, hGLRC))
|
|
|
|
CV_ERROR( CV_OpenGlApiCallError, "Can't Activate The GL Rendering Context" );
|
|
|
|
|
|
|
|
useGl = true;
|
|
|
|
|
|
|
|
__END__;
|
|
|
|
}
|
|
|
|
|
|
|
|
void releaseGlContext(CvWindow* window)
|
|
|
|
{
|
2012-06-12 22:46:12 +08:00
|
|
|
//CV_FUNCNAME( "releaseGlContext" );
|
2011-11-21 19:58:52 +08:00
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
if (window->hGLRC)
|
|
|
|
{
|
|
|
|
wglDeleteContext(window->hGLRC);
|
|
|
|
window->hGLRC = NULL;
|
|
|
|
}
|
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
if (window->dc)
|
2011-11-21 19:58:52 +08:00
|
|
|
{
|
|
|
|
ReleaseDC(window->hwnd, window->dc);
|
|
|
|
window->dc = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
window->useGl = false;
|
|
|
|
|
|
|
|
__END__;
|
|
|
|
}
|
|
|
|
|
|
|
|
void drawGl(CvWindow* window)
|
|
|
|
{
|
|
|
|
CV_FUNCNAME( "drawGl" );
|
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
if (!wglMakeCurrent(window->dc, window->hGLRC))
|
|
|
|
CV_ERROR( CV_OpenGlApiCallError, "Can't Activate The GL Rendering Context" );
|
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
2011-11-21 19:58:52 +08:00
|
|
|
|
|
|
|
if (window->glDrawCallback)
|
|
|
|
window->glDrawCallback(window->glDrawData);
|
|
|
|
|
|
|
|
if (!SwapBuffers(window->dc))
|
|
|
|
CV_ERROR( CV_OpenGlApiCallError, "Can't swap OpenGL buffers" );
|
|
|
|
|
|
|
|
__END__;
|
|
|
|
}
|
|
|
|
|
|
|
|
void resizeGl(CvWindow* window)
|
|
|
|
{
|
|
|
|
CV_FUNCNAME( "resizeGl" );
|
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
if (!wglMakeCurrent(window->dc, window->hGLRC))
|
|
|
|
CV_ERROR( CV_OpenGlApiCallError, "Can't Activate The GL Rendering Context" );
|
|
|
|
|
|
|
|
glViewport(0, 0, window->width, window->height);
|
|
|
|
|
|
|
|
__END__;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // HAVE_OPENGL
|
|
|
|
|
|
|
|
|
2010-05-12 01:44:00 +08:00
|
|
|
CV_IMPL int cvNamedWindow( const char* name, int flags )
|
|
|
|
{
|
|
|
|
int result = 0;
|
|
|
|
CV_FUNCNAME( "cvNamedWindow" );
|
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
HWND hWnd, mainhWnd;
|
|
|
|
CvWindow* window;
|
|
|
|
DWORD defStyle = WS_VISIBLE | WS_MINIMIZEBOX | WS_MAXIMIZEBOX | WS_SYSMENU;
|
|
|
|
int len;
|
|
|
|
CvRect rect;
|
2012-05-21 02:45:19 +08:00
|
|
|
#ifdef HAVE_OPENGL
|
|
|
|
bool useGl;
|
|
|
|
HDC hGLDC;
|
|
|
|
HGLRC hGLRC;
|
|
|
|
#endif
|
2010-05-12 01:44:00 +08:00
|
|
|
|
|
|
|
cvInitSystem(0,0);
|
|
|
|
|
|
|
|
if( !name )
|
|
|
|
CV_ERROR( CV_StsNullPtr, "NULL name string" );
|
|
|
|
|
|
|
|
// Check the name in the storage
|
2011-11-21 19:58:52 +08:00
|
|
|
window = icvFindWindowByName( name );
|
|
|
|
if (window != 0)
|
2010-05-12 01:44:00 +08:00
|
|
|
{
|
|
|
|
result = 1;
|
|
|
|
EXIT;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( !(flags & CV_WINDOW_AUTOSIZE))//YV add border in order to resize the window
|
|
|
|
defStyle |= WS_SIZEBOX;
|
|
|
|
|
2015-05-10 00:23:09 +08:00
|
|
|
#ifdef HAVE_OPENGL
|
|
|
|
if (flags & CV_WINDOW_OPENGL)
|
|
|
|
defStyle |= WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
|
|
|
|
#endif
|
|
|
|
|
2010-05-12 01:44:00 +08:00
|
|
|
icvLoadWindowPos( name, rect );
|
|
|
|
|
|
|
|
mainhWnd = CreateWindow( "Main HighGUI class", name, defStyle | WS_OVERLAPPED,
|
|
|
|
rect.x, rect.y, rect.width, rect.height, 0, 0, hg_hinstance, 0 );
|
|
|
|
if( !mainhWnd )
|
|
|
|
CV_ERROR( CV_StsError, "Frame window can not be created" );
|
|
|
|
|
|
|
|
ShowWindow(mainhWnd, SW_SHOW);
|
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
//YV- remove one border by changing the style
|
2010-05-12 01:44:00 +08:00
|
|
|
hWnd = CreateWindow("HighGUI class", "", (defStyle & ~WS_SIZEBOX) | WS_CHILD, CW_USEDEFAULT, 0, rect.width, rect.height, mainhWnd, 0, hg_hinstance, 0);
|
|
|
|
if( !hWnd )
|
|
|
|
CV_ERROR( CV_StsError, "Frame window can not be created" );
|
|
|
|
|
2011-11-21 19:58:52 +08:00
|
|
|
#ifndef HAVE_OPENGL
|
|
|
|
if (flags & CV_WINDOW_OPENGL)
|
|
|
|
CV_ERROR( CV_OpenGlNotSupported, "Library was built without OpenGL support" );
|
|
|
|
#else
|
2012-05-21 02:45:19 +08:00
|
|
|
useGl = false;
|
|
|
|
hGLDC = 0;
|
|
|
|
hGLRC = 0;
|
2011-11-21 19:58:52 +08:00
|
|
|
|
|
|
|
if (flags & CV_WINDOW_OPENGL)
|
|
|
|
createGlContext(hWnd, hGLDC, hGLRC, useGl);
|
|
|
|
#endif
|
|
|
|
|
2010-05-12 01:44:00 +08:00
|
|
|
ShowWindow(hWnd, SW_SHOW);
|
|
|
|
|
|
|
|
len = (int)strlen(name);
|
|
|
|
CV_CALL( window = (CvWindow*)cvAlloc(sizeof(CvWindow) + len + 1));
|
|
|
|
|
|
|
|
window->signature = CV_WINDOW_MAGIC_VAL;
|
|
|
|
window->hwnd = hWnd;
|
|
|
|
window->frame = mainhWnd;
|
|
|
|
window->name = (char*)(window + 1);
|
|
|
|
memcpy( window->name, name, len + 1 );
|
|
|
|
window->flags = flags;
|
|
|
|
window->image = 0;
|
2011-11-21 19:58:52 +08:00
|
|
|
|
|
|
|
#ifndef HAVE_OPENGL
|
2010-05-12 01:44:00 +08:00
|
|
|
window->dc = CreateCompatibleDC(0);
|
2011-11-21 19:58:52 +08:00
|
|
|
#else
|
|
|
|
if (!useGl)
|
|
|
|
{
|
|
|
|
window->dc = CreateCompatibleDC(0);
|
|
|
|
window->hGLRC = 0;
|
|
|
|
window->useGl = false;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
window->dc = hGLDC;
|
|
|
|
window->hGLRC = hGLRC;
|
|
|
|
window->useGl = true;
|
|
|
|
}
|
|
|
|
|
|
|
|
window->glDrawCallback = 0;
|
|
|
|
window->glDrawData = 0;
|
|
|
|
#endif
|
|
|
|
|
2010-05-12 01:44:00 +08:00
|
|
|
window->last_key = 0;
|
|
|
|
window->status = CV_WINDOW_NORMAL;//YV
|
|
|
|
|
|
|
|
window->on_mouse = 0;
|
|
|
|
window->on_mouse_param = 0;
|
|
|
|
|
|
|
|
memset( &window->toolbar, 0, sizeof(window->toolbar));
|
|
|
|
|
|
|
|
window->next = hg_windows;
|
|
|
|
window->prev = 0;
|
|
|
|
if( hg_windows )
|
|
|
|
hg_windows->prev = window;
|
|
|
|
hg_windows = window;
|
|
|
|
icvSetWindowLongPtr( hWnd, CV_USERDATA, window );
|
|
|
|
icvSetWindowLongPtr( mainhWnd, CV_USERDATA, window );
|
|
|
|
|
2012-05-17 00:13:24 +08:00
|
|
|
// Recalculate window pos
|
2010-05-12 01:44:00 +08:00
|
|
|
icvUpdateWindowPos( window );
|
|
|
|
|
|
|
|
result = 1;
|
|
|
|
__END__;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2011-11-21 19:58:52 +08:00
|
|
|
#ifdef HAVE_OPENGL
|
|
|
|
|
|
|
|
CV_IMPL void cvSetOpenGlContext(const char* name)
|
|
|
|
{
|
|
|
|
CV_FUNCNAME( "cvSetOpenGlContext" );
|
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
CvWindow* window;
|
|
|
|
|
|
|
|
if(!name)
|
|
|
|
CV_ERROR( CV_StsNullPtr, "NULL name string" );
|
|
|
|
|
|
|
|
window = icvFindWindowByName( name );
|
|
|
|
if (!window)
|
|
|
|
CV_ERROR( CV_StsNullPtr, "NULL window" );
|
|
|
|
|
|
|
|
if (!window->useGl)
|
|
|
|
CV_ERROR( CV_OpenGlNotSupported, "Window doesn't support OpenGL" );
|
|
|
|
|
|
|
|
if (!wglMakeCurrent(window->dc, window->hGLRC))
|
|
|
|
CV_ERROR( CV_OpenGlApiCallError, "Can't Activate The GL Rendering Context" );
|
|
|
|
|
2011-11-28 19:50:46 +08:00
|
|
|
__END__;
|
|
|
|
}
|
|
|
|
|
2011-11-21 19:58:52 +08:00
|
|
|
CV_IMPL void cvUpdateWindow(const char* name)
|
|
|
|
{
|
|
|
|
CV_FUNCNAME( "cvUpdateWindow" );
|
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
CvWindow* window;
|
|
|
|
|
|
|
|
if (!name)
|
|
|
|
CV_ERROR( CV_StsNullPtr, "NULL name string" );
|
|
|
|
|
|
|
|
window = icvFindWindowByName( name );
|
|
|
|
if (!window)
|
|
|
|
EXIT;
|
|
|
|
|
|
|
|
InvalidateRect(window->hwnd, 0, 0);
|
|
|
|
|
|
|
|
__END__;
|
|
|
|
}
|
|
|
|
|
2011-12-12 20:52:06 +08:00
|
|
|
CV_IMPL void cvSetOpenGlDrawCallback(const char* name, CvOpenGlDrawCallback callback, void* userdata)
|
2011-11-21 19:58:52 +08:00
|
|
|
{
|
|
|
|
CV_FUNCNAME( "cvCreateOpenGLCallback" );
|
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
CvWindow* window;
|
|
|
|
|
|
|
|
if(!name)
|
|
|
|
CV_ERROR( CV_StsNullPtr, "NULL name string" );
|
|
|
|
|
|
|
|
window = icvFindWindowByName( name );
|
|
|
|
if( !window )
|
|
|
|
EXIT;
|
|
|
|
|
|
|
|
if (!window->useGl)
|
|
|
|
CV_ERROR( CV_OpenGlNotSupported, "Window was created without OpenGL context" );
|
|
|
|
|
|
|
|
window->glDrawCallback = callback;
|
|
|
|
window->glDrawData = userdata;
|
|
|
|
|
|
|
|
__END__;
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif // HAVE_OPENGL
|
2010-05-12 01:44:00 +08:00
|
|
|
|
|
|
|
static void icvRemoveWindow( CvWindow* window )
|
|
|
|
{
|
|
|
|
CvTrackbar* trackbar = NULL;
|
|
|
|
RECT wrect={0,0,0,0};
|
|
|
|
|
2011-11-21 19:58:52 +08:00
|
|
|
#ifdef HAVE_OPENGL
|
|
|
|
if (window->useGl)
|
|
|
|
releaseGlContext(window);
|
|
|
|
#endif
|
|
|
|
|
2010-05-12 01:44:00 +08:00
|
|
|
if( window->frame )
|
|
|
|
GetWindowRect( window->frame, &wrect );
|
|
|
|
if( window->name )
|
|
|
|
icvSaveWindowPos( window->name, cvRect(wrect.left, wrect.top,
|
|
|
|
wrect.right-wrect.left, wrect.bottom-wrect.top) );
|
|
|
|
|
|
|
|
if( window->hwnd )
|
|
|
|
icvSetWindowLongPtr( window->hwnd, CV_USERDATA, 0 );
|
|
|
|
if( window->frame )
|
2011-11-21 19:58:52 +08:00
|
|
|
icvSetWindowLongPtr( window->frame, CV_USERDATA, 0 );
|
2010-05-12 01:44:00 +08:00
|
|
|
|
|
|
|
if( window->toolbar.toolbar )
|
|
|
|
icvSetWindowLongPtr(window->toolbar.toolbar, CV_USERDATA, 0);
|
|
|
|
|
|
|
|
if( window->prev )
|
|
|
|
window->prev->next = window->next;
|
|
|
|
else
|
|
|
|
hg_windows = window->next;
|
|
|
|
|
|
|
|
if( window->next )
|
|
|
|
window->next->prev = window->prev;
|
|
|
|
|
|
|
|
window->prev = window->next = 0;
|
|
|
|
|
|
|
|
if( window->dc && window->image )
|
|
|
|
DeleteObject(SelectObject(window->dc,window->image));
|
|
|
|
|
|
|
|
if( window->dc )
|
|
|
|
DeleteDC(window->dc);
|
|
|
|
|
|
|
|
for( trackbar = window->toolbar.first; trackbar != 0; )
|
|
|
|
{
|
|
|
|
CvTrackbar* next = trackbar->next;
|
|
|
|
if( trackbar->hwnd )
|
|
|
|
{
|
|
|
|
icvSetWindowLongPtr( trackbar->hwnd, CV_USERDATA, 0 );
|
|
|
|
cvFree( &trackbar );
|
|
|
|
}
|
|
|
|
trackbar = next;
|
|
|
|
}
|
|
|
|
|
|
|
|
cvFree( &window );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
CV_IMPL void cvDestroyWindow( const char* name )
|
|
|
|
{
|
|
|
|
CV_FUNCNAME( "cvDestroyWindow" );
|
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
CvWindow* window;
|
|
|
|
HWND mainhWnd;
|
|
|
|
|
|
|
|
if(!name)
|
|
|
|
CV_ERROR( CV_StsNullPtr, "NULL name string" );
|
|
|
|
|
|
|
|
window = icvFindWindowByName( name );
|
|
|
|
if( !window )
|
|
|
|
EXIT;
|
|
|
|
|
|
|
|
mainhWnd = window->frame;
|
|
|
|
|
|
|
|
SendMessage(window->hwnd, WM_CLOSE, 0, 0);
|
|
|
|
SendMessage( mainhWnd, WM_CLOSE, 0, 0);
|
|
|
|
// Do NOT call _remove_window -- CvWindow list will be updated automatically ...
|
|
|
|
|
|
|
|
__END__;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void icvScreenToClient( HWND hwnd, RECT* rect )
|
|
|
|
{
|
|
|
|
POINT p;
|
|
|
|
p.x = rect->left;
|
|
|
|
p.y = rect->top;
|
|
|
|
ScreenToClient(hwnd, &p);
|
|
|
|
OffsetRect( rect, p.x - rect->left, p.y - rect->top );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* Calculatess the window coordinates relative to the upper left corner of the mainhWnd window */
|
|
|
|
static RECT icvCalcWindowRect( CvWindow* window )
|
|
|
|
{
|
|
|
|
const int gutter = 1;
|
2020-09-02 06:18:20 +08:00
|
|
|
RECT crect = { 0 }, trect = { 0 } , rect = { 0 };
|
2010-05-12 01:44:00 +08:00
|
|
|
|
|
|
|
assert(window);
|
|
|
|
|
|
|
|
GetClientRect(window->frame, &crect);
|
|
|
|
if(window->toolbar.toolbar)
|
|
|
|
{
|
|
|
|
GetWindowRect(window->toolbar.toolbar, &trect);
|
|
|
|
icvScreenToClient(window->frame, &trect);
|
|
|
|
SubtractRect( &rect, &crect, &trect);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
rect = crect;
|
|
|
|
|
|
|
|
rect.top += gutter;
|
|
|
|
rect.left += gutter;
|
|
|
|
rect.bottom -= gutter;
|
|
|
|
rect.right -= gutter;
|
|
|
|
|
|
|
|
return rect;
|
|
|
|
}
|
|
|
|
|
|
|
|
// returns TRUE if there is a problem such as ERROR_IO_PENDING.
|
|
|
|
static bool icvGetBitmapData( CvWindow* window, SIZE* size, int* channels, void** data )
|
|
|
|
{
|
|
|
|
BITMAP bmp;
|
|
|
|
GdiFlush();
|
|
|
|
HGDIOBJ h = GetCurrentObject( window->dc, OBJ_BITMAP );
|
|
|
|
if( size )
|
|
|
|
size->cx = size->cy = 0;
|
|
|
|
if( data )
|
|
|
|
*data = 0;
|
|
|
|
|
|
|
|
if (h == NULL)
|
|
|
|
return true;
|
|
|
|
if (GetObject(h, sizeof(bmp), &bmp) == 0)
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if( size )
|
|
|
|
{
|
|
|
|
size->cx = abs(bmp.bmWidth);
|
|
|
|
size->cy = abs(bmp.bmHeight);
|
|
|
|
}
|
|
|
|
|
|
|
|
if( channels )
|
|
|
|
*channels = bmp.bmBitsPixel/8;
|
|
|
|
|
|
|
|
if( data )
|
|
|
|
*data = bmp.bmBits;
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void icvUpdateWindowPos( CvWindow* window )
|
|
|
|
{
|
2020-09-02 06:18:20 +08:00
|
|
|
RECT rect = { 0 };
|
2010-05-12 01:44:00 +08:00
|
|
|
assert(window);
|
|
|
|
|
|
|
|
if( (window->flags & CV_WINDOW_AUTOSIZE) && window->image )
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
SIZE size = {0,0};
|
|
|
|
icvGetBitmapData( window, &size, 0, 0 );
|
|
|
|
|
|
|
|
// Repeat two times because after the first resizing of the mainhWnd window
|
|
|
|
// toolbar may resize too
|
|
|
|
for(i = 0; i < (window->toolbar.toolbar ? 2 : 1); i++)
|
|
|
|
{
|
2020-09-02 06:18:20 +08:00
|
|
|
RECT rmw = { 0 }, rw = icvCalcWindowRect(window );
|
2010-05-12 01:44:00 +08:00
|
|
|
MoveWindow(window->hwnd, rw.left, rw.top,
|
2018-12-16 10:53:42 +08:00
|
|
|
rw.right - rw.left, rw.bottom - rw.top, FALSE);
|
2010-05-12 01:44:00 +08:00
|
|
|
GetClientRect(window->hwnd, &rw);
|
|
|
|
GetWindowRect(window->frame, &rmw);
|
|
|
|
// Resize the mainhWnd window in order to make the bitmap fit into the child window
|
|
|
|
MoveWindow(window->frame, rmw.left, rmw.top,
|
2018-12-16 10:53:42 +08:00
|
|
|
size.cx + (rmw.right - rmw.left) - (rw.right - rw.left),
|
|
|
|
size.cy + (rmw.bottom - rmw.top) - (rw.bottom - rw.top), TRUE );
|
2010-05-12 01:44:00 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
rect = icvCalcWindowRect(window);
|
|
|
|
MoveWindow(window->hwnd, rect.left, rect.top,
|
2018-12-16 10:53:42 +08:00
|
|
|
rect.right - rect.left,
|
|
|
|
rect.bottom - rect.top, TRUE );
|
2010-05-12 01:44:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
CV_IMPL void
|
|
|
|
cvShowImage( const char* name, const CvArr* arr )
|
|
|
|
{
|
|
|
|
CV_FUNCNAME( "cvShowImage" );
|
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
CvWindow* window;
|
|
|
|
SIZE size = { 0, 0 };
|
|
|
|
int channels = 0;
|
|
|
|
void* dst_ptr = 0;
|
|
|
|
const int channels0 = 3;
|
|
|
|
int origin = 0;
|
|
|
|
CvMat stub, dst, *image;
|
|
|
|
bool changed_size = false; // philipg
|
|
|
|
|
|
|
|
if( !name )
|
|
|
|
CV_ERROR( CV_StsNullPtr, "NULL name" );
|
|
|
|
|
|
|
|
window = icvFindWindowByName(name);
|
2012-06-08 11:15:08 +08:00
|
|
|
if(!window)
|
|
|
|
{
|
2013-10-18 00:54:43 +08:00
|
|
|
cvNamedWindow(name, CV_WINDOW_AUTOSIZE);
|
2012-06-08 11:15:08 +08:00
|
|
|
window = icvFindWindowByName(name);
|
|
|
|
}
|
2010-05-12 01:44:00 +08:00
|
|
|
|
|
|
|
if( !window || !arr )
|
|
|
|
EXIT; // keep silence here.
|
|
|
|
|
|
|
|
if( CV_IS_IMAGE_HDR( arr ))
|
|
|
|
origin = ((IplImage*)arr)->origin;
|
|
|
|
|
|
|
|
CV_CALL( image = cvGetMat( arr, &stub ));
|
|
|
|
|
2011-11-21 19:58:52 +08:00
|
|
|
#ifdef HAVE_OPENGL
|
|
|
|
if (window->useGl)
|
|
|
|
{
|
2013-03-31 17:26:21 +08:00
|
|
|
cv::imshow(name, cv::cvarrToMat(image));
|
2011-11-21 19:58:52 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2010-05-12 01:44:00 +08:00
|
|
|
if (window->image)
|
|
|
|
// if there is something wrong with these system calls, we cannot display image...
|
|
|
|
if (icvGetBitmapData( window, &size, &channels, &dst_ptr ))
|
|
|
|
return;
|
|
|
|
|
|
|
|
if( size.cx != image->width || size.cy != image->height || channels != channels0 )
|
|
|
|
{
|
|
|
|
changed_size = true;
|
|
|
|
|
|
|
|
uchar buffer[sizeof(BITMAPINFO) + 255*sizeof(RGBQUAD)];
|
|
|
|
BITMAPINFO* binfo = (BITMAPINFO*)buffer;
|
|
|
|
|
|
|
|
DeleteObject( SelectObject( window->dc, window->image ));
|
|
|
|
window->image = 0;
|
|
|
|
|
|
|
|
size.cx = image->width;
|
|
|
|
size.cy = image->height;
|
|
|
|
channels = channels0;
|
|
|
|
|
|
|
|
FillBitmapInfo( binfo, size.cx, size.cy, channels*8, 1 );
|
|
|
|
|
|
|
|
window->image = SelectObject( window->dc, CreateDIBSection(window->dc, binfo,
|
|
|
|
DIB_RGB_COLORS, &dst_ptr, 0, 0));
|
|
|
|
}
|
|
|
|
|
|
|
|
cvInitMatHeader( &dst, size.cy, size.cx, CV_8UC3,
|
|
|
|
dst_ptr, (size.cx * channels + 3) & -4 );
|
|
|
|
cvConvertImage( image, &dst, origin == 0 ? CV_CVTIMG_FLIP : 0 );
|
|
|
|
|
Fix modules/ typos
Found using `codespell -q 3 -S ./3rdparty -L activ,amin,ang,atleast,childs,dof,endwhile,halfs,hist,iff,nd,od,uint`
backporting of commit: ec43292e1ea9da963e67427505b4113750829c3e
2019-08-16 06:02:09 +08:00
|
|
|
// only resize window if needed
|
2010-05-12 01:44:00 +08:00
|
|
|
if (changed_size)
|
|
|
|
icvUpdateWindowPos(window);
|
|
|
|
InvalidateRect(window->hwnd, 0, 0);
|
|
|
|
// philipg: this is not needed and just slows things down
|
2014-11-30 05:43:21 +08:00
|
|
|
// UpdateWindow(window->hwnd);
|
2010-05-12 01:44:00 +08:00
|
|
|
|
|
|
|
__END__;
|
|
|
|
}
|
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
#if 0
|
2012-02-22 21:30:47 +08:00
|
|
|
CV_IMPL void
|
|
|
|
cvShowImageHWND(HWND w_hWnd, const CvArr* arr)
|
|
|
|
{
|
|
|
|
CV_FUNCNAME( "cvShowImageHWND" );
|
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
SIZE size = { 0, 0 };
|
|
|
|
int channels = 0;
|
|
|
|
void* dst_ptr = 0;
|
|
|
|
const int channels0 = 3;
|
|
|
|
int origin = 0;
|
|
|
|
CvMat stub, dst, *image;
|
|
|
|
bool changed_size = false;
|
|
|
|
BITMAPINFO tempbinfo;
|
|
|
|
HDC hdc = NULL;
|
|
|
|
|
|
|
|
if( !arr )
|
|
|
|
EXIT;
|
|
|
|
if( !w_hWnd )
|
|
|
|
EXIT;
|
|
|
|
|
|
|
|
hdc = GetDC(w_hWnd);
|
|
|
|
|
|
|
|
if( CV_IS_IMAGE_HDR( arr ) )
|
|
|
|
origin = ((IplImage*)arr)->origin;
|
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
CV_CALL( image = cvGetMat( arr, &stub ) );
|
2012-02-22 21:30:47 +08:00
|
|
|
|
|
|
|
if ( hdc )
|
|
|
|
{
|
|
|
|
//GetBitmapData
|
|
|
|
BITMAP bmp;
|
|
|
|
GdiFlush();
|
|
|
|
HGDIOBJ h = GetCurrentObject( hdc, OBJ_BITMAP );
|
|
|
|
|
|
|
|
if (h == NULL)
|
|
|
|
EXIT;
|
|
|
|
if (GetObject(h, sizeof(bmp), &bmp) == 0) //GetObject(): returns size of object, 0 if error
|
|
|
|
EXIT;
|
|
|
|
|
|
|
|
channels = bmp.bmBitsPixel/8;
|
|
|
|
dst_ptr = bmp.bmBits;
|
|
|
|
}
|
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
if( size.cx != image->width || size.cy != image->height || channels != channels0 )
|
2012-02-22 21:30:47 +08:00
|
|
|
{
|
|
|
|
changed_size = true;
|
|
|
|
|
|
|
|
uchar buffer[sizeof(BITMAPINFO) + 255*sizeof(RGBQUAD)];
|
|
|
|
BITMAPINFO* binfo = (BITMAPINFO*)buffer;
|
|
|
|
|
|
|
|
BOOL bDeleteObj = DeleteObject(GetCurrentObject(hdc, OBJ_BITMAP));
|
|
|
|
CV_Assert( FALSE != bDeleteObj );
|
|
|
|
|
|
|
|
size.cx = image->width;
|
|
|
|
size.cy = image->height;
|
|
|
|
channels = channels0;
|
|
|
|
|
|
|
|
FillBitmapInfo( binfo, size.cx, size.cy, channels*8, 1 );
|
|
|
|
|
2012-02-28 20:39:25 +08:00
|
|
|
SelectObject( hdc, CreateDIBSection( hdc, binfo, DIB_RGB_COLORS, &dst_ptr, 0, 0));
|
2012-02-22 21:30:47 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
cvInitMatHeader( &dst, size.cy, size.cx, CV_8UC3, dst_ptr, (size.cx * channels + 3) & -4 );
|
|
|
|
cvConvertImage( image, &dst, origin == 0 ? CV_CVTIMG_FLIP : 0 );
|
|
|
|
|
|
|
|
// Image stretching to fit the window
|
|
|
|
RECT rect;
|
|
|
|
GetClientRect(w_hWnd, &rect);
|
2012-02-28 20:39:25 +08:00
|
|
|
StretchDIBits( hdc, 0, 0, rect.right, rect.bottom, 0, 0, image->width, image->height, dst_ptr, &tempbinfo, DIB_RGB_COLORS, SRCCOPY );
|
2012-02-22 21:30:47 +08:00
|
|
|
|
|
|
|
// ony resize window if needed
|
|
|
|
InvalidateRect(w_hWnd, 0, 0);
|
|
|
|
|
|
|
|
__END__;
|
|
|
|
}
|
2012-06-08 11:15:08 +08:00
|
|
|
#endif
|
2010-05-12 01:44:00 +08:00
|
|
|
|
|
|
|
CV_IMPL void cvResizeWindow(const char* name, int width, int height )
|
|
|
|
{
|
|
|
|
CV_FUNCNAME( "cvResizeWindow" );
|
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
int i;
|
|
|
|
CvWindow* window;
|
2020-09-02 06:18:20 +08:00
|
|
|
RECT rmw = { 0 }, rw = { 0 }, rect = { 0 };
|
2010-05-12 01:44:00 +08:00
|
|
|
|
|
|
|
if( !name )
|
|
|
|
CV_ERROR( CV_StsNullPtr, "NULL name" );
|
|
|
|
|
|
|
|
window = icvFindWindowByName(name);
|
|
|
|
if(!window)
|
|
|
|
EXIT;
|
|
|
|
|
|
|
|
// Repeat two times because after the first resizing of the mainhWnd window
|
|
|
|
// toolbar may resize too
|
|
|
|
for(i = 0; i < (window->toolbar.toolbar ? 2 : 1); i++)
|
|
|
|
{
|
|
|
|
rw = icvCalcWindowRect(window);
|
|
|
|
MoveWindow(window->hwnd, rw.left, rw.top,
|
2018-12-16 10:53:42 +08:00
|
|
|
rw.right - rw.left, rw.bottom - rw.top, FALSE);
|
2010-05-12 01:44:00 +08:00
|
|
|
GetClientRect(window->hwnd, &rw);
|
|
|
|
GetWindowRect(window->frame, &rmw);
|
|
|
|
// Resize the mainhWnd window in order to make the bitmap fit into the child window
|
|
|
|
MoveWindow(window->frame, rmw.left, rmw.top,
|
2018-12-16 10:53:42 +08:00
|
|
|
width + (rmw.right - rmw.left) - (rw.right - rw.left),
|
|
|
|
height + (rmw.bottom - rmw.top) - (rw.bottom - rw.top), TRUE);
|
2010-05-12 01:44:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
rect = icvCalcWindowRect(window);
|
|
|
|
MoveWindow(window->hwnd, rect.left, rect.top,
|
2018-12-16 10:53:42 +08:00
|
|
|
rect.right - rect.left, rect.bottom - rect.top, TRUE);
|
2010-05-12 01:44:00 +08:00
|
|
|
|
|
|
|
__END__;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
CV_IMPL void cvMoveWindow( const char* name, int x, int y )
|
|
|
|
{
|
|
|
|
CV_FUNCNAME( "cvMoveWindow" );
|
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
CvWindow* window;
|
2020-09-02 06:18:20 +08:00
|
|
|
RECT rect = { 0 };
|
2010-05-12 01:44:00 +08:00
|
|
|
|
|
|
|
if( !name )
|
|
|
|
CV_ERROR( CV_StsNullPtr, "NULL name" );
|
|
|
|
|
|
|
|
window = icvFindWindowByName(name);
|
|
|
|
if(!window)
|
|
|
|
EXIT;
|
|
|
|
|
|
|
|
GetWindowRect( window->frame, &rect );
|
|
|
|
MoveWindow( window->frame, x, y, rect.right - rect.left, rect.bottom - rect.top, TRUE);
|
|
|
|
|
|
|
|
__END__;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static LRESULT CALLBACK
|
|
|
|
MainWindowProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
|
|
|
|
{
|
|
|
|
CvWindow* window = icvWindowByHWND( hwnd );
|
|
|
|
if( !window )
|
|
|
|
return DefWindowProc(hwnd, uMsg, wParam, lParam);
|
|
|
|
|
|
|
|
switch(uMsg)
|
|
|
|
{
|
2014-01-21 03:44:27 +08:00
|
|
|
case WM_COPY:
|
2014-11-30 05:43:21 +08:00
|
|
|
::SendMessage(window->hwnd, uMsg, wParam, lParam);
|
2014-01-27 16:14:49 +08:00
|
|
|
break;
|
2014-01-21 03:44:27 +08:00
|
|
|
|
2010-05-12 01:44:00 +08:00
|
|
|
case WM_DESTROY:
|
|
|
|
|
|
|
|
icvRemoveWindow(window);
|
|
|
|
// Do nothing!!!
|
|
|
|
//PostQuitMessage(0);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WM_GETMINMAXINFO:
|
|
|
|
if( !(window->flags & CV_WINDOW_AUTOSIZE) )
|
|
|
|
{
|
|
|
|
MINMAXINFO* minmax = (MINMAXINFO*)lParam;
|
2020-09-02 06:18:20 +08:00
|
|
|
RECT rect = { 0 };
|
2010-05-12 01:44:00 +08:00
|
|
|
LRESULT retval = DefWindowProc(hwnd, uMsg, wParam, lParam);
|
|
|
|
|
|
|
|
minmax->ptMinTrackSize.y = 100;
|
|
|
|
minmax->ptMinTrackSize.x = 100;
|
|
|
|
|
|
|
|
if( window->toolbar.first )
|
|
|
|
{
|
|
|
|
GetWindowRect( window->toolbar.first->hwnd, &rect );
|
|
|
|
minmax->ptMinTrackSize.y += window->toolbar.rows*(rect.bottom - rect.top);
|
|
|
|
minmax->ptMinTrackSize.x = MAX(rect.right - rect.left + HG_BUDDY_WIDTH, HG_BUDDY_WIDTH*2);
|
|
|
|
}
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WM_WINDOWPOSCHANGED:
|
|
|
|
{
|
|
|
|
WINDOWPOS* pos = (WINDOWPOS*)lParam;
|
|
|
|
|
2012-05-17 00:13:24 +08:00
|
|
|
// Update the toolbar pos/size
|
2010-05-12 01:44:00 +08:00
|
|
|
if(window->toolbar.toolbar)
|
|
|
|
{
|
2020-09-02 06:18:20 +08:00
|
|
|
RECT rect = { 0 };
|
2010-05-12 01:44:00 +08:00
|
|
|
GetWindowRect(window->toolbar.toolbar, &rect);
|
|
|
|
MoveWindow(window->toolbar.toolbar, 0, 0, pos->cx, rect.bottom - rect.top, TRUE);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!(window->flags & CV_WINDOW_AUTOSIZE))
|
|
|
|
icvUpdateWindowPos(window);
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2012-05-17 00:13:24 +08:00
|
|
|
case WM_WINDOWPOSCHANGING:
|
|
|
|
{
|
|
|
|
// Snap window to screen edges with multi-monitor support. // Adi Shavit
|
|
|
|
LPWINDOWPOS pos = (LPWINDOWPOS)lParam;
|
2012-06-08 11:15:08 +08:00
|
|
|
|
2020-09-02 06:18:20 +08:00
|
|
|
RECT rect = { 0 };
|
2012-05-17 00:13:24 +08:00
|
|
|
GetWindowRect(window->frame, &rect);
|
|
|
|
|
|
|
|
HMONITOR hMonitor;
|
|
|
|
hMonitor = MonitorFromRect(&rect, MONITOR_DEFAULTTONEAREST);
|
|
|
|
|
|
|
|
MONITORINFO mi;
|
|
|
|
mi.cbSize = sizeof(mi);
|
|
|
|
GetMonitorInfo(hMonitor, &mi);
|
|
|
|
|
|
|
|
const int SNAP_DISTANCE = 15;
|
|
|
|
|
2012-06-08 11:15:08 +08:00
|
|
|
if (abs(pos->x - mi.rcMonitor.left) <= SNAP_DISTANCE)
|
2012-05-17 00:13:24 +08:00
|
|
|
pos->x = mi.rcMonitor.left; // snap to left edge
|
2012-06-08 11:15:08 +08:00
|
|
|
else
|
2012-05-17 00:13:24 +08:00
|
|
|
if (abs(pos->x + pos->cx - mi.rcMonitor.right) <= SNAP_DISTANCE)
|
|
|
|
pos->x = mi.rcMonitor.right - pos->cx; // snap to right edge
|
|
|
|
|
|
|
|
if (abs(pos->y - mi.rcMonitor.top) <= SNAP_DISTANCE)
|
|
|
|
pos->y = mi.rcMonitor.top; // snap to top edge
|
2012-06-08 11:15:08 +08:00
|
|
|
else
|
2012-05-17 00:13:24 +08:00
|
|
|
if (abs(pos->y + pos->cy - mi.rcMonitor.bottom) <= SNAP_DISTANCE)
|
|
|
|
pos->y = mi.rcMonitor.bottom - pos->cy; // snap to bottom edge
|
|
|
|
}
|
|
|
|
|
2010-05-12 01:44:00 +08:00
|
|
|
case WM_ACTIVATE:
|
|
|
|
if(LOWORD(wParam) == WA_ACTIVE || LOWORD(wParam) == WA_CLICKACTIVE)
|
|
|
|
SetFocus(window->hwnd);
|
|
|
|
break;
|
|
|
|
|
2014-01-08 03:17:57 +08:00
|
|
|
case WM_MOUSEWHEEL:
|
|
|
|
case WM_MOUSEHWHEEL:
|
|
|
|
if( window->on_mouse )
|
|
|
|
{
|
|
|
|
int flags = (wParam & MK_LBUTTON ? CV_EVENT_FLAG_LBUTTON : 0)|
|
|
|
|
(wParam & MK_RBUTTON ? CV_EVENT_FLAG_RBUTTON : 0)|
|
|
|
|
(wParam & MK_MBUTTON ? CV_EVENT_FLAG_MBUTTON : 0)|
|
|
|
|
(wParam & MK_CONTROL ? CV_EVENT_FLAG_CTRLKEY : 0)|
|
|
|
|
(wParam & MK_SHIFT ? CV_EVENT_FLAG_SHIFTKEY : 0)|
|
|
|
|
(GetKeyState(VK_MENU) < 0 ? CV_EVENT_FLAG_ALTKEY : 0);
|
|
|
|
int event = (uMsg == WM_MOUSEWHEEL ? CV_EVENT_MOUSEWHEEL : CV_EVENT_MOUSEHWHEEL);
|
|
|
|
|
|
|
|
// Set the wheel delta of mouse wheel to be in the upper word of 'event'
|
|
|
|
int delta = GET_WHEEL_DELTA_WPARAM(wParam);
|
2014-01-12 15:33:08 +08:00
|
|
|
flags |= (delta << 16);
|
2014-01-08 03:17:57 +08:00
|
|
|
|
|
|
|
POINT pt;
|
2014-01-16 17:09:25 +08:00
|
|
|
pt.x = GET_X_LPARAM( lParam );
|
|
|
|
pt.y = GET_Y_LPARAM( lParam );
|
|
|
|
::ScreenToClient(hwnd, &pt); // Convert screen coordinates to client coordinates.
|
2014-01-08 03:17:57 +08:00
|
|
|
|
2020-09-02 06:18:20 +08:00
|
|
|
RECT rect = { 0 };
|
2014-01-08 03:17:57 +08:00
|
|
|
GetClientRect( window->hwnd, &rect );
|
|
|
|
|
|
|
|
SIZE size = {0,0};
|
2018-12-16 12:50:32 +08:00
|
|
|
#ifdef HAVE_OPENGL
|
|
|
|
if (window->useGl)
|
|
|
|
{
|
|
|
|
cv::ogl::Texture2D* texObj = static_cast<cv::ogl::Texture2D*>(window->glDrawData);
|
|
|
|
size.cx = texObj->cols();
|
|
|
|
size.cy = texObj->rows();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
icvGetBitmapData(window, &size, 0, 0);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
icvGetBitmapData(window, &size, 0, 0);
|
|
|
|
#endif
|
2014-01-08 03:17:57 +08:00
|
|
|
|
|
|
|
window->on_mouse( event, pt.x*size.cx/MAX(rect.right - rect.left,1),
|
|
|
|
pt.y*size.cy/MAX(rect.bottom - rect.top,1), flags,
|
|
|
|
window->on_mouse_param );
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2010-05-12 01:44:00 +08:00
|
|
|
case WM_ERASEBKGND:
|
|
|
|
{
|
2020-09-02 06:18:20 +08:00
|
|
|
RECT cr = { 0 }, tr = { 0 }, wrc = { 0 };
|
2010-05-12 01:44:00 +08:00
|
|
|
HRGN rgn, rgn1, rgn2;
|
|
|
|
int ret;
|
|
|
|
HDC hdc = (HDC)wParam;
|
|
|
|
GetWindowRect(window->hwnd, &cr);
|
|
|
|
icvScreenToClient(window->frame, &cr);
|
|
|
|
if(window->toolbar.toolbar)
|
|
|
|
{
|
|
|
|
GetWindowRect(window->toolbar.toolbar, &tr);
|
|
|
|
icvScreenToClient(window->frame, &tr);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
tr.left = tr.top = tr.right = tr.bottom = 0;
|
|
|
|
|
|
|
|
GetClientRect(window->frame, &wrc);
|
|
|
|
|
|
|
|
rgn = CreateRectRgn(0, 0, wrc.right, wrc.bottom);
|
|
|
|
rgn1 = CreateRectRgn(cr.left, cr.top, cr.right, cr.bottom);
|
|
|
|
rgn2 = CreateRectRgn(tr.left, tr.top, tr.right, tr.bottom);
|
2018-08-15 19:55:47 +08:00
|
|
|
CV_Assert_N(rgn != 0, rgn1 != 0, rgn2 != 0);
|
2018-07-27 23:25:55 +08:00
|
|
|
|
2010-05-12 01:44:00 +08:00
|
|
|
ret = CombineRgn(rgn, rgn, rgn1, RGN_DIFF);
|
|
|
|
ret = CombineRgn(rgn, rgn, rgn2, RGN_DIFF);
|
|
|
|
|
|
|
|
if(ret != NULLREGION && ret != ERROR)
|
|
|
|
FillRgn(hdc, rgn, (HBRUSH)icvGetClassLongPtr(hwnd, CV_HBRBACKGROUND));
|
|
|
|
|
|
|
|
DeleteObject(rgn);
|
|
|
|
DeleteObject(rgn1);
|
|
|
|
DeleteObject(rgn2);
|
|
|
|
}
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return DefWindowProc(hwnd, uMsg, wParam, lParam);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static LRESULT CALLBACK HighGUIProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
|
|
|
|
{
|
|
|
|
CvWindow* window = icvWindowByHWND(hwnd);
|
|
|
|
if( !window )
|
|
|
|
// This window is not mentioned in HighGUI storage
|
|
|
|
// Actually, this should be error except for the case of calls to CreateWindow
|
|
|
|
return DefWindowProc(hwnd, uMsg, wParam, lParam);
|
|
|
|
|
|
|
|
// Process the message
|
|
|
|
switch(uMsg)
|
|
|
|
{
|
2014-01-21 03:44:27 +08:00
|
|
|
case WM_COPY:
|
|
|
|
{
|
|
|
|
if (!::OpenClipboard(hwnd) )
|
|
|
|
break;
|
|
|
|
|
|
|
|
HDC hDC = 0;
|
|
|
|
HDC memDC = 0;
|
|
|
|
HBITMAP memBM = 0;
|
|
|
|
|
|
|
|
// We'll use a do-while(0){} scope as a single-run breakable scope
|
|
|
|
// Upon any error we can jump out of the single-time while scope to clean up the resources.
|
|
|
|
do
|
|
|
|
{
|
2014-01-27 16:14:49 +08:00
|
|
|
if (!::EmptyClipboard())
|
|
|
|
break;
|
|
|
|
|
|
|
|
if(!window->image)
|
|
|
|
break;
|
|
|
|
|
|
|
|
// Get window device context
|
|
|
|
if (0 == (hDC = ::GetDC(hwnd)))
|
|
|
|
break;
|
|
|
|
|
|
|
|
// Create another DC compatible with hDC
|
|
|
|
if (0 == (memDC = ::CreateCompatibleDC( hDC )))
|
|
|
|
break;
|
|
|
|
|
|
|
|
// Determine the bitmap's dimensions
|
|
|
|
int nchannels = 3;
|
|
|
|
SIZE size = {0,0};
|
|
|
|
icvGetBitmapData( window, &size, &nchannels, 0 );
|
|
|
|
|
|
|
|
// Create bitmap to draw on and it in the new DC
|
|
|
|
if (0 == (memBM = ::CreateCompatibleBitmap ( hDC, size.cx, size.cy)))
|
|
|
|
break;
|
|
|
|
|
|
|
|
if (!::SelectObject( memDC, memBM ))
|
|
|
|
break;
|
|
|
|
|
|
|
|
// Begin drawing to DC
|
|
|
|
if (!::SetStretchBltMode(memDC, COLORONCOLOR))
|
|
|
|
break;
|
|
|
|
|
|
|
|
RGBQUAD table[256];
|
|
|
|
if( 1 == nchannels )
|
|
|
|
{
|
|
|
|
for(int i = 0; i < 256; ++i)
|
|
|
|
{
|
|
|
|
table[i].rgbBlue = (unsigned char)i;
|
|
|
|
table[i].rgbGreen = (unsigned char)i;
|
|
|
|
table[i].rgbRed = (unsigned char)i;
|
|
|
|
}
|
|
|
|
if (!::SetDIBColorTable(window->dc, 0, 255, table))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// The image copied to the clipboard will be in its original size, regardless if the window itself was resized.
|
|
|
|
|
|
|
|
// Render the image to the dc/bitmap (at original size).
|
|
|
|
if (!::BitBlt( memDC, 0, 0, size.cx, size.cy, window->dc, 0, 0, SRCCOPY ))
|
|
|
|
break;
|
|
|
|
|
|
|
|
// Finally, set bitmap to clipboard
|
|
|
|
::SetClipboardData(CF_BITMAP, memBM);
|
2014-01-21 03:44:27 +08:00
|
|
|
} while (0,0); // (0,0) instead of (0) to avoid MSVC compiler warning C4127: "conditional expression is constant"
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
// if handle is allocated (i.e. != 0) then clean-up.
|
2014-07-04 03:45:11 +08:00
|
|
|
if (memBM) ::DeleteObject(memBM);
|
|
|
|
if (memDC) ::DeleteDC(memDC);
|
|
|
|
if (hDC) ::ReleaseDC(hwnd, hDC);
|
2014-01-21 03:44:27 +08:00
|
|
|
::CloseClipboard();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-05-12 01:44:00 +08:00
|
|
|
case WM_WINDOWPOSCHANGING:
|
|
|
|
{
|
|
|
|
LPWINDOWPOS pos = (LPWINDOWPOS)lParam;
|
|
|
|
RECT rect = icvCalcWindowRect(window);
|
|
|
|
pos->x = rect.left;
|
|
|
|
pos->y = rect.top;
|
2018-12-16 10:53:42 +08:00
|
|
|
pos->cx = rect.right - rect.left;
|
|
|
|
pos->cy = rect.bottom - rect.top;
|
2010-05-12 01:44:00 +08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WM_LBUTTONDOWN:
|
|
|
|
case WM_RBUTTONDOWN:
|
|
|
|
case WM_MBUTTONDOWN:
|
|
|
|
case WM_LBUTTONDBLCLK:
|
|
|
|
case WM_RBUTTONDBLCLK:
|
|
|
|
case WM_MBUTTONDBLCLK:
|
|
|
|
case WM_LBUTTONUP:
|
|
|
|
case WM_RBUTTONUP:
|
|
|
|
case WM_MBUTTONUP:
|
|
|
|
case WM_MOUSEMOVE:
|
|
|
|
if( window->on_mouse )
|
|
|
|
{
|
|
|
|
POINT pt;
|
|
|
|
|
|
|
|
int flags = (wParam & MK_LBUTTON ? CV_EVENT_FLAG_LBUTTON : 0)|
|
|
|
|
(wParam & MK_RBUTTON ? CV_EVENT_FLAG_RBUTTON : 0)|
|
|
|
|
(wParam & MK_MBUTTON ? CV_EVENT_FLAG_MBUTTON : 0)|
|
|
|
|
(wParam & MK_CONTROL ? CV_EVENT_FLAG_CTRLKEY : 0)|
|
|
|
|
(wParam & MK_SHIFT ? CV_EVENT_FLAG_SHIFTKEY : 0)|
|
|
|
|
(GetKeyState(VK_MENU) < 0 ? CV_EVENT_FLAG_ALTKEY : 0);
|
|
|
|
int event = uMsg == WM_LBUTTONDOWN ? CV_EVENT_LBUTTONDOWN :
|
|
|
|
uMsg == WM_RBUTTONDOWN ? CV_EVENT_RBUTTONDOWN :
|
|
|
|
uMsg == WM_MBUTTONDOWN ? CV_EVENT_MBUTTONDOWN :
|
|
|
|
uMsg == WM_LBUTTONUP ? CV_EVENT_LBUTTONUP :
|
|
|
|
uMsg == WM_RBUTTONUP ? CV_EVENT_RBUTTONUP :
|
|
|
|
uMsg == WM_MBUTTONUP ? CV_EVENT_MBUTTONUP :
|
|
|
|
uMsg == WM_LBUTTONDBLCLK ? CV_EVENT_LBUTTONDBLCLK :
|
|
|
|
uMsg == WM_RBUTTONDBLCLK ? CV_EVENT_RBUTTONDBLCLK :
|
|
|
|
uMsg == WM_MBUTTONDBLCLK ? CV_EVENT_MBUTTONDBLCLK :
|
|
|
|
CV_EVENT_MOUSEMOVE;
|
|
|
|
if( uMsg == WM_LBUTTONDOWN || uMsg == WM_RBUTTONDOWN || uMsg == WM_MBUTTONDOWN )
|
|
|
|
SetCapture( hwnd );
|
|
|
|
if( uMsg == WM_LBUTTONUP || uMsg == WM_RBUTTONUP || uMsg == WM_MBUTTONUP )
|
|
|
|
ReleaseCapture();
|
|
|
|
|
2014-01-05 23:21:59 +08:00
|
|
|
pt.x = GET_X_LPARAM( lParam );
|
|
|
|
pt.y = GET_Y_LPARAM( lParam );
|
2010-05-12 01:44:00 +08:00
|
|
|
|
2014-05-13 17:43:02 +08:00
|
|
|
if (window->flags & CV_WINDOW_AUTOSIZE)
|
|
|
|
{
|
|
|
|
// As user can't change window size, do not scale window coordinates. Underlying windowing system
|
|
|
|
// may prevent full window from being displayed and in this case coordinates should not be scaled.
|
|
|
|
window->on_mouse( event, pt.x, pt.y, flags, window->on_mouse_param );
|
|
|
|
} else {
|
|
|
|
// Full window is displayed using different size. Scale coordinates to match underlying positions.
|
2020-09-02 06:18:20 +08:00
|
|
|
RECT rect = { 0 };
|
2014-05-13 17:43:02 +08:00
|
|
|
SIZE size = {0, 0};
|
|
|
|
|
|
|
|
GetClientRect( window->hwnd, &rect );
|
2018-12-16 12:50:32 +08:00
|
|
|
|
|
|
|
#ifdef HAVE_OPENGL
|
|
|
|
if (window->useGl)
|
|
|
|
{
|
|
|
|
cv::ogl::Texture2D* texObj = static_cast<cv::ogl::Texture2D*>(window->glDrawData);
|
|
|
|
size.cx = texObj->cols();
|
|
|
|
size.cy = texObj->rows();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
icvGetBitmapData(window, &size, 0, 0);
|
|
|
|
}
|
|
|
|
#else
|
2014-05-13 17:43:02 +08:00
|
|
|
icvGetBitmapData( window, &size, 0, 0 );
|
2018-12-16 12:50:32 +08:00
|
|
|
#endif
|
2010-05-12 01:44:00 +08:00
|
|
|
|
2014-05-13 17:43:02 +08:00
|
|
|
window->on_mouse( event, pt.x*size.cx/MAX(rect.right - rect.left,1),
|
|
|
|
pt.y*size.cy/MAX(rect.bottom - rect.top,1), flags,
|
|
|
|
window->on_mouse_param );
|
|
|
|
}
|
2010-05-12 01:44:00 +08:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WM_PAINT:
|
|
|
|
if(window->image != 0)
|
|
|
|
{
|
|
|
|
int nchannels = 3;
|
|
|
|
SIZE size = {0,0};
|
|
|
|
PAINTSTRUCT paint;
|
|
|
|
HDC hdc;
|
|
|
|
RGBQUAD table[256];
|
|
|
|
|
|
|
|
// Determine the bitmap's dimensions
|
|
|
|
icvGetBitmapData( window, &size, &nchannels, 0 );
|
|
|
|
|
|
|
|
hdc = BeginPaint(hwnd, &paint);
|
|
|
|
SetStretchBltMode(hdc, COLORONCOLOR);
|
|
|
|
|
|
|
|
if( nchannels == 1 )
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for(i = 0; i < 256; i++)
|
|
|
|
{
|
|
|
|
table[i].rgbBlue = (unsigned char)i;
|
|
|
|
table[i].rgbGreen = (unsigned char)i;
|
|
|
|
table[i].rgbRed = (unsigned char)i;
|
|
|
|
}
|
|
|
|
SetDIBColorTable(window->dc, 0, 255, table);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(window->flags & CV_WINDOW_AUTOSIZE)
|
|
|
|
{
|
|
|
|
BitBlt( hdc, 0, 0, size.cx, size.cy, window->dc, 0, 0, SRCCOPY );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2020-09-02 06:18:20 +08:00
|
|
|
RECT rect = { 0 };
|
2010-05-12 01:44:00 +08:00
|
|
|
GetClientRect(window->hwnd, &rect);
|
|
|
|
StretchBlt( hdc, 0, 0, rect.right - rect.left, rect.bottom - rect.top,
|
|
|
|
window->dc, 0, 0, size.cx, size.cy, SRCCOPY );
|
|
|
|
}
|
|
|
|
//DeleteDC(hdc);
|
|
|
|
EndPaint(hwnd, &paint);
|
|
|
|
}
|
2011-11-21 19:58:52 +08:00
|
|
|
#ifdef HAVE_OPENGL
|
2012-06-08 11:15:08 +08:00
|
|
|
else if(window->useGl)
|
2011-11-21 19:58:52 +08:00
|
|
|
{
|
2012-06-08 11:15:08 +08:00
|
|
|
drawGl(window);
|
2011-11-21 19:58:52 +08:00
|
|
|
return DefWindowProc(hwnd, uMsg, wParam, lParam);
|
|
|
|
}
|
|
|
|
#endif
|
2010-05-12 01:44:00 +08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
return DefWindowProc(hwnd, uMsg, wParam, lParam);
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case WM_ERASEBKGND:
|
|
|
|
if(window->image)
|
|
|
|
return 0;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WM_DESTROY:
|
|
|
|
|
|
|
|
icvRemoveWindow(window);
|
|
|
|
// Do nothing!!!
|
|
|
|
//PostQuitMessage(0);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WM_SETCURSOR:
|
|
|
|
SetCursor((HCURSOR)icvGetClassLongPtr(hwnd, CV_HCURSOR));
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
case WM_KEYDOWN:
|
|
|
|
window->last_key = (int)wParam;
|
|
|
|
return 0;
|
2011-11-21 19:58:52 +08:00
|
|
|
|
|
|
|
case WM_SIZE:
|
|
|
|
window->width = LOWORD(lParam);
|
|
|
|
window->height = HIWORD(lParam);
|
|
|
|
|
|
|
|
#ifdef HAVE_OPENGL
|
|
|
|
if (window->useGl)
|
|
|
|
resizeGl(window);
|
|
|
|
#endif
|
2010-05-12 01:44:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return DefWindowProc(hwnd, uMsg, wParam, lParam);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static LRESULT CALLBACK WindowProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
|
|
|
|
{
|
|
|
|
LRESULT ret;
|
|
|
|
|
|
|
|
if( hg_on_preprocess )
|
|
|
|
{
|
|
|
|
int was_processed = 0;
|
2012-06-12 22:46:12 +08:00
|
|
|
int rethg = hg_on_preprocess(hwnd, uMsg, wParam, lParam, &was_processed);
|
2010-05-12 01:44:00 +08:00
|
|
|
if( was_processed )
|
2012-06-12 22:46:12 +08:00
|
|
|
return rethg;
|
2010-05-12 01:44:00 +08:00
|
|
|
}
|
|
|
|
ret = HighGUIProc(hwnd, uMsg, wParam, lParam);
|
|
|
|
|
|
|
|
if(hg_on_postprocess)
|
|
|
|
{
|
|
|
|
int was_processed = 0;
|
2012-06-12 22:46:12 +08:00
|
|
|
int rethg = hg_on_postprocess(hwnd, uMsg, wParam, lParam, &was_processed);
|
2010-05-12 01:44:00 +08:00
|
|
|
if( was_processed )
|
2012-06-12 22:46:12 +08:00
|
|
|
return rethg;
|
2010-05-12 01:44:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static void icvUpdateTrackbar( CvTrackbar* trackbar, int pos )
|
|
|
|
{
|
|
|
|
const int max_name_len = 10;
|
|
|
|
const char* suffix = "";
|
|
|
|
char pos_text[32];
|
|
|
|
int name_len;
|
|
|
|
|
|
|
|
if( trackbar->data )
|
|
|
|
*trackbar->data = pos;
|
|
|
|
|
|
|
|
if( trackbar->pos != pos )
|
|
|
|
{
|
|
|
|
trackbar->pos = pos;
|
|
|
|
if( trackbar->notify2 )
|
|
|
|
trackbar->notify2(pos, trackbar->userdata);
|
|
|
|
if( trackbar->notify )
|
|
|
|
trackbar->notify(pos);
|
|
|
|
|
|
|
|
name_len = (int)strlen(trackbar->name);
|
|
|
|
|
|
|
|
if( name_len > max_name_len )
|
|
|
|
{
|
|
|
|
int start_len = max_name_len*2/3;
|
|
|
|
int end_len = max_name_len - start_len - 2;
|
|
|
|
memcpy( pos_text, trackbar->name, start_len );
|
|
|
|
memcpy( pos_text + start_len, "...", 3 );
|
|
|
|
memcpy( pos_text + start_len + 3, trackbar->name + name_len - end_len, end_len + 1 );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
memcpy( pos_text, trackbar->name, name_len + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
sprintf( pos_text + strlen(pos_text), "%s: %d\n", suffix, pos );
|
|
|
|
SetWindowText( trackbar->buddy, pos_text );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static LRESULT CALLBACK HGToolbarProc( HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam )
|
|
|
|
{
|
|
|
|
CvWindow* window = icvWindowByHWND( hwnd );
|
|
|
|
if(!window)
|
|
|
|
return DefWindowProc(hwnd, uMsg, wParam, lParam);
|
|
|
|
|
|
|
|
// Control messages processing
|
|
|
|
switch(uMsg)
|
|
|
|
{
|
|
|
|
// Slider processing
|
|
|
|
case WM_HSCROLL:
|
|
|
|
{
|
|
|
|
HWND slider = (HWND)lParam;
|
|
|
|
int pos = (int)SendMessage(slider, TBM_GETPOS, 0, 0);
|
|
|
|
CvTrackbar* trackbar = icvTrackbarByHWND( slider );
|
|
|
|
|
|
|
|
if( trackbar )
|
|
|
|
{
|
|
|
|
if( trackbar->pos != pos )
|
|
|
|
icvUpdateTrackbar( trackbar, pos );
|
|
|
|
}
|
|
|
|
|
|
|
|
SetFocus( window->hwnd );
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
case WM_NCCALCSIZE:
|
|
|
|
{
|
|
|
|
LRESULT ret = CallWindowProc(window->toolbar.toolBarProc, hwnd, uMsg, wParam, lParam);
|
|
|
|
int rows = (int)SendMessage(hwnd, TB_GETROWS, 0, 0);
|
|
|
|
|
|
|
|
if(window->toolbar.rows != rows)
|
|
|
|
{
|
|
|
|
SendMessage(window->toolbar.toolbar, TB_BUTTONCOUNT, 0, 0);
|
|
|
|
CvTrackbar* trackbar = window->toolbar.first;
|
|
|
|
|
|
|
|
for( ; trackbar != 0; trackbar = trackbar->next )
|
|
|
|
{
|
2020-09-02 06:18:20 +08:00
|
|
|
RECT rect = { 0 };
|
2010-05-12 01:44:00 +08:00
|
|
|
SendMessage(window->toolbar.toolbar, TB_GETITEMRECT,
|
|
|
|
(WPARAM)trackbar->id, (LPARAM)&rect);
|
|
|
|
MoveWindow(trackbar->hwnd, rect.left + HG_BUDDY_WIDTH, rect.top,
|
|
|
|
rect.right - rect.left - HG_BUDDY_WIDTH,
|
|
|
|
rect.bottom - rect.top, FALSE);
|
|
|
|
MoveWindow(trackbar->buddy, rect.left, rect.top,
|
|
|
|
HG_BUDDY_WIDTH, rect.bottom - rect.top, FALSE);
|
|
|
|
}
|
|
|
|
window->toolbar.rows = rows;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return CallWindowProc(window->toolbar.toolBarProc, hwnd, uMsg, wParam, lParam);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
CV_IMPL void
|
|
|
|
cvDestroyAllWindows(void)
|
|
|
|
{
|
|
|
|
CvWindow* window = hg_windows;
|
|
|
|
|
|
|
|
while( window )
|
|
|
|
{
|
|
|
|
HWND mainhWnd = window->frame;
|
|
|
|
HWND hwnd = window->hwnd;
|
|
|
|
window = window->next;
|
|
|
|
|
|
|
|
SendMessage( hwnd, WM_CLOSE, 0, 0 );
|
|
|
|
SendMessage( mainhWnd, WM_CLOSE, 0, 0 );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-11-30 05:43:21 +08:00
|
|
|
static void showSaveDialog(CvWindow* window)
|
|
|
|
{
|
|
|
|
if (!window || !window->image)
|
|
|
|
return;
|
|
|
|
|
|
|
|
SIZE sz;
|
|
|
|
int channels;
|
|
|
|
void* data;
|
|
|
|
if (icvGetBitmapData(window, &sz, &channels, &data))
|
|
|
|
return; // nothing to save
|
|
|
|
|
|
|
|
char szFileName[MAX_PATH] = "";
|
|
|
|
// try to use window title as file name
|
|
|
|
GetWindowText(window->frame, szFileName, MAX_PATH);
|
|
|
|
|
|
|
|
OPENFILENAME ofn;
|
|
|
|
ZeroMemory(&ofn, sizeof(ofn));
|
|
|
|
#ifdef OPENFILENAME_SIZE_VERSION_400
|
|
|
|
// we are not going to use new fields any way
|
|
|
|
ofn.lStructSize = OPENFILENAME_SIZE_VERSION_400;
|
|
|
|
#else
|
|
|
|
ofn.lStructSize = sizeof(ofn);
|
|
|
|
#endif
|
|
|
|
ofn.hwndOwner = window->hwnd;
|
2015-07-20 21:35:00 +08:00
|
|
|
ofn.lpstrFilter =
|
|
|
|
#ifdef HAVE_PNG
|
|
|
|
"Portable Network Graphics files (*.png)\0*.png\0"
|
|
|
|
#endif
|
2014-11-30 05:43:21 +08:00
|
|
|
"Windows bitmap (*.bmp;*.dib)\0*.bmp;*.dib\0"
|
2015-07-20 21:35:00 +08:00
|
|
|
#ifdef HAVE_JPEG
|
|
|
|
"JPEG files (*.jpeg;*.jpg;*.jpe)\0*.jpeg;*.jpg;*.jpe\0"
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_TIFF
|
2014-11-30 05:43:21 +08:00
|
|
|
"TIFF Files (*.tiff;*.tif)\0*.tiff;*.tif\0"
|
2015-07-20 21:35:00 +08:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_JASPER
|
2014-11-30 05:43:21 +08:00
|
|
|
"JPEG-2000 files (*.jp2)\0*.jp2\0"
|
2015-07-20 21:35:00 +08:00
|
|
|
#endif
|
|
|
|
#ifdef HAVE_WEBP
|
2014-11-30 05:43:21 +08:00
|
|
|
"WebP files (*.webp)\0*.webp\0"
|
2015-07-20 21:35:00 +08:00
|
|
|
#endif
|
2014-11-30 05:43:21 +08:00
|
|
|
"Portable image format (*.pbm;*.pgm;*.ppm;*.pxm;*.pnm)\0*.pbm;*.pgm;*.ppm;*.pxm;*.pnm\0"
|
2015-07-20 21:35:00 +08:00
|
|
|
#ifdef HAVE_OPENEXR
|
2014-11-30 05:43:21 +08:00
|
|
|
"OpenEXR Image files (*.exr)\0*.exr\0"
|
2015-07-20 21:35:00 +08:00
|
|
|
#endif
|
2014-11-30 05:43:21 +08:00
|
|
|
"Radiance HDR (*.hdr;*.pic)\0*.hdr;*.pic\0"
|
|
|
|
"Sun raster files (*.sr;*.ras)\0*.sr;*.ras\0"
|
|
|
|
"All Files (*.*)\0*.*\0";
|
|
|
|
ofn.lpstrFile = szFileName;
|
|
|
|
ofn.nMaxFile = MAX_PATH;
|
|
|
|
ofn.Flags = OFN_EXPLORER | OFN_PATHMUSTEXIST | OFN_OVERWRITEPROMPT | OFN_NOREADONLYRETURN | OFN_NOCHANGEDIR;
|
2015-07-20 21:35:00 +08:00
|
|
|
#ifdef HAVE_PNG
|
2014-11-30 05:43:21 +08:00
|
|
|
ofn.lpstrDefExt = "png";
|
2015-07-20 21:35:00 +08:00
|
|
|
#else
|
|
|
|
ofn.lpstrDefExt = "bmp";
|
|
|
|
#endif
|
2014-11-30 05:43:21 +08:00
|
|
|
|
|
|
|
if (GetSaveFileName(&ofn))
|
|
|
|
{
|
2015-09-21 05:34:15 +08:00
|
|
|
cv::Mat tmp;
|
|
|
|
cv::flip(cv::Mat(sz.cy, sz.cx, CV_8UC(channels), data, (sz.cx * channels + 3) & -4), tmp, 0);
|
2014-11-30 05:43:21 +08:00
|
|
|
cv::imwrite(szFileName, tmp);
|
|
|
|
}
|
|
|
|
}
|
2010-05-12 01:44:00 +08:00
|
|
|
|
|
|
|
CV_IMPL int
|
|
|
|
cvWaitKey( int delay )
|
|
|
|
{
|
2018-06-08 00:25:01 +08:00
|
|
|
int64 time0 = cv::getTickCount();
|
|
|
|
int64 timeEnd = time0 + (int64)(delay * 0.001f * cv::getTickFrequency());
|
2010-05-12 01:44:00 +08:00
|
|
|
|
|
|
|
for(;;)
|
|
|
|
{
|
|
|
|
CvWindow* window;
|
|
|
|
MSG message;
|
|
|
|
int is_processed = 0;
|
|
|
|
|
2018-11-06 18:43:58 +08:00
|
|
|
if( (delay <= 0) && hg_windows)
|
2010-05-12 01:44:00 +08:00
|
|
|
GetMessage(&message, 0, 0, 0);
|
|
|
|
else if( PeekMessage(&message, 0, 0, 0, PM_REMOVE) == FALSE )
|
|
|
|
{
|
2018-06-08 00:25:01 +08:00
|
|
|
int64 t = cv::getTickCount();
|
|
|
|
if (t - timeEnd >= 0)
|
|
|
|
return -1; // no messages and no more time
|
2010-05-12 01:44:00 +08:00
|
|
|
Sleep(1);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
for( window = hg_windows; window != 0 && is_processed == 0; window = window->next )
|
|
|
|
{
|
|
|
|
if( window->hwnd == message.hwnd || window->frame == message.hwnd )
|
|
|
|
{
|
|
|
|
is_processed = 1;
|
|
|
|
switch(message.message)
|
|
|
|
{
|
|
|
|
case WM_DESTROY:
|
|
|
|
case WM_CHAR:
|
|
|
|
DispatchMessage(&message);
|
|
|
|
return (int)message.wParam;
|
|
|
|
|
|
|
|
case WM_SYSKEYDOWN:
|
|
|
|
if( message.wParam == VK_F10 )
|
|
|
|
{
|
|
|
|
is_processed = 1;
|
|
|
|
return (int)(message.wParam << 16);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WM_KEYDOWN:
|
|
|
|
TranslateMessage(&message);
|
2014-11-30 05:43:21 +08:00
|
|
|
if( (message.wParam >= VK_F1 && message.wParam <= VK_F24) ||
|
|
|
|
message.wParam == VK_HOME || message.wParam == VK_END ||
|
|
|
|
message.wParam == VK_UP || message.wParam == VK_DOWN ||
|
|
|
|
message.wParam == VK_LEFT || message.wParam == VK_RIGHT ||
|
|
|
|
message.wParam == VK_INSERT || message.wParam == VK_DELETE ||
|
|
|
|
message.wParam == VK_PRIOR || message.wParam == VK_NEXT )
|
2010-05-12 01:44:00 +08:00
|
|
|
{
|
|
|
|
DispatchMessage(&message);
|
|
|
|
is_processed = 1;
|
|
|
|
return (int)(message.wParam << 16);
|
|
|
|
}
|
2014-01-21 03:44:27 +08:00
|
|
|
|
|
|
|
// Intercept Ctrl+C for copy to clipboard
|
|
|
|
if ('C' == message.wParam && (::GetKeyState(VK_CONTROL)>>15))
|
2014-11-30 05:43:21 +08:00
|
|
|
::SendMessage(message.hwnd, WM_COPY, 0, 0);
|
|
|
|
|
|
|
|
// Intercept Ctrl+S for "save as" dialog
|
|
|
|
if ('S' == message.wParam && (::GetKeyState(VK_CONTROL)>>15))
|
|
|
|
showSaveDialog(window);
|
2014-01-21 03:44:27 +08:00
|
|
|
|
2010-05-12 01:44:00 +08:00
|
|
|
default:
|
|
|
|
DispatchMessage(&message);
|
|
|
|
is_processed = 1;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if( !is_processed )
|
|
|
|
{
|
|
|
|
TranslateMessage(&message);
|
|
|
|
DispatchMessage(&message);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static CvTrackbar*
|
|
|
|
icvFindTrackbarByName( const CvWindow* window, const char* name )
|
|
|
|
{
|
|
|
|
CvTrackbar* trackbar = window->toolbar.first;
|
|
|
|
|
|
|
|
for( ; trackbar != 0 && strcmp( trackbar->name, name ) != 0; trackbar = trackbar->next )
|
|
|
|
;
|
|
|
|
|
|
|
|
return trackbar;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
icvCreateTrackbar( const char* trackbar_name, const char* window_name,
|
|
|
|
int* val, int count, CvTrackbarCallback on_notify,
|
|
|
|
CvTrackbarCallback2 on_notify2, void* userdata )
|
|
|
|
{
|
|
|
|
int result = 0;
|
|
|
|
|
|
|
|
CV_FUNCNAME( "icvCreateTrackbar" );
|
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
char slider_name[32];
|
|
|
|
CvWindow* window = 0;
|
|
|
|
CvTrackbar* trackbar = 0;
|
|
|
|
int pos = 0;
|
|
|
|
|
|
|
|
if( !window_name || !trackbar_name )
|
|
|
|
CV_ERROR( CV_StsNullPtr, "NULL window or trackbar name" );
|
|
|
|
|
2014-09-28 05:27:04 +08:00
|
|
|
if( count < 0 )
|
2010-05-12 01:44:00 +08:00
|
|
|
CV_ERROR( CV_StsOutOfRange, "Bad trackbar maximal value" );
|
|
|
|
|
|
|
|
window = icvFindWindowByName(window_name);
|
|
|
|
if( !window )
|
|
|
|
EXIT;
|
|
|
|
|
|
|
|
trackbar = icvFindTrackbarByName(window,trackbar_name);
|
|
|
|
if( !trackbar )
|
|
|
|
{
|
2015-09-01 05:59:08 +08:00
|
|
|
TBBUTTON tbs = {};
|
|
|
|
TBBUTTONINFO tbis = {};
|
2020-09-02 06:18:20 +08:00
|
|
|
RECT rect = { 0 };
|
2010-05-12 01:44:00 +08:00
|
|
|
int bcount;
|
|
|
|
int len = (int)strlen( trackbar_name );
|
|
|
|
|
|
|
|
// create toolbar if it is not created yet
|
|
|
|
if( !window->toolbar.toolbar )
|
|
|
|
{
|
|
|
|
const int default_height = 30;
|
|
|
|
|
2014-09-28 05:27:04 +08:00
|
|
|
// CreateToolbarEx is deprecated and forces linking against Comctl32.lib.
|
|
|
|
window->toolbar.toolbar = CreateWindowEx(0, TOOLBARCLASSNAME, NULL,
|
|
|
|
WS_CHILD | CCS_TOP | TBSTYLE_WRAPABLE | BTNS_AUTOSIZE | BTNS_BUTTON,
|
|
|
|
0, 0, 0, 0,
|
|
|
|
window->frame, NULL, GetModuleHandle(NULL), NULL);
|
|
|
|
// CreateToolbarEx automatically sends this but CreateWindowEx doesn't.
|
|
|
|
SendMessage(window->toolbar.toolbar, TB_BUTTONSTRUCTSIZE, (WPARAM)sizeof(TBBUTTON), 0);
|
|
|
|
|
2010-05-12 01:44:00 +08:00
|
|
|
GetClientRect(window->frame, &rect);
|
|
|
|
MoveWindow( window->toolbar.toolbar, 0, 0,
|
|
|
|
rect.right - rect.left, default_height, TRUE);
|
|
|
|
SendMessage(window->toolbar.toolbar, TB_AUTOSIZE, 0, 0);
|
|
|
|
ShowWindow(window->toolbar.toolbar, SW_SHOW);
|
|
|
|
|
|
|
|
window->toolbar.first = 0;
|
|
|
|
window->toolbar.pos = 0;
|
|
|
|
window->toolbar.rows = 0;
|
|
|
|
window->toolbar.toolBarProc =
|
|
|
|
(WNDPROC)icvGetWindowLongPtr(window->toolbar.toolbar, CV_WNDPROC);
|
|
|
|
|
|
|
|
icvUpdateWindowPos(window);
|
|
|
|
|
|
|
|
// Subclassing from toolbar
|
|
|
|
icvSetWindowLongPtr(window->toolbar.toolbar, CV_WNDPROC, HGToolbarProc);
|
|
|
|
icvSetWindowLongPtr(window->toolbar.toolbar, CV_USERDATA, window);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Retrieve current buttons count */
|
|
|
|
bcount = (int)SendMessage(window->toolbar.toolbar, TB_BUTTONCOUNT, 0, 0);
|
|
|
|
|
|
|
|
if(bcount > 1)
|
|
|
|
{
|
|
|
|
/* If this is not the first button then we need to
|
|
|
|
separate it from the previous one */
|
|
|
|
tbs.iBitmap = 0;
|
|
|
|
tbs.idCommand = bcount; // Set button id to it's number
|
|
|
|
tbs.iString = 0;
|
|
|
|
tbs.fsStyle = TBSTYLE_SEP;
|
|
|
|
tbs.fsState = TBSTATE_ENABLED;
|
|
|
|
SendMessage(window->toolbar.toolbar, TB_ADDBUTTONS, 1, (LPARAM)&tbs);
|
|
|
|
|
|
|
|
// Retrieve current buttons count
|
|
|
|
bcount = (int)SendMessage(window->toolbar.toolbar, TB_BUTTONCOUNT, 0, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Add a button which we're going to cover with the slider */
|
|
|
|
tbs.iBitmap = 0;
|
|
|
|
tbs.idCommand = bcount; // Set button id to it's number
|
|
|
|
tbs.fsState = TBSTATE_ENABLED;
|
|
|
|
#if 0/*!defined WIN64 && !defined EM64T*/
|
|
|
|
tbs.fsStyle = 0;
|
|
|
|
tbs.iString = 0;
|
|
|
|
#else
|
|
|
|
|
|
|
|
#ifndef TBSTYLE_AUTOSIZE
|
|
|
|
#define TBSTYLE_AUTOSIZE 0x0010
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifndef TBSTYLE_GROUP
|
|
|
|
#define TBSTYLE_GROUP 0x0004
|
|
|
|
#endif
|
|
|
|
//tbs.fsStyle = TBSTYLE_AUTOSIZE;
|
|
|
|
tbs.fsStyle = TBSTYLE_GROUP;
|
|
|
|
tbs.iString = (INT_PTR)trackbar_text;
|
|
|
|
#endif
|
|
|
|
SendMessage(window->toolbar.toolbar, TB_ADDBUTTONS, 1, (LPARAM)&tbs);
|
|
|
|
|
|
|
|
/* Adjust button size to the slider */
|
|
|
|
tbis.cbSize = sizeof(tbis);
|
|
|
|
tbis.dwMask = TBIF_SIZE;
|
|
|
|
|
|
|
|
GetClientRect(window->hwnd, &rect);
|
|
|
|
tbis.cx = (unsigned short)(rect.right - rect.left);
|
|
|
|
|
|
|
|
SendMessage(window->toolbar.toolbar, TB_SETBUTTONINFO,
|
|
|
|
(WPARAM)tbs.idCommand, (LPARAM)&tbis);
|
|
|
|
|
2012-05-17 00:13:24 +08:00
|
|
|
/* Get button pos */
|
2010-05-12 01:44:00 +08:00
|
|
|
SendMessage(window->toolbar.toolbar, TB_GETITEMRECT,
|
|
|
|
(WPARAM)tbs.idCommand, (LPARAM)&rect);
|
|
|
|
|
|
|
|
/* Create a slider */
|
|
|
|
trackbar = (CvTrackbar*)cvAlloc( sizeof(CvTrackbar) + len + 1 );
|
|
|
|
trackbar->signature = CV_TRACKBAR_MAGIC_VAL;
|
|
|
|
trackbar->notify = 0;
|
|
|
|
trackbar->notify2 = 0;
|
|
|
|
trackbar->parent = window;
|
|
|
|
trackbar->pos = 0;
|
|
|
|
trackbar->data = 0;
|
|
|
|
trackbar->id = bcount;
|
|
|
|
trackbar->next = window->toolbar.first;
|
|
|
|
trackbar->name = (char*)(trackbar + 1);
|
|
|
|
memcpy( trackbar->name, trackbar_name, len + 1 );
|
|
|
|
window->toolbar.first = trackbar;
|
|
|
|
|
|
|
|
sprintf(slider_name, "Trackbar%p", val);
|
|
|
|
trackbar->hwnd = CreateWindowEx(0, TRACKBAR_CLASS, slider_name,
|
|
|
|
WS_CHILD | WS_VISIBLE | TBS_AUTOTICKS |
|
|
|
|
TBS_FIXEDLENGTH | TBS_HORZ | TBS_BOTTOM,
|
|
|
|
rect.left + HG_BUDDY_WIDTH, rect.top,
|
|
|
|
rect.right - rect.left - HG_BUDDY_WIDTH,
|
|
|
|
rect.bottom - rect.top, window->toolbar.toolbar,
|
|
|
|
(HMENU)(size_t)bcount, hg_hinstance, 0);
|
|
|
|
|
|
|
|
sprintf(slider_name,"Buddy%p", val);
|
|
|
|
trackbar->buddy = CreateWindowEx(0, "STATIC", slider_name,
|
|
|
|
WS_CHILD | SS_RIGHT,
|
|
|
|
rect.left, rect.top,
|
|
|
|
HG_BUDDY_WIDTH, rect.bottom - rect.top,
|
|
|
|
window->toolbar.toolbar, 0, hg_hinstance, 0);
|
|
|
|
|
|
|
|
icvSetWindowLongPtr( trackbar->hwnd, CV_USERDATA, trackbar );
|
|
|
|
|
|
|
|
/* Minimize the number of rows */
|
|
|
|
SendMessage( window->toolbar.toolbar, TB_SETROWS,
|
|
|
|
MAKEWPARAM(1, FALSE), (LPARAM)&rect );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
trackbar->data = 0;
|
|
|
|
trackbar->notify = 0;
|
|
|
|
trackbar->notify2 = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
trackbar->maxval = count;
|
|
|
|
|
|
|
|
/* Adjust slider parameters */
|
2012-10-11 03:05:15 +08:00
|
|
|
SendMessage(trackbar->hwnd, TBM_SETRANGEMIN, (WPARAM)TRUE, (LPARAM)0);
|
|
|
|
SendMessage(trackbar->hwnd, TBM_SETRANGEMAX, (WPARAM)TRUE, (LPARAM)count);
|
2010-05-12 01:44:00 +08:00
|
|
|
SendMessage(trackbar->hwnd, TBM_SETTICFREQ, (WPARAM)1, (LPARAM)0 );
|
|
|
|
if( val )
|
|
|
|
pos = *val;
|
|
|
|
|
|
|
|
SendMessage(trackbar->hwnd, TBM_SETPOS, (WPARAM)TRUE, (LPARAM)pos );
|
|
|
|
SendMessage(window->toolbar.toolbar, TB_AUTOSIZE, 0, 0);
|
|
|
|
|
|
|
|
trackbar->pos = -1;
|
|
|
|
icvUpdateTrackbar( trackbar, pos );
|
|
|
|
ShowWindow( trackbar->buddy, SW_SHOW );
|
|
|
|
ShowWindow( trackbar->hwnd, SW_SHOW );
|
|
|
|
|
|
|
|
trackbar->notify = on_notify;
|
|
|
|
trackbar->notify2 = on_notify2;
|
|
|
|
trackbar->userdata = userdata;
|
|
|
|
trackbar->data = val;
|
|
|
|
|
|
|
|
/* Resize the window to reflect the toolbar resizing*/
|
|
|
|
icvUpdateWindowPos(window);
|
|
|
|
|
|
|
|
result = 1;
|
|
|
|
|
|
|
|
__END__;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
CV_IMPL int
|
|
|
|
cvCreateTrackbar( const char* trackbar_name, const char* window_name,
|
|
|
|
int* val, int count, CvTrackbarCallback on_notify )
|
|
|
|
{
|
|
|
|
return icvCreateTrackbar( trackbar_name, window_name, val, count,
|
|
|
|
on_notify, 0, 0 );
|
|
|
|
}
|
|
|
|
|
|
|
|
CV_IMPL int
|
|
|
|
cvCreateTrackbar2( const char* trackbar_name, const char* window_name,
|
|
|
|
int* val, int count, CvTrackbarCallback2 on_notify2,
|
|
|
|
void* userdata )
|
|
|
|
{
|
|
|
|
return icvCreateTrackbar( trackbar_name, window_name, val, count,
|
|
|
|
0, on_notify2, userdata );
|
|
|
|
}
|
|
|
|
|
|
|
|
CV_IMPL void
|
|
|
|
cvSetMouseCallback( const char* window_name, CvMouseCallback on_mouse, void* param )
|
|
|
|
{
|
|
|
|
CV_FUNCNAME( "cvSetMouseCallback" );
|
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
CvWindow* window = 0;
|
|
|
|
|
|
|
|
if( !window_name )
|
|
|
|
CV_ERROR( CV_StsNullPtr, "NULL window name" );
|
|
|
|
|
|
|
|
window = icvFindWindowByName(window_name);
|
|
|
|
if( !window )
|
|
|
|
EXIT;
|
|
|
|
|
|
|
|
window->on_mouse = on_mouse;
|
|
|
|
window->on_mouse_param = param;
|
|
|
|
|
|
|
|
__END__;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
CV_IMPL int cvGetTrackbarPos( const char* trackbar_name, const char* window_name )
|
|
|
|
{
|
|
|
|
int pos = -1;
|
|
|
|
|
|
|
|
CV_FUNCNAME( "cvGetTrackbarPos" );
|
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
CvWindow* window;
|
|
|
|
CvTrackbar* trackbar = 0;
|
|
|
|
|
|
|
|
if( trackbar_name == 0 || window_name == 0 )
|
|
|
|
CV_ERROR( CV_StsNullPtr, "NULL trackbar or window name" );
|
|
|
|
|
|
|
|
window = icvFindWindowByName( window_name );
|
|
|
|
if( window )
|
|
|
|
trackbar = icvFindTrackbarByName( window, trackbar_name );
|
|
|
|
|
|
|
|
if( trackbar )
|
|
|
|
pos = trackbar->pos;
|
|
|
|
|
|
|
|
__END__;
|
|
|
|
|
|
|
|
return pos;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
CV_IMPL void cvSetTrackbarPos( const char* trackbar_name, const char* window_name, int pos )
|
|
|
|
{
|
|
|
|
CV_FUNCNAME( "cvSetTrackbarPos" );
|
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
CvWindow* window;
|
|
|
|
CvTrackbar* trackbar = 0;
|
|
|
|
|
|
|
|
if( trackbar_name == 0 || window_name == 0 )
|
|
|
|
CV_ERROR( CV_StsNullPtr, "NULL trackbar or window name" );
|
|
|
|
|
|
|
|
window = icvFindWindowByName( window_name );
|
|
|
|
if( window )
|
|
|
|
trackbar = icvFindTrackbarByName( window, trackbar_name );
|
|
|
|
|
|
|
|
if( trackbar )
|
|
|
|
{
|
|
|
|
if( pos < 0 )
|
|
|
|
pos = 0;
|
|
|
|
|
|
|
|
if( pos > trackbar->maxval )
|
|
|
|
pos = trackbar->maxval;
|
|
|
|
|
|
|
|
SendMessage( trackbar->hwnd, TBM_SETPOS, (WPARAM)TRUE, (LPARAM)pos );
|
|
|
|
icvUpdateTrackbar( trackbar, pos );
|
|
|
|
}
|
|
|
|
|
|
|
|
__END__;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-09-28 05:27:04 +08:00
|
|
|
CV_IMPL void cvSetTrackbarMax(const char* trackbar_name, const char* window_name, int maxval)
|
|
|
|
{
|
|
|
|
CV_FUNCNAME( "cvSetTrackbarMax" );
|
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
if (maxval >= 0)
|
|
|
|
{
|
|
|
|
CvWindow* window = 0;
|
|
|
|
CvTrackbar* trackbar = 0;
|
|
|
|
if (trackbar_name == 0 || window_name == 0)
|
|
|
|
{
|
|
|
|
CV_ERROR(CV_StsNullPtr, "NULL trackbar or window name");
|
|
|
|
}
|
|
|
|
|
|
|
|
window = icvFindWindowByName(window_name);
|
|
|
|
if (window)
|
|
|
|
{
|
|
|
|
trackbar = icvFindTrackbarByName(window, trackbar_name);
|
|
|
|
if (trackbar)
|
|
|
|
{
|
|
|
|
// The position will be min(pos, maxval).
|
2015-10-19 16:44:06 +08:00
|
|
|
trackbar->maxval = (trackbar->minval>maxval)?trackbar->minval:maxval;
|
2014-09-28 05:27:04 +08:00
|
|
|
SendMessage(trackbar->hwnd, TBM_SETRANGEMAX, (WPARAM)TRUE, (LPARAM)maxval);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
__END__;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2015-10-19 16:44:06 +08:00
|
|
|
CV_IMPL void cvSetTrackbarMin(const char* trackbar_name, const char* window_name, int minval)
|
|
|
|
{
|
|
|
|
CV_FUNCNAME( "cvSetTrackbarMin" );
|
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
2015-10-19 18:58:43 +08:00
|
|
|
if (minval >= 0)
|
2015-10-19 16:44:06 +08:00
|
|
|
{
|
|
|
|
CvWindow* window = 0;
|
|
|
|
CvTrackbar* trackbar = 0;
|
|
|
|
if (trackbar_name == 0 || window_name == 0)
|
|
|
|
{
|
|
|
|
CV_ERROR(CV_StsNullPtr, "NULL trackbar or window name");
|
|
|
|
}
|
|
|
|
|
|
|
|
window = icvFindWindowByName(window_name);
|
|
|
|
if (window)
|
|
|
|
{
|
|
|
|
trackbar = icvFindTrackbarByName(window, trackbar_name);
|
|
|
|
if (trackbar)
|
|
|
|
{
|
|
|
|
// The position will be min(pos, maxval).
|
|
|
|
trackbar->minval = (minval<trackbar->maxval)?minval:trackbar->maxval;
|
|
|
|
SendMessage(trackbar->hwnd, TBM_SETRANGEMIN, (WPARAM)TRUE, (LPARAM)minval);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
__END__;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2010-05-12 01:44:00 +08:00
|
|
|
CV_IMPL void* cvGetWindowHandle( const char* window_name )
|
|
|
|
{
|
|
|
|
void* hwnd = 0;
|
|
|
|
|
|
|
|
CV_FUNCNAME( "cvGetWindowHandle" );
|
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
CvWindow* window;
|
|
|
|
|
|
|
|
if( window_name == 0 )
|
|
|
|
CV_ERROR( CV_StsNullPtr, "NULL window name" );
|
|
|
|
|
|
|
|
window = icvFindWindowByName( window_name );
|
|
|
|
if( window )
|
|
|
|
hwnd = (void*)window->hwnd;
|
|
|
|
|
|
|
|
__END__;
|
|
|
|
|
|
|
|
return hwnd;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
CV_IMPL const char* cvGetWindowName( void* window_handle )
|
|
|
|
{
|
|
|
|
const char* window_name = "";
|
|
|
|
|
|
|
|
CV_FUNCNAME( "cvGetWindowName" );
|
|
|
|
|
|
|
|
__BEGIN__;
|
|
|
|
|
|
|
|
CvWindow* window;
|
|
|
|
|
|
|
|
if( window_handle == 0 )
|
|
|
|
CV_ERROR( CV_StsNullPtr, "NULL window" );
|
|
|
|
|
|
|
|
window = icvWindowByHWND( (HWND)window_handle );
|
|
|
|
if( window )
|
|
|
|
window_name = window->name;
|
|
|
|
|
|
|
|
__END__;
|
|
|
|
|
|
|
|
return window_name;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
CV_IMPL void
|
2011-05-14 03:40:57 +08:00
|
|
|
cvSetPreprocessFuncWin32_(const void* callback)
|
2010-05-12 01:44:00 +08:00
|
|
|
{
|
2011-05-14 03:40:57 +08:00
|
|
|
hg_on_preprocess = (CvWin32WindowCallback)callback;
|
2010-05-12 01:44:00 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
CV_IMPL void
|
2011-05-14 03:40:57 +08:00
|
|
|
cvSetPostprocessFuncWin32_(const void* callback)
|
2010-05-12 01:44:00 +08:00
|
|
|
{
|
2011-05-14 03:40:57 +08:00
|
|
|
hg_on_postprocess = (CvWin32WindowCallback)callback;
|
2010-05-12 01:44:00 +08:00
|
|
|
}
|
|
|
|
|
2017-07-25 18:23:44 +08:00
|
|
|
#endif //_WIN32
|