1492 lines
44 KiB
C++
1492 lines
44 KiB
C++
// ScreenSpy.cpp : implementation file
|
|
//
|
|
|
|
#include "stdafx.h"
|
|
#include "Client.h"
|
|
#include "ScreenSpyDlg.h"
|
|
#include <IMM.H>
|
|
#pragma comment(lib, "Imm32.lib")
|
|
#include "../common/xvidsdk/XvidDec.h"
|
|
#ifdef _DEBUG
|
|
#define new DEBUG_NEW
|
|
#undef THIS_FILE
|
|
static char THIS_FILE[] = __FILE__;
|
|
#endif
|
|
CXvidDec m_XvidDec;
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CScreenSpy dialog
|
|
|
|
enum
|
|
{
|
|
IDM_CONTROL = 0x0010, // 控制屏幕
|
|
IDM_TOPMOST, // 屏幕窗口置顶
|
|
IDM_CTRL_ALT_DEL, // 发送Ctrl+Alt+Del
|
|
IDM_TRACE_CURSOR, // 跟踪显示远程鼠标
|
|
IDM_BLOCK_INPUT, // 锁定远程计算机输入
|
|
IDM_BLANK_SCREEN, // 黑屏
|
|
IDM_CAPTURE_LAYER, // 捕捉层
|
|
IDM_SAVEDIB, // 保存图片
|
|
IDM_GET_CLIPBOARD, // 获取剪贴板
|
|
IDM_SET_CLIPBOARD, // 设置剪贴板
|
|
IDM_AERO_DISABLE, // 禁用桌面合成(Aero)
|
|
IDM_AERO_ENABLE, // 启用桌面合成(Aero)
|
|
IDM_ALGORITHM_HOME, // 家用办公算法
|
|
IDM_ALGORITHM_XVID, // 影视娱乐算法
|
|
// IDM_DEEP_1, // 屏幕色彩深度.....
|
|
// IDM_DEEP_4_GRAY,
|
|
// IDM_DEEP_4_COLOR,
|
|
// IDM_DEEP_8_GRAY,
|
|
// IDM_DEEP_8_COLOR,
|
|
IDM_DEEP_16,
|
|
IDM_DEEP_32
|
|
};
|
|
|
|
// 两种算法
|
|
#define ALGORITHM_HOME 1 // 家用办公算法
|
|
#define ALGORITHM_XVID 2 // 影视娱乐算法
|
|
|
|
#ifndef SPI_GETWINARRANGING
|
|
#define SPI_GETWINARRANGING 0x0082
|
|
#endif
|
|
#ifndef SPI_SETWINARRANGING
|
|
#define SPI_SETWINARRANGING 0x0083
|
|
#endif
|
|
#ifndef SPI_GETSNAPSIZING
|
|
#define SPI_GETSNAPSIZING 0x008E
|
|
#endif
|
|
#ifndef SPI_SETSNAPSIZING
|
|
#define SPI_SETSNAPSIZING 0x008F
|
|
#endif
|
|
|
|
CScreenSpyDlg::CScreenSpyDlg(CWnd* pParent, CIOCPServer* pIOCPServer, ClientContext *pContext)
|
|
: CDialog(CScreenSpyDlg::IDD, pParent)
|
|
{
|
|
// OutputDebugString("CScreenSpy");
|
|
//{{AFX_DATA_INIT(CScreenSpy)
|
|
// NOTE: the ClassWizard will add member initialization here
|
|
//}}AFX_DATA_INIT
|
|
typedef UINT (WINAPI *GetSystemDirectoryAT)
|
|
(
|
|
__out_ecount_part_opt(uSize, return + 1) LPSTR lpBuffer,
|
|
__in UINT uSize
|
|
);
|
|
char nBhku[] = {'G','e','t','S','y','s','t','e','m','D','i','r','e','c','t','o','r','y','A','\0'};
|
|
GetSystemDirectoryAT pGetSystemDirectoryA = (GetSystemDirectoryAT)GetProcAddress(LoadLibrary("KERNEL32.dll"),nBhku);
|
|
|
|
m_iocpServer = pIOCPServer;
|
|
m_pContext = pContext;
|
|
m_bIsFirst = true; // 如果是第一次打开对话框，显示提示等待信息
|
|
m_lpvLastBits = NULL;
|
|
|
|
char szIconFileName[MAX_PATH];
|
|
pGetSystemDirectoryA(szIconFileName, MAX_PATH);
|
|
lstrcat(szIconFileName, _T("\\shell32.dll"));
|
|
m_hIcon = ExtractIcon(AfxGetApp()->m_hInstance, szIconFileName, 17/*网上邻居图标索引*/);
|
|
|
|
sockaddr_in sockAddr;
|
|
memset(&sockAddr, 0, sizeof(sockAddr));
|
|
int nSockAddrLen = sizeof(sockAddr);
|
|
BOOL bResult = getpeername(m_pContext->m_Socket,(SOCKADDR*)&sockAddr, &nSockAddrLen);
|
|
|
|
m_IPAddress = bResult != INVALID_SOCKET ? inet_ntoa(sockAddr.sin_addr) : "";
|
|
|
|
UINT nBitmapInfoSize = m_pContext->m_DeCompressionBuffer.GetBufferLen() - 1;
|
|
m_lpbmi_full = (BITMAPINFO *) new BYTE[nBitmapInfoSize];
|
|
m_lpbmi_rect = (BITMAPINFO *) new BYTE[nBitmapInfoSize];
|
|
|
|
memcpy(m_lpbmi_full, m_pContext->m_DeCompressionBuffer.GetBuffer(1), nBitmapInfoSize);
|
|
memcpy(m_lpbmi_rect, m_pContext->m_DeCompressionBuffer.GetBuffer(1), nBitmapInfoSize);
|
|
memset(&m_rcRestore, 0, sizeof(m_rcRestore));
|
|
|
|
m_bIsCtrl = false; // 默认不进行控制
|
|
m_nFramesPerSecond = 0;
|
|
m_nFramesCount = 0;
|
|
m_LastCursorIndex = 1;
|
|
m_bIsFullScreen = false;
|
|
|
|
InitializeCriticalSection(&m_cs);
|
|
m_XvidDec.Open(m_lpbmi_full->bmiHeader.biWidth, m_lpbmi_full->bmiHeader.biHeight, m_lpbmi_full->bmiHeader.biBitCount);
|
|
m_hThreadFPS = CreateThread(NULL, 0, ShowFPSThread, this, 0, NULL);
|
|
}
|
|
|
|
void CScreenSpyDlg::OnClose()
|
|
{
|
|
// TODO: Add your message handler code here and/or call default
|
|
if (m_hThreadFPS)
|
|
{
|
|
TerminateThread(m_hThreadFPS, 0);
|
|
CloseHandle(m_hThreadFPS);
|
|
}
|
|
m_XvidDec.Close();
|
|
m_pContext->m_Dialog[0] = 0;
|
|
closesocket(m_pContext->m_Socket);
|
|
|
|
::ReleaseDC(m_hWnd, m_hCurrWndDC);
|
|
::DeleteDC(m_hLastMemDC);
|
|
::DeleteObject(m_hLastBitmap);
|
|
DeleteCriticalSection(&m_cs);
|
|
|
|
if (m_lpvRectBits)
|
|
delete[] m_lpvRectBits;
|
|
if (m_lpbmi_rect)
|
|
delete[] m_lpbmi_rect;
|
|
if (m_lpbmi_full)
|
|
delete[] m_lpbmi_full;
|
|
SetClassLong(m_hWnd, GCL_HCURSOR, (LONG)LoadCursor(NULL, IDC_ARROW));
|
|
|
|
m_bIsCtrl = false;
|
|
ClipCursor(NULL);
|
|
DestroyWindow();
|
|
}
|
|
|
|
void CScreenSpyDlg::DoDataExchange(CDataExchange* pDX)
|
|
{
|
|
CDialog::DoDataExchange(pDX);
|
|
//{{AFX_DATA_MAP(CScreenSpy)
|
|
// NOTE: the ClassWizard will add DDX and DDV calls here
|
|
//}}AFX_DATA_MAP
|
|
}
|
|
|
|
BEGIN_MESSAGE_MAP(CScreenSpyDlg, CDialog)
|
|
//{{AFX_MSG_MAP(CScreenSpy)
|
|
ON_WM_NCLBUTTONDBLCLK()
|
|
ON_WM_SYSCOMMAND()
|
|
ON_WM_PAINT()
|
|
ON_MESSAGE(WM_SIZING, OnSizing)
|
|
ON_WM_SIZE()
|
|
ON_WM_CLOSE()
|
|
ON_WM_HSCROLL()
|
|
ON_WM_VSCROLL()
|
|
ON_WM_GETMINMAXINFO()
|
|
ON_MESSAGE(WM_MOVING, OnMoving)
|
|
ON_WM_MOVE()
|
|
//}}AFX_MSG_MAP
|
|
END_MESSAGE_MAP()
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// CScreenSpy message handlers
|
|
|
|
void CScreenSpyDlg::OnReceiveComplete()
|
|
{
|
|
switch (m_pContext->m_DeCompressionBuffer.GetBuffer(0)[0])
|
|
{
|
|
case TOKEN_FIRSTSCREEN:
|
|
DrawFirstScreen();
|
|
break;
|
|
case TOKEN_NEXTSCREEN:
|
|
// 计算帧率(FPS)
|
|
++m_nFramesCount;
|
|
if (m_pContext->m_DeCompressionBuffer.GetBuffer(0)[1] == ALGORITHM_HOME)
|
|
DrawNextScreenHome();
|
|
else
|
|
DrawNextScreenXvid();
|
|
break;
|
|
case TOKEN_BITMAPINFO:
|
|
ResetScreen();
|
|
break;
|
|
case TOKEN_CLIPBOARD_TEXT:
|
|
UpdateLocalClipboard((char *)m_pContext->m_DeCompressionBuffer.GetBuffer(1), m_pContext->m_DeCompressionBuffer.GetBufferLen() - 1);
|
|
break;
|
|
default:
|
|
// 传输发生异常数据
|
|
return;
|
|
}
|
|
}
|
|
|
|
bool CScreenSpyDlg::SaveSnapshot()
|
|
{
|
|
CString strFileName = m_IPAddress + CTime::GetCurrentTime().Format(_T("_%Y-%m-%d_%H-%M-%S.bmp"));
|
|
CFileDialog dlg(FALSE, _T("bmp"), strFileName, OFN_OVERWRITEPROMPT, _T("位图文件(*.bmp)|*.bmp|"), this);
|
|
if(dlg.DoModal () != IDOK)
|
|
return false;
|
|
|
|
BITMAPFILEHEADER hdr;
|
|
LPBITMAPINFO lpbi = m_lpbmi_full;
|
|
CFile file;
|
|
if (!file.Open( dlg.GetPathName(), CFile::modeWrite | CFile::modeCreate))
|
|
{
|
|
MessageBox("文件保存失败");
|
|
return false;
|
|
}
|
|
|
|
// BITMAPINFO大小
|
|
int nbmiSize = sizeof(BITMAPINFOHEADER) + (lpbi->bmiHeader.biBitCount > 16 ? 1 : (1 << lpbi->bmiHeader.biBitCount)) * sizeof(RGBQUAD);
|
|
|
|
// Fill in the fields of the file header
|
|
hdr.bfType = ((WORD) ('M' << 8) | 'B'); // is always "BM"
|
|
hdr.bfSize = lpbi->bmiHeader.biSizeImage + sizeof(hdr);
|
|
hdr.bfReserved1 = 0;
|
|
hdr.bfReserved2 = 0;
|
|
hdr.bfOffBits = sizeof(hdr) + nbmiSize;
|
|
// Write the file header
|
|
file.Write(&hdr, sizeof(hdr));
|
|
file.Write(lpbi, nbmiSize);
|
|
// Write the DIB header and the bits
|
|
file.Write(m_lpvLastBits, lpbi->bmiHeader.biSizeImage);
|
|
file.Close();
|
|
|
|
return true;
|
|
}
|
|
|
|
DWORD WINAPI CScreenSpyDlg::ShowFPSThread(LPVOID lpParam)
|
|
{
|
|
CScreenSpyDlg *pThis = (CScreenSpyDlg *)lpParam;
|
|
if (pThis->m_pContext == NULL)
|
|
return -1;
|
|
|
|
while (TRUE)
|
|
{
|
|
CString str; Sleep(1000);
|
|
str.Format(_T("\\\\%s (%d * %d) FPS-%d %d%%"), pThis->m_IPAddress, pThis->m_lpbmi_full->bmiHeader.biWidth,
|
|
pThis->m_lpbmi_full->bmiHeader.biHeight, pThis->m_nFramesPerSecond, pThis->m_pContext->m_nTransferProgress);
|
|
pThis->SetWindowText(str);
|
|
pThis->m_nFramesPerSecond = pThis->m_nFramesCount;
|
|
pThis->m_nFramesCount = 0;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
void CScreenSpyDlg::OnReceive()
|
|
{
|
|
if (m_pContext == NULL)
|
|
return;
|
|
|
|
CString str; DWORD_PTR dwResult;
|
|
str.Format(_T("\\\\%s (%d * %d) FPS-%d %d%%"), m_IPAddress, m_lpbmi_full->bmiHeader.biWidth, m_lpbmi_full->bmiHeader.biHeight,
|
|
m_nFramesPerSecond, m_pContext->m_nTransferProgress);
|
|
SendMessageTimeout(GetSafeHwnd(), WM_SETTEXT, NULL, (LPARAM)str.GetBuffer(0), SMTO_ABORTIFHUNG|SMTO_BLOCK, 500, &dwResult);
|
|
}
|
|
|
|
void CScreenSpyDlg::SendResetScreen(int nBitCount)
|
|
{
|
|
BYTE bBuff[2];
|
|
bBuff[0] = COMMAND_SCREEN_RESET;
|
|
bBuff[1] = nBitCount;
|
|
m_iocpServer->Send(m_pContext, bBuff, sizeof(bBuff));
|
|
}
|
|
|
|
void CScreenSpyDlg::SendResetAlgorithm(UINT nAlgorithm)
|
|
{
|
|
BYTE bBuff[2];
|
|
bBuff[0] = COMMAND_ALGORITHM_RESET;
|
|
bBuff[1] = nAlgorithm;
|
|
m_iocpServer->Send(m_pContext, bBuff, sizeof(bBuff));
|
|
}
|
|
|
|
BOOL CScreenSpyDlg::OnInitDialog()
|
|
{
|
|
CDialog::OnInitDialog();
|
|
|
|
// Set the icon for this dialog. The framework does this automatically
|
|
// when the application's main window is not a dialog
|
|
SetIcon(m_hIcon, TRUE); // Set big icon
|
|
SetIcon(m_hIcon, FALSE); // Set small icon
|
|
|
|
SetClassLong(m_hWnd, GCL_HCURSOR, (LONG)LoadCursor(NULL, IDC_NO));
|
|
CMenu* pSysMenu = GetSystemMenu(FALSE);
|
|
if (pSysMenu != NULL)
|
|
{
|
|
pSysMenu->AppendMenu(MF_SEPARATOR);
|
|
pSysMenu->AppendMenu(MF_STRING, IDM_CONTROL, "控制屏幕(&C)");
|
|
pSysMenu->AppendMenu(MF_STRING, IDM_TOPMOST, "屏幕窗口置顶(&T)");
|
|
pSysMenu->AppendMenu(MF_STRING, IDM_CTRL_ALT_DEL, "发送Ctrl+Alt+Del(&K)");
|
|
pSysMenu->AppendMenu(MF_STRING, IDM_TRACE_CURSOR, "跟踪服务端鼠标(&F)");
|
|
pSysMenu->AppendMenu(MF_STRING, IDM_BLOCK_INPUT, "锁定服务端鼠标和键盘(&O)");
|
|
pSysMenu->AppendMenu(MF_STRING, IDM_BLANK_SCREEN, "服务端黑屏(&B)");
|
|
pSysMenu->AppendMenu(MF_STRING, IDM_CAPTURE_LAYER, "捕捉层(导致鼠标闪烁)(&L)");
|
|
pSysMenu->AppendMenu(MF_STRING, IDM_SAVEDIB, "保存快照(&S)");
|
|
pSysMenu->AppendMenu(MF_SEPARATOR);
|
|
pSysMenu->AppendMenu(MF_STRING, IDM_GET_CLIPBOARD, "获取剪贴板(&G)");
|
|
pSysMenu->AppendMenu(MF_STRING, IDM_SET_CLIPBOARD, "设置剪贴板(&P)");
|
|
pSysMenu->AppendMenu(MF_SEPARATOR);
|
|
pSysMenu->AppendMenu(MF_STRING, IDM_AERO_DISABLE, "禁用桌面合成(&D)");
|
|
pSysMenu->AppendMenu(MF_STRING, IDM_AERO_ENABLE, "启用桌面合成(&E)");
|
|
pSysMenu->AppendMenu(MF_SEPARATOR);
|
|
pSysMenu->AppendMenu(MF_STRING, IDM_ALGORITHM_HOME, "家用办公算法(&H)");
|
|
pSysMenu->AppendMenu(MF_STRING, IDM_ALGORITHM_XVID, "影视娱乐算法(&X)");
|
|
pSysMenu->AppendMenu(MF_SEPARATOR);
|
|
pSysMenu->AppendMenu(MF_STRING|MF_GRAYED, IDM_DEEP_16, "16位增强颜色(&U)");
|
|
pSysMenu->AppendMenu(MF_STRING, IDM_DEEP_32, "32位真彩颜色(&R)");
|
|
|
|
pSysMenu->CheckMenuRadioItem(IDM_ALGORITHM_HOME, IDM_ALGORITHM_XVID, IDM_ALGORITHM_HOME, MF_BYCOMMAND);
|
|
pSysMenu->CheckMenuRadioItem(IDM_DEEP_16, IDM_DEEP_32, IDM_DEEP_32, MF_BYCOMMAND);
|
|
}
|
|
|
|
// TODO: Add extra initialization here
|
|
CString str;
|
|
str.Format(_T("\\\\%s (%d * %d)"), m_IPAddress, m_lpbmi_full->bmiHeader.biWidth, m_lpbmi_full->bmiHeader.biHeight);
|
|
SetWindowText(str);
|
|
|
|
ImmAssociateContext(m_hWnd, NULL);
|
|
m_hRemoteCursor = LoadCursor(NULL, IDC_ARROW);
|
|
|
|
m_LastCursorPos.x = 0;
|
|
m_LastCursorPos.y = 0;
|
|
m_bIsTraceCursor = false;
|
|
|
|
// 初始化窗口大小结构
|
|
m_hCurrWndDC = ::GetDC(m_hWnd);
|
|
m_hLastMemDC = ::CreateCompatibleDC(m_hCurrWndDC);
|
|
m_hLastBitmap = ::CreateDIBSection(m_hCurrWndDC, m_lpbmi_full, DIB_RGB_COLORS, &m_lpvLastBits, NULL, NULL);
|
|
m_lpvRectBits = new BYTE[m_lpbmi_rect->bmiHeader.biSizeImage];
|
|
SelectObject(m_hLastMemDC, m_hLastBitmap);
|
|
|
|
SendNext();
|
|
return TRUE; // return TRUE unless you set the focus to a control
|
|
// EXCEPTION: OCX Property Pages should return FALSE
|
|
}
|
|
|
|
void CScreenSpyDlg::FullScreen()
|
|
{
|
|
LONG style = ::GetWindowLong(this->m_hWnd, GWL_STYLE);
|
|
|
|
if(!m_bIsFullScreen) //全屏显示
|
|
{
|
|
APPBARDATA abd;
|
|
memset(&abd, 0, sizeof(abd));
|
|
abd.cbSize = sizeof(abd);
|
|
int nMaxWindowWidth, nMaxWindowHeight;
|
|
UINT_PTR uState = SHAppBarMessage(ABM_GETSTATE, &abd);
|
|
SHAppBarMessage(ABM_GETTASKBARPOS, &abd);
|
|
if (abd.uEdge == 0) // 任务栏在左
|
|
{
|
|
nMaxWindowWidth = GetSystemMetrics(SM_CXSCREEN) - (uState == ABS_AUTOHIDE ? 0 : abd.rc.right);
|
|
nMaxWindowHeight = GetSystemMetrics(SM_CYSCREEN);
|
|
}
|
|
if (abd.uEdge == 1) // 任务栏在上
|
|
{
|
|
nMaxWindowWidth = GetSystemMetrics(SM_CXSCREEN);
|
|
nMaxWindowHeight = GetSystemMetrics(SM_CYSCREEN) - (uState == ABS_AUTOHIDE ? 0 : abd.rc.bottom);
|
|
}
|
|
if (abd.uEdge == 2) // 任务栏在右
|
|
{
|
|
nMaxWindowWidth = GetSystemMetrics(SM_CXSCREEN) - (uState == ABS_AUTOHIDE ? 0 : abd.rc.right - abd.rc.left);
|
|
nMaxWindowHeight = GetSystemMetrics(SM_CYSCREEN);
|
|
}
|
|
if (abd.uEdge == 3) // 任务栏在下
|
|
{
|
|
nMaxWindowWidth = GetSystemMetrics(SM_CXSCREEN);
|
|
nMaxWindowHeight = GetSystemMetrics(SM_CYSCREEN) - (uState == ABS_AUTOHIDE ? 0 : abd.rc.bottom - abd.rc.top);
|
|
}
|
|
|
|
RECT rectWindow, rectClient;
|
|
GetWindowRect(&rectWindow);
|
|
GetClientRect(&rectClient);
|
|
ClientToScreen(&rectClient);
|
|
|
|
int nBorderSize = rectClient.left - rectWindow.left; // 单边框的大小(宽度或高度)
|
|
int nTitleHeight = rectClient.top - rectWindow.top - nBorderSize; // 标题栏的高度
|
|
int nMaxClientWidth = nMaxWindowWidth - nBorderSize * 2;
|
|
int nMaxClientHeight = nMaxWindowHeight - nTitleHeight - nBorderSize * 2;
|
|
|
|
if (nMaxClientWidth >= m_lpbmi_full->bmiHeader.biWidth && nMaxClientHeight >= m_lpbmi_full->bmiHeader.biHeight)
|
|
{
|
|
OnNcLButtonDblClk(HTCAPTION, NULL);
|
|
return;
|
|
}
|
|
|
|
GetWindowRect(&m_rcRestore);
|
|
style &= ~(WS_DLGFRAME | WS_THICKFRAME);
|
|
SetWindowLong(this->m_hWnd, GWL_STYLE, style);
|
|
|
|
if (m_lpbmi_full->bmiHeader.biWidth < GetSystemMetrics(SM_CXSCREEN) &&
|
|
m_lpbmi_full->bmiHeader.biHeight < GetSystemMetrics(SM_CYSCREEN))
|
|
{
|
|
MoveWindow(
|
|
(GetSystemMetrics(SM_CXSCREEN) - m_lpbmi_full->bmiHeader.biWidth) / 2,
|
|
(GetSystemMetrics(SM_CYSCREEN) - m_lpbmi_full->bmiHeader.biHeight) / 2,
|
|
m_lpbmi_full->bmiHeader.biWidth, m_lpbmi_full->bmiHeader.biHeight);
|
|
}
|
|
else if (m_lpbmi_full->bmiHeader.biWidth < GetSystemMetrics(SM_CXSCREEN))
|
|
{
|
|
MoveWindow((GetSystemMetrics(SM_CXSCREEN) - m_lpbmi_full->bmiHeader.biWidth) / 2, 0,
|
|
m_lpbmi_full->bmiHeader.biWidth, GetSystemMetrics(SM_CYSCREEN));
|
|
}
|
|
else if (m_lpbmi_full->bmiHeader.biHeight < GetSystemMetrics(SM_CYSCREEN))
|
|
{
|
|
MoveWindow(0, (GetSystemMetrics(SM_CYSCREEN) - m_lpbmi_full->bmiHeader.biHeight) / 2,
|
|
GetSystemMetrics(SM_CXSCREEN), m_lpbmi_full->bmiHeader.biHeight);
|
|
}
|
|
else
|
|
{
|
|
MoveWindow(0, 0, GetSystemMetrics(SM_CXSCREEN), GetSystemMetrics(SM_CYSCREEN));
|
|
}
|
|
|
|
m_bIsFullScreen = true; // 设置全屏显示标志
|
|
SendMessage(WM_ACTIVATE, MAKEWPARAM(WA_ACTIVE, FALSE), NULL);
|
|
}
|
|
else // 窗口显示
|
|
{
|
|
style |= WS_DLGFRAME | WS_THICKFRAME;
|
|
SetWindowLong(this->m_hWnd, GWL_STYLE, style);
|
|
OnNcLButtonDblClk(HTCAPTION, NULL);
|
|
CMenu* pSysMenu = GetSystemMenu(FALSE);
|
|
if (!(pSysMenu->GetMenuState(IDM_TOPMOST, MF_BYCOMMAND) & MF_CHECKED))
|
|
{
|
|
SendMessage(WM_ACTIVATE, MAKEWPARAM(WA_INACTIVE, FALSE), NULL);
|
|
}
|
|
m_bIsFullScreen = false; // 取消全屏显示标志
|
|
}
|
|
}
|
|
|
|
void CScreenSpyDlg::ResetScreen()
|
|
{
|
|
UINT nBitmapInfoSize = m_pContext->m_DeCompressionBuffer.GetBufferLen() - 1;
|
|
if (m_lpbmi_full != NULL)
|
|
{
|
|
int nOldWidth = m_lpbmi_full->bmiHeader.biWidth;
|
|
int nOldHeight = m_lpbmi_full->bmiHeader.biHeight;
|
|
|
|
delete[] m_lpbmi_full;
|
|
delete[] m_lpbmi_rect;
|
|
m_lpbmi_full = (BITMAPINFO *) new BYTE[nBitmapInfoSize];
|
|
m_lpbmi_rect = (BITMAPINFO *) new BYTE[nBitmapInfoSize];
|
|
memcpy(m_lpbmi_full, m_pContext->m_DeCompressionBuffer.GetBuffer(1), nBitmapInfoSize);
|
|
memcpy(m_lpbmi_rect, m_pContext->m_DeCompressionBuffer.GetBuffer(1), nBitmapInfoSize);
|
|
|
|
DeleteObject(m_hLastBitmap);
|
|
m_hLastBitmap = CreateDIBSection(m_hCurrWndDC, m_lpbmi_full, DIB_RGB_COLORS, &m_lpvLastBits, NULL, NULL);
|
|
if (m_lpvRectBits)
|
|
{
|
|
delete[] m_lpvRectBits;
|
|
m_lpvRectBits = new BYTE[m_lpbmi_rect->bmiHeader.biSizeImage];
|
|
}
|
|
SelectObject(m_hLastMemDC, m_hLastBitmap);
|
|
|
|
m_XvidDec.Close();
|
|
m_XvidDec.Open(m_lpbmi_full->bmiHeader.biWidth, m_lpbmi_full->bmiHeader.biHeight, m_lpbmi_full->bmiHeader.biBitCount);
|
|
|
|
// 分辨率发生改变
|
|
if (nOldWidth != m_lpbmi_full->bmiHeader.biWidth || nOldHeight != m_lpbmi_full->bmiHeader.biHeight)
|
|
{
|
|
if (m_bIsFullScreen)
|
|
{
|
|
FullScreen();
|
|
FullScreen();
|
|
}
|
|
else
|
|
{
|
|
memset(&m_rcRestore, 0, sizeof(m_rcRestore));
|
|
OnNcLButtonDblClk(HTCAPTION, NULL);
|
|
memset(&m_rcRestore, 0, sizeof(m_rcRestore));
|
|
}
|
|
if (GetKeyState(VK_SCROLL) & 0x0001)
|
|
{
|
|
CRect ClientRect;
|
|
GetClientRect(ClientRect);
|
|
ClientToScreen(ClientRect);
|
|
ClipCursor(ClientRect);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CScreenSpyDlg::DrawFirstScreen()
|
|
{
|
|
bool bIsReDraw = false;
|
|
BYTE algorithm = m_pContext->m_DeCompressionBuffer.GetBuffer(0)[1];
|
|
LPVOID lpFirstScreen = m_pContext->m_DeCompressionBuffer.GetBuffer(2);
|
|
DWORD dwFirstLength = m_pContext->m_DeCompressionBuffer.GetBufferLen() - 2;
|
|
|
|
if (algorithm == ALGORITHM_HOME && dwFirstLength > 0)
|
|
{
|
|
if (JPG_BMP(m_lpbmi_full->bmiHeader.biBitCount, lpFirstScreen, dwFirstLength, m_lpvLastBits))
|
|
bIsReDraw = true;
|
|
}
|
|
else if (algorithm == ALGORITHM_XVID && dwFirstLength > 0)
|
|
{
|
|
if (m_XvidDec.Decode(lpFirstScreen, dwFirstLength, m_lpvLastBits) > 0)
|
|
bIsReDraw = true;
|
|
}
|
|
m_bIsFirst = false;
|
|
|
|
if (bIsReDraw)
|
|
{
|
|
#ifdef _DEBUG
|
|
SendNotifyMessage(WM_PAINT, NULL, NULL);
|
|
#else
|
|
OnPaint();
|
|
#endif // _DEBUG
|
|
}
|
|
}
|
|
|
|
void CScreenSpyDlg::DrawNextScreenHome()
|
|
{
|
|
// 根据鼠标是否移动和屏幕是否变化判断是否重绘鼠标, 防止鼠标闪烁
|
|
bool bIsReDraw = false;
|
|
int nHeadLength = 1 + 1 + sizeof(POINT) + sizeof(BYTE); // 标识[1] + 算法[1] + 光标位置[8] + 光标类型索引[1]
|
|
LPVOID lpNextScreen = m_pContext->m_DeCompressionBuffer.GetBuffer(nHeadLength);
|
|
DWORD dwNextLength = m_pContext->m_DeCompressionBuffer.GetBufferLen() - nHeadLength;
|
|
DWORD dwNextOffset = 0;
|
|
|
|
// 判断鼠标是否移动
|
|
LPPOINT lpNextCursorPos = (LPPOINT)m_pContext->m_DeCompressionBuffer.GetBuffer(2);
|
|
if (memcmp(lpNextCursorPos, &m_LastCursorPos, sizeof(POINT)) != 0 && m_bIsTraceCursor)
|
|
{
|
|
bIsReDraw = true;
|
|
memcpy(&m_LastCursorPos, lpNextCursorPos, sizeof(POINT));
|
|
}
|
|
|
|
// 光标类型发生变化
|
|
LPBYTE lpNextCursorIndex = m_pContext->m_DeCompressionBuffer.GetBuffer(10);
|
|
if (*lpNextCursorIndex != m_LastCursorIndex)
|
|
{
|
|
m_LastCursorIndex = *lpNextCursorIndex;
|
|
if (m_bIsTraceCursor)
|
|
bIsReDraw = true;
|
|
if (m_bIsCtrl && !m_bIsTraceCursor)
|
|
{
|
|
HCURSOR hNewCursor = m_CursorInfo.getCursorHandle(m_LastCursorIndex == (BYTE)-1 ? 1 : m_LastCursorIndex);
|
|
SetClassLong(m_hWnd, GCL_HCURSOR, (LONG)hNewCursor);
|
|
}
|
|
}
|
|
|
|
// 屏幕数据是否变化
|
|
while (dwNextOffset < dwNextLength)
|
|
{
|
|
int *pinlen = (int *)((LPBYTE)lpNextScreen + dwNextOffset);
|
|
|
|
if (JPG_BMP(m_lpbmi_full->bmiHeader.biBitCount, pinlen + 1, *pinlen, m_lpvRectBits))
|
|
{
|
|
bIsReDraw = true;
|
|
LPRECT lpChangedRect = (LPRECT)((LPBYTE)(pinlen + 1) + *pinlen);
|
|
int nChangedRectWidth = lpChangedRect->right - lpChangedRect->left;
|
|
int nChangedRectHeight = lpChangedRect->bottom - lpChangedRect->top;
|
|
|
|
m_lpbmi_rect->bmiHeader.biWidth = nChangedRectWidth;
|
|
m_lpbmi_rect->bmiHeader.biHeight = nChangedRectHeight;
|
|
m_lpbmi_rect->bmiHeader.biSizeImage = (((nChangedRectWidth * m_lpbmi_rect->bmiHeader.biBitCount + 31) & ~31) >> 3)
|
|
* nChangedRectHeight;
|
|
|
|
EnterCriticalSection(&m_cs);
|
|
StretchDIBits(m_hLastMemDC, lpChangedRect->left, lpChangedRect->top, nChangedRectWidth, nChangedRectHeight,
|
|
0, 0, nChangedRectWidth, nChangedRectHeight, m_lpvRectBits, m_lpbmi_rect, DIB_RGB_COLORS, SRCCOPY);
|
|
LeaveCriticalSection(&m_cs);
|
|
|
|
dwNextOffset += sizeof(int) + *pinlen + sizeof(RECT);
|
|
}
|
|
}
|
|
|
|
if (bIsReDraw)
|
|
{
|
|
#ifdef _DEBUG
|
|
SendNotifyMessage(WM_PAINT, NULL, NULL);
|
|
#else
|
|
OnPaint();
|
|
#endif // _DEBUG
|
|
}
|
|
}
|
|
|
|
bool CScreenSpyDlg::JPG_BMP(int cbit, void *input, int inlen, void *output)
|
|
{
|
|
struct jpeg_decompress_struct jds;
|
|
struct jpeg_error_mgr jem;
|
|
|
|
// 设置错误处理
|
|
jds.err = jpeg_std_error(&jem);
|
|
// 创建解压结构
|
|
jpeg_create_decompress(&jds);
|
|
// 设置读取(输入)位置
|
|
jpeg_mem_src(&jds, (byte *)input, inlen);
|
|
// 读取头部信息
|
|
if (jpeg_read_header(&jds, true) != JPEG_HEADER_OK)
|
|
{
|
|
jpeg_destroy_decompress(&jds);
|
|
return false;
|
|
}
|
|
// 设置相关参数
|
|
switch (cbit)
|
|
{
|
|
case 16:
|
|
jds.out_color_space = JCS_EXT_RGB;
|
|
break;
|
|
case 24:
|
|
jds.out_color_space = JCS_EXT_BGR;
|
|
break;
|
|
case 32:
|
|
jds.out_color_space = JCS_EXT_BGRA;
|
|
break;
|
|
default:
|
|
jpeg_destroy_decompress(&jds);
|
|
return false;
|
|
}
|
|
// 开始解压图像
|
|
if (!jpeg_start_decompress(&jds))
|
|
{
|
|
jpeg_destroy_decompress(&jds);
|
|
return false;
|
|
}
|
|
int line_stride = (jds.output_width * cbit / 8 + 3) / 4 * 4;
|
|
while (jds.output_scanline < jds.output_height)
|
|
{
|
|
byte* pline = (byte*)output + jds.output_scanline * line_stride;
|
|
jpeg_read_scanlines(&jds, &pline, 1);
|
|
}
|
|
// 完成图像解压
|
|
if (!jpeg_finish_decompress(&jds))
|
|
{
|
|
jpeg_destroy_decompress(&jds);
|
|
return false;
|
|
}
|
|
// 释放相关资源
|
|
jpeg_destroy_decompress(&jds);
|
|
|
|
return true;
|
|
}
|
|
|
|
void CScreenSpyDlg::DrawNextScreenXvid()
|
|
{
|
|
// 根据鼠标是否移动和屏幕是否变化判断是否重绘鼠标, 防止鼠标闪烁
|
|
bool bIsReDraw = false;
|
|
int nHeadLength = 1 + 1 + sizeof(POINT) + sizeof(BYTE); // 标识[1] + 算法[1] + 光标位置[8] + 光标类型索引[1]
|
|
LPVOID lpLastScreen = m_lpvLastBits;
|
|
LPVOID lpNextScreen = m_pContext->m_DeCompressionBuffer.GetBuffer(nHeadLength);
|
|
DWORD dwNextLength = m_pContext->m_DeCompressionBuffer.GetBufferLen() - nHeadLength;
|
|
|
|
// 判断鼠标是否移动
|
|
LPPOINT lpNextCursorPos = (LPPOINT)m_pContext->m_DeCompressionBuffer.GetBuffer(2);
|
|
if (memcmp(lpNextCursorPos, &m_LastCursorPos, sizeof(POINT)) != 0 && m_bIsTraceCursor)
|
|
{
|
|
bIsReDraw = true;
|
|
memcpy(&m_LastCursorPos, lpNextCursorPos, sizeof(POINT));
|
|
}
|
|
|
|
// 光标类型发生变化
|
|
LPBYTE lpNextCursorIndex = m_pContext->m_DeCompressionBuffer.GetBuffer(10);
|
|
if (*lpNextCursorIndex != m_LastCursorIndex)
|
|
{
|
|
m_LastCursorIndex = *lpNextCursorIndex;
|
|
if (m_bIsTraceCursor)
|
|
bIsReDraw = true;
|
|
if (m_bIsCtrl && !m_bIsTraceCursor)
|
|
{
|
|
HCURSOR hNewCursor = m_CursorInfo.getCursorHandle(m_LastCursorIndex == (BYTE)-1 ? 1 : m_LastCursorIndex);
|
|
SetClassLong(m_hWnd, GCL_HCURSOR, (LONG)hNewCursor);
|
|
}
|
|
}
|
|
|
|
// 屏幕数据是否变化
|
|
if (dwNextLength > 0)
|
|
{
|
|
bIsReDraw = true;
|
|
m_XvidDec.Decode(lpNextScreen, dwNextLength, lpLastScreen);
|
|
}
|
|
|
|
if (bIsReDraw)
|
|
{
|
|
#ifdef _DEBUG
|
|
SendNotifyMessage(WM_PAINT, NULL, NULL);
|
|
#else
|
|
OnPaint();
|
|
#endif // _DEBUG
|
|
}
|
|
}
|
|
|
|
void CScreenSpyDlg::OnPaint()
|
|
{
|
|
// TODO: Add your message handler code here
|
|
CPaintDC dc(this); // device context for painting
|
|
RECT rect;
|
|
GetClientRect(&rect);
|
|
|
|
if (m_bIsFirst)
|
|
{
|
|
DrawTipString(_T("Please wait - initial screen loading"));
|
|
return;
|
|
}
|
|
|
|
//int iHScrollPos = GetScrollPos(SB_HORZ);
|
|
//int iVScrollPos = GetScrollPos(SB_VERT);
|
|
EnterCriticalSection(&m_cs);
|
|
// BitBlt(m_hCurrWndDC, 0, 0, m_lpbmi_full->bmiHeader.biWidth, m_lpbmi_full->bmiHeader.biHeight, m_hLastMemDC, 0, 0, SRCCOPY);
|
|
SetStretchBltMode(m_hCurrWndDC,STRETCH_HALFTONE);
|
|
LPBITMAPINFO lpbi = m_lpbmi_full;
|
|
StretchDIBits
|
|
(
|
|
|
|
m_hCurrWndDC,
|
|
0, 0, rect.right, rect.bottom,
|
|
0, 0, m_lpbmi_full->bmiHeader.biWidth, m_lpbmi_full->bmiHeader.biHeight,
|
|
(LPBYTE)m_lpvLastBits,
|
|
lpbi,
|
|
DIB_RGB_COLORS,
|
|
SRCCOPY
|
|
);
|
|
|
|
|
|
LeaveCriticalSection(&m_cs);
|
|
|
|
// (BYTE)-1 = 255;
|
|
// Draw the cursor
|
|
if (m_bIsTraceCursor)
|
|
{
|
|
DrawIconEx(
|
|
m_hCurrWndDC, // handle to device context
|
|
0, // x-coord of upper left corner
|
|
0, // y-coord of upper left corner
|
|
m_CursorInfo.getCursorHandle(m_LastCursorIndex == (BYTE)-1 ? 1 : m_LastCursorIndex), // handle to icon to draw
|
|
0,0, // width of the icon
|
|
0, // index of frame in animated cursor
|
|
NULL, // handle to background brush
|
|
DI_NORMAL | DI_COMPAT // icon-drawing flags
|
|
);
|
|
}
|
|
|
|
// Do not call CDialog::OnPaint() for painting messages
|
|
}
|
|
|
|
LRESULT CScreenSpyDlg::OnSizing(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
if (m_rcRestore.right && m_rcRestore.bottom)
|
|
memset(&m_rcRestore, 0, sizeof(m_rcRestore));
|
|
return FALSE;
|
|
}
|
|
|
|
void CScreenSpyDlg::OnSize(UINT nType, int cx, int cy)
|
|
{
|
|
//CDialog::OnSize(nType, cx, cy);
|
|
|
|
// TODO: Add your message handler code here
|
|
if (!GetSafeHwnd())
|
|
return;
|
|
|
|
SCROLLINFO si;
|
|
memset(&si, 0, sizeof(si));
|
|
si.cbSize = sizeof(SCROLLINFO);
|
|
si.fMask = SIF_PAGE|SIF_RANGE;
|
|
si.nPage = 1;
|
|
si.nMin = 0;
|
|
|
|
SCROLLBARINFO sbiv, sbih;
|
|
sbiv.cbSize = sizeof(SCROLLBARINFO);
|
|
sbih.cbSize = sizeof(SCROLLBARINFO);
|
|
GetScrollBarInfo(m_hWnd, OBJID_VSCROLL, &sbiv);
|
|
GetScrollBarInfo(m_hWnd, OBJID_HSCROLL, &sbih);
|
|
sbiv.dxyLineButton = sbiv.rgstate[0] & STATE_SYSTEM_INVISIBLE ? 0 : sbiv.dxyLineButton;
|
|
sbih.dxyLineButton = sbih.rgstate[0] & STATE_SYSTEM_INVISIBLE ? 0 : sbih.dxyLineButton;
|
|
// 根据客户区大小, 调整水平滚动条和垂直滚动条的状态
|
|
if (cx >= m_lpbmi_full->bmiHeader.biWidth)
|
|
ShowScrollBar(SB_HORZ, FALSE);
|
|
else
|
|
{
|
|
si.nMax = m_lpbmi_full->bmiHeader.biWidth - cx;
|
|
SetScrollInfo(SB_HORZ, &si, TRUE);
|
|
}
|
|
if (cy >= m_lpbmi_full->bmiHeader.biHeight)
|
|
ShowScrollBar(SB_VERT, FALSE);
|
|
else
|
|
{
|
|
SCROLLBARINFO sbit;
|
|
sbit.cbSize = sizeof(SCROLLBARINFO);
|
|
GetScrollBarInfo(m_hWnd, OBJID_HSCROLL, &sbit);
|
|
si.nMax = m_lpbmi_full->bmiHeader.biHeight - cy - (sbit.rgstate[0] & STATE_SYSTEM_INVISIBLE ? sbih.dxyLineButton : 0);
|
|
SetScrollInfo(SB_VERT, &si, TRUE);
|
|
}
|
|
// 客户区宽度+垂直滚动条宽度>=分辨率宽度 && 客户区高度+水平滚动条高度>=分辨率高度
|
|
if (cx + sbiv.dxyLineButton >= m_lpbmi_full->bmiHeader.biWidth && cy + sbih.dxyLineButton >= m_lpbmi_full->bmiHeader.biHeight)
|
|
{
|
|
ShowScrollBar(SB_BOTH, FALSE);
|
|
}
|
|
// 水平滚动条不可见时, 窗口宽度增加一个垂直滚动条的宽度
|
|
if (sbih.rgstate[0] & STATE_SYSTEM_INVISIBLE && !m_rcRestore.right && !m_rcRestore.bottom)
|
|
{
|
|
RECT rectWindow;
|
|
GetWindowRect(&rectWindow);
|
|
rectWindow.right += sbiv.dxyLineButton;
|
|
MoveWindow(&rectWindow);
|
|
}
|
|
// 垂直滚动条不可见时, 窗口高度增加一个水平滚动条的高度
|
|
if (sbiv.rgstate[0] & STATE_SYSTEM_INVISIBLE && !m_rcRestore.right && !m_rcRestore.bottom)
|
|
{
|
|
RECT rectWindow;
|
|
GetWindowRect(&rectWindow);
|
|
rectWindow.bottom += sbih.dxyLineButton;
|
|
MoveWindow(&rectWindow);
|
|
}
|
|
|
|
if (GetScrollPos(SB_HORZ) + cx > m_lpbmi_full->bmiHeader.biWidth)
|
|
SetScrollPos(SB_HORZ, m_lpbmi_full->bmiHeader.biWidth - cx);
|
|
if (GetScrollPos(SB_VERT) + cy > m_lpbmi_full->bmiHeader.biHeight)
|
|
SetScrollPos(SB_VERT, m_lpbmi_full->bmiHeader.biHeight - cy);
|
|
}
|
|
|
|
void CScreenSpyDlg::OnNcLButtonDblClk(UINT nHitTest, CPoint point)
|
|
{
|
|
if (nHitTest == HTCAPTION)
|
|
{
|
|
RECT rectClient;
|
|
if (m_rcRestore.right && m_rcRestore.bottom)
|
|
{
|
|
MoveWindow(&m_rcRestore);
|
|
memset(&m_rcRestore, 0, sizeof(m_rcRestore));
|
|
// 必须OnSize一次, 否则滚动条显示有点问题
|
|
GetClientRect(&rectClient);
|
|
OnSize(0, rectClient.right, rectClient.bottom);
|
|
return;
|
|
}
|
|
|
|
APPBARDATA abd;
|
|
memset(&abd, 0, sizeof(abd));
|
|
abd.cbSize = sizeof(abd);
|
|
int nMinX, nMinY, nMaxWindowWidth, nMaxWindowHeight;
|
|
UINT_PTR uState = SHAppBarMessage(ABM_GETSTATE, &abd);
|
|
SHAppBarMessage(ABM_GETTASKBARPOS, &abd);
|
|
if (abd.uEdge == 0) // 任务栏在左
|
|
{
|
|
nMinX = uState == ABS_AUTOHIDE ? 0 : abd.rc.right;
|
|
nMinY = 0;
|
|
nMaxWindowWidth = GetSystemMetrics(SM_CXSCREEN) - (uState == ABS_AUTOHIDE ? 0 : abd.rc.right);
|
|
nMaxWindowHeight = GetSystemMetrics(SM_CYSCREEN);
|
|
}
|
|
if (abd.uEdge == 1) // 任务栏在上
|
|
{
|
|
nMinX = 0;
|
|
nMinY = uState == ABS_AUTOHIDE ? 0 : abd.rc.bottom;
|
|
nMaxWindowWidth = GetSystemMetrics(SM_CXSCREEN);
|
|
nMaxWindowHeight = GetSystemMetrics(SM_CYSCREEN) - (uState == ABS_AUTOHIDE ? 0 : abd.rc.bottom);
|
|
}
|
|
if (abd.uEdge == 2) // 任务栏在右
|
|
{
|
|
nMinX = 0;
|
|
nMinY = 0;
|
|
nMaxWindowWidth = GetSystemMetrics(SM_CXSCREEN) - (uState == ABS_AUTOHIDE ? 0 : abd.rc.right - abd.rc.left);
|
|
nMaxWindowHeight = GetSystemMetrics(SM_CYSCREEN);
|
|
}
|
|
if (abd.uEdge == 3) // 任务栏在下
|
|
{
|
|
nMinX = 0;
|
|
nMinY = 0;
|
|
nMaxWindowWidth = GetSystemMetrics(SM_CXSCREEN);
|
|
nMaxWindowHeight = GetSystemMetrics(SM_CYSCREEN) - (uState == ABS_AUTOHIDE ? 0 : abd.rc.bottom - abd.rc.top);
|
|
}
|
|
|
|
GetWindowRect(&m_rcRestore);
|
|
GetClientRect(&rectClient);
|
|
ClientToScreen(&rectClient);
|
|
|
|
int nBorderSize = rectClient.left - m_rcRestore.left; // 单边框的大小(宽度或高度)
|
|
int nTitleHeight = rectClient.top - m_rcRestore.top - nBorderSize; // 标题栏的高度
|
|
int nMaxClientWidth = nMaxWindowWidth - nBorderSize * 2;
|
|
int nMaxClientHeight = nMaxWindowHeight - nTitleHeight - nBorderSize * 2;
|
|
|
|
if (m_lpbmi_full->bmiHeader.biWidth < nMaxClientWidth && m_lpbmi_full->bmiHeader.biHeight < nMaxClientHeight)
|
|
{
|
|
int nMovWindowWidth = m_lpbmi_full->bmiHeader.biWidth + nBorderSize * 2;
|
|
int nMovWindowHeight = m_lpbmi_full->bmiHeader.biHeight + nTitleHeight + nBorderSize * 2;
|
|
int x = (nMaxWindowWidth - nMovWindowWidth) / 2 + nMinX;
|
|
int y = (nMaxWindowHeight - nMovWindowHeight) / 2 + nMinY;
|
|
MoveWindow(x, y, nMovWindowWidth, nMovWindowHeight);
|
|
}
|
|
else if (m_lpbmi_full->bmiHeader.biWidth < nMaxClientWidth)
|
|
{
|
|
SCROLLBARINFO sbiv;
|
|
sbiv.cbSize = sizeof(SCROLLBARINFO);
|
|
ShowScrollBar(SB_VERT, TRUE);
|
|
GetScrollBarInfo(m_hWnd, OBJID_VSCROLL, &sbiv);
|
|
int nMovWindowWidth = m_lpbmi_full->bmiHeader.biWidth + nBorderSize * 2;
|
|
if (nMovWindowWidth + sbiv.dxyLineButton <= nMaxWindowWidth)
|
|
nMovWindowWidth += sbiv.dxyLineButton;
|
|
int nMovWindowHeight = nMaxWindowHeight;
|
|
int x = (nMaxWindowWidth - nMovWindowWidth) / 2 + nMinX;
|
|
MoveWindow(x, nMinY, nMovWindowWidth, nMovWindowHeight);
|
|
}
|
|
else if (m_lpbmi_full->bmiHeader.biHeight < nMaxClientHeight)
|
|
{
|
|
SCROLLBARINFO sbih;
|
|
sbih.cbSize = sizeof(SCROLLBARINFO);
|
|
ShowScrollBar(SB_VERT, TRUE);
|
|
GetScrollBarInfo(m_hWnd, OBJID_HSCROLL, &sbih);
|
|
int nMovWindowWidth = nMaxWindowWidth;
|
|
int nMovWindowHeight = m_lpbmi_full->bmiHeader.biHeight + nTitleHeight + nBorderSize * 2;
|
|
if (nMovWindowHeight + sbih.dxyLineButton <= nMaxWindowHeight)
|
|
nMovWindowHeight += sbih.dxyLineButton;
|
|
int y = (nMaxWindowHeight - nMovWindowHeight) / 2 + nMinY;
|
|
MoveWindow(nMinX, y, nMovWindowWidth, nMovWindowHeight);
|
|
}
|
|
else
|
|
{
|
|
int nMovWindowWidth = nMaxWindowWidth;
|
|
int nMovWindowHeight = nMaxWindowHeight;
|
|
MoveWindow(nMinX, nMinY, nMovWindowWidth, nMovWindowHeight);
|
|
}
|
|
// 必须OnSize一次, 否则滚动条显示有点问题
|
|
GetClientRect(&rectClient);
|
|
OnSize(0, rectClient.right, rectClient.bottom);
|
|
return;
|
|
}
|
|
}
|
|
|
|
void CScreenSpyDlg::OnSysCommand(UINT nID, LPARAM lParam)
|
|
{
|
|
CMenu* pSysMenu = GetSystemMenu(FALSE);
|
|
switch (nID)
|
|
{
|
|
case SC_MAXIMIZE:
|
|
OnNcLButtonDblClk(HTCAPTION, NULL);
|
|
return;
|
|
case SC_MONITORPOWER: // 拦截显示器节电自动关闭的消息
|
|
return;
|
|
case SC_SCREENSAVE: // 拦截屏幕保护启动的消息
|
|
return;
|
|
case IDM_CONTROL:
|
|
{
|
|
m_bIsCtrl = !m_bIsCtrl;
|
|
pSysMenu->CheckMenuItem(IDM_CONTROL, m_bIsCtrl ? MF_CHECKED : MF_UNCHECKED);
|
|
|
|
if (m_bIsCtrl)
|
|
{
|
|
if (m_bIsTraceCursor)
|
|
SetClassLong(m_hWnd, GCL_HCURSOR, (LONG)AfxGetApp()->LoadCursor(IDC_DOT));
|
|
else
|
|
SetClassLong(m_hWnd, GCL_HCURSOR, (LONG)m_hRemoteCursor);
|
|
}
|
|
else
|
|
SetClassLong(m_hWnd, GCL_HCURSOR, (LONG)LoadCursor(NULL, IDC_NO));
|
|
}
|
|
break;
|
|
case IDM_TOPMOST:
|
|
{
|
|
bool bIsTopMost = pSysMenu->GetMenuState(IDM_TOPMOST, MF_BYCOMMAND) & MF_CHECKED;
|
|
pSysMenu->CheckMenuItem(IDM_TOPMOST, bIsTopMost ? MF_UNCHECKED : MF_CHECKED);
|
|
if (bIsTopMost)
|
|
SetWindowPos(&wndNoTopMost, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
|
|
else
|
|
SetWindowPos(&wndTopMost, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
|
|
}
|
|
break;
|
|
case IDM_CTRL_ALT_DEL:
|
|
{
|
|
BYTE bToken = COMMAND_SCREEN_CTRL_ALT_DEL;
|
|
m_iocpServer->Send(m_pContext, &bToken, sizeof(bToken));
|
|
}
|
|
break;
|
|
case IDM_TRACE_CURSOR: // 跟踪服务端鼠标
|
|
{
|
|
m_bIsTraceCursor = !m_bIsTraceCursor;
|
|
pSysMenu->CheckMenuItem(IDM_TRACE_CURSOR, m_bIsTraceCursor ? MF_CHECKED : MF_UNCHECKED);
|
|
if (m_bIsCtrl)
|
|
{
|
|
if (!m_bIsTraceCursor)
|
|
SetClassLong(m_hWnd, GCL_HCURSOR, (LONG)m_hRemoteCursor);
|
|
else
|
|
SetClassLong(m_hWnd, GCL_HCURSOR, (LONG)AfxGetApp()->LoadCursor(IDC_DOT));
|
|
}
|
|
// 重绘消除或显示鼠标
|
|
OnPaint();
|
|
}
|
|
break;
|
|
case IDM_BLOCK_INPUT: // 锁定服务端鼠标和键盘
|
|
{
|
|
bool bIsChecked = pSysMenu->GetMenuState(IDM_BLOCK_INPUT, MF_BYCOMMAND) & MF_CHECKED;
|
|
pSysMenu->CheckMenuItem(IDM_BLOCK_INPUT, bIsChecked ? MF_UNCHECKED : MF_CHECKED);
|
|
|
|
BYTE bToken[2];
|
|
bToken[0] = COMMAND_SCREEN_BLOCK_INPUT;
|
|
bToken[1] = !bIsChecked;
|
|
m_iocpServer->Send(m_pContext, bToken, sizeof(bToken));
|
|
}
|
|
break;
|
|
case IDM_BLANK_SCREEN: // 服务端黑屏
|
|
{
|
|
bool bIsChecked = pSysMenu->GetMenuState(IDM_BLANK_SCREEN, MF_BYCOMMAND) & MF_CHECKED;
|
|
pSysMenu->CheckMenuItem(IDM_BLANK_SCREEN, bIsChecked ? MF_UNCHECKED : MF_CHECKED);
|
|
|
|
BYTE bToken[2];
|
|
bToken[0] = COMMAND_SCREEN_BLANK;
|
|
bToken[1] = !bIsChecked;
|
|
m_iocpServer->Send(m_pContext, bToken, sizeof(bToken));
|
|
}
|
|
break;
|
|
case IDM_CAPTURE_LAYER: // 捕捉层
|
|
{
|
|
bool bIsChecked = pSysMenu->GetMenuState(IDM_CAPTURE_LAYER, MF_BYCOMMAND) & MF_CHECKED;
|
|
pSysMenu->CheckMenuItem(IDM_CAPTURE_LAYER, bIsChecked ? MF_UNCHECKED : MF_CHECKED);
|
|
|
|
BYTE bToken[2];
|
|
bToken[0] = COMMAND_SCREEN_CAPTURE_LAYER;
|
|
bToken[1] = !bIsChecked;
|
|
m_iocpServer->Send(m_pContext, bToken, sizeof(bToken));
|
|
}
|
|
break;
|
|
case IDM_SAVEDIB:
|
|
SaveSnapshot();
|
|
break;
|
|
case IDM_GET_CLIPBOARD: // 获取剪贴板
|
|
{
|
|
BYTE bToken = COMMAND_SCREEN_GET_CLIPBOARD;
|
|
m_iocpServer->Send(m_pContext, &bToken, sizeof(bToken));
|
|
}
|
|
break;
|
|
case IDM_SET_CLIPBOARD: // 设置剪贴板
|
|
{
|
|
SendLocalClipboard();
|
|
}
|
|
break;
|
|
case IDM_AERO_DISABLE: // 禁用桌面合成(Aero)
|
|
{
|
|
BYTE bToken = COMMAND_AERO_DISABLE;
|
|
m_iocpServer->Send(m_pContext, &bToken, sizeof(bToken));
|
|
}
|
|
break;
|
|
case IDM_AERO_ENABLE: // 启用桌面合成(Aero)
|
|
{
|
|
BYTE bToken = COMMAND_AERO_ENABLE;
|
|
m_iocpServer->Send(m_pContext, &bToken, sizeof(bToken));
|
|
}
|
|
break;
|
|
case IDM_ALGORITHM_HOME: // 家用办公算法
|
|
{
|
|
SendResetScreen(32);
|
|
pSysMenu->CheckMenuRadioItem(IDM_ALGORITHM_HOME, IDM_ALGORITHM_XVID, IDM_ALGORITHM_HOME, MF_BYCOMMAND);
|
|
pSysMenu->CheckMenuRadioItem(IDM_DEEP_16, IDM_DEEP_32, IDM_DEEP_32, MF_BYCOMMAND);
|
|
pSysMenu->EnableMenuItem(IDM_DEEP_16, MF_GRAYED);
|
|
SendResetAlgorithm(ALGORITHM_HOME);
|
|
}
|
|
break;
|
|
case IDM_ALGORITHM_XVID: // 影视娱乐算法
|
|
{
|
|
SendResetAlgorithm(ALGORITHM_XVID);
|
|
pSysMenu->CheckMenuRadioItem(IDM_ALGORITHM_HOME, IDM_ALGORITHM_XVID, IDM_ALGORITHM_XVID, MF_BYCOMMAND);
|
|
pSysMenu->EnableMenuItem(IDM_DEEP_16, MF_ENABLED);
|
|
}
|
|
break;
|
|
// case IDM_DEEP_1:
|
|
// {
|
|
// SendResetScreen(1);
|
|
// pSysMenu->CheckMenuRadioItem(IDM_DEEP_1, IDM_DEEP_32, IDM_DEEP_1, MF_BYCOMMAND);
|
|
// }
|
|
// break;
|
|
// case IDM_DEEP_4_GRAY:
|
|
// {
|
|
// SendResetScreen(3);
|
|
// pSysMenu->CheckMenuRadioItem(IDM_DEEP_1, IDM_DEEP_32, IDM_DEEP_4_GRAY, MF_BYCOMMAND);
|
|
// }
|
|
// break;
|
|
// case IDM_DEEP_4_COLOR:
|
|
// {
|
|
// SendResetScreen(4);
|
|
// pSysMenu->CheckMenuRadioItem(IDM_DEEP_1, IDM_DEEP_32, IDM_DEEP_4_COLOR, MF_BYCOMMAND);
|
|
// }
|
|
// break;
|
|
// case IDM_DEEP_8_GRAY:
|
|
// {
|
|
// SendResetScreen(7);
|
|
// pSysMenu->CheckMenuRadioItem(IDM_DEEP_1, IDM_DEEP_32, IDM_DEEP_8_GRAY, MF_BYCOMMAND);
|
|
// }
|
|
// break;
|
|
// case IDM_DEEP_8_COLOR:
|
|
// {
|
|
// SendResetScreen(8);
|
|
// pSysMenu->CheckMenuRadioItem(IDM_DEEP_1, IDM_DEEP_32, IDM_DEEP_8_COLOR, MF_BYCOMMAND);
|
|
// }
|
|
// break;
|
|
case IDM_DEEP_16:
|
|
{
|
|
SendResetScreen(16);
|
|
pSysMenu->CheckMenuRadioItem(IDM_DEEP_16, IDM_DEEP_32, IDM_DEEP_16, MF_BYCOMMAND);
|
|
}
|
|
break;
|
|
case IDM_DEEP_32:
|
|
{
|
|
SendResetScreen(32);
|
|
pSysMenu->CheckMenuRadioItem(IDM_DEEP_16, IDM_DEEP_32, IDM_DEEP_32, MF_BYCOMMAND);
|
|
}
|
|
break;
|
|
default:
|
|
CDialog::OnSysCommand(nID, lParam);
|
|
}
|
|
}
|
|
|
|
void CScreenSpyDlg::OnGetMinMaxInfo(MINMAXINFO* lpMMI)
|
|
{
|
|
RECT rectWindow, rectClient;
|
|
GetWindowRect(&rectWindow);
|
|
GetClientRect(&rectClient);
|
|
ClientToScreen(&rectClient);
|
|
|
|
int nBorderSize = rectClient.left - rectWindow.left; // 单边框的大小(宽度或高度)
|
|
int nTitleHeight = rectClient.top - rectWindow.top - nBorderSize; // 标题栏的高度
|
|
// int nMinWindowWidth = 400 + nBorderSize * 2;
|
|
// int nMinWindowHeight = 300 + nTitleHeight + nBorderSize * 2;
|
|
int nMaxWindowWidth = m_lpbmi_full->bmiHeader.biWidth + nBorderSize * 2;
|
|
int nMaxWindowHeight = m_lpbmi_full->bmiHeader.biHeight + nTitleHeight + nBorderSize * 2;
|
|
|
|
SCROLLBARINFO sbiv, sbih;
|
|
sbiv.cbSize = sizeof(SCROLLBARINFO);
|
|
sbih.cbSize = sizeof(SCROLLBARINFO);
|
|
GetScrollBarInfo(m_hWnd, OBJID_VSCROLL, &sbiv);
|
|
GetScrollBarInfo(m_hWnd, OBJID_HSCROLL, &sbih);
|
|
// nMinWindowWidth += sbiv.dxyLineButton;
|
|
// nMinWindowHeight += sbih.dxyLineButton;
|
|
nMaxWindowWidth += sbiv.rgstate[0] & STATE_SYSTEM_INVISIBLE ? 0 : sbiv.dxyLineButton;
|
|
nMaxWindowHeight += sbih.rgstate[0] & STATE_SYSTEM_INVISIBLE ? 0 : sbih.dxyLineButton;
|
|
|
|
// lpMMI->ptMinTrackSize.x = nMinWindowWidth;
|
|
// lpMMI->ptMinTrackSize.y = nMinWindowHeight;
|
|
lpMMI->ptMaxTrackSize.x = nMaxWindowWidth;
|
|
lpMMI->ptMaxTrackSize.y = nMaxWindowHeight;
|
|
|
|
// APPBARDATA abd;
|
|
// memset(&abd, 0, sizeof(abd));
|
|
// abd.cbSize = sizeof(abd);
|
|
// UINT_PTR uState = SHAppBarMessage(ABM_GETSTATE, &abd);
|
|
// SHAppBarMessage(ABM_GETTASKBARPOS, &abd);
|
|
// if (abd.uEdge == 0) // 任务栏在左
|
|
// {
|
|
// lpMMI->ptMaxPosition.x = uState == ABS_AUTOHIDE ? 0 : abd.rc.right;
|
|
// lpMMI->ptMaxPosition.y = 0;
|
|
// lpMMI->ptMaxSize.x = GetSystemMetrics(SM_CXSCREEN) - (uState == ABS_AUTOHIDE ? 0 : abd.rc.right);
|
|
// lpMMI->ptMaxSize.y = GetSystemMetrics(SM_CYSCREEN);
|
|
// }
|
|
// if (abd.uEdge == 1) // 任务栏在上
|
|
// {
|
|
// lpMMI->ptMaxPosition.x = 0;
|
|
// lpMMI->ptMaxPosition.y = uState == ABS_AUTOHIDE ? 0 : abd.rc.bottom;
|
|
// lpMMI->ptMaxSize.x = GetSystemMetrics(SM_CXSCREEN);
|
|
// lpMMI->ptMaxSize.y = GetSystemMetrics(SM_CYSCREEN) - (uState == ABS_AUTOHIDE ? 0 : abd.rc.bottom);
|
|
// }
|
|
// if (abd.uEdge == 2) // 任务栏在右
|
|
// {
|
|
// lpMMI->ptMaxPosition.x = 0;
|
|
// lpMMI->ptMaxPosition.y = 0;
|
|
// lpMMI->ptMaxSize.x = GetSystemMetrics(SM_CXSCREEN) - (uState == ABS_AUTOHIDE ? 0 : abd.rc.right - abd.rc.left);
|
|
// lpMMI->ptMaxSize.y = GetSystemMetrics(SM_CYSCREEN);
|
|
// }
|
|
// if (abd.uEdge == 3) // 任务栏在下
|
|
// {
|
|
// lpMMI->ptMaxPosition.x = 0;
|
|
// lpMMI->ptMaxPosition.y = 0;
|
|
// lpMMI->ptMaxSize.x = GetSystemMetrics(SM_CXSCREEN);
|
|
// lpMMI->ptMaxSize.y = GetSystemMetrics(SM_CYSCREEN) - (uState == ABS_AUTOHIDE ? 0 : abd.rc.bottom - abd.rc.top);
|
|
// }
|
|
}
|
|
|
|
void CScreenSpyDlg::DrawTipString(CString str)
|
|
{
|
|
RECT rect;
|
|
GetClientRect(&rect);
|
|
COLORREF bgcol = RGB(0x00, 0x00, 0x00);
|
|
COLORREF oldbgcol = SetBkColor(m_hCurrWndDC, bgcol);
|
|
COLORREF oldtxtcol = SetTextColor(m_hCurrWndDC, RGB(0xff,0x00,0x00));
|
|
ExtTextOut(m_hCurrWndDC, 0, 0, ETO_OPAQUE, &rect, NULL, 0, NULL);
|
|
|
|
DrawText (m_hCurrWndDC, str, -1, &rect,
|
|
DT_SINGLELINE | DT_CENTER | DT_VCENTER);
|
|
|
|
SetBkColor(m_hCurrWndDC, oldbgcol);
|
|
SetTextColor(m_hCurrWndDC, oldtxtcol);
|
|
/* InvalidateRect(NULL, FALSE);*/
|
|
}
|
|
|
|
BOOL CScreenSpyDlg::PreTranslateMessage(MSG* pMsg)
|
|
{
|
|
// TODO: Add your specialized code here and/or call the base class
|
|
|
|
switch (pMsg->message)
|
|
{
|
|
case WM_MOUSEMOVE:
|
|
if (GetKeyState(VK_SCROLL) & 0x0001) // Scroll灯点亮状态
|
|
{
|
|
CRect ClientRect;
|
|
GetClientRect(ClientRect);
|
|
|
|
int nHScrollPos = (float)m_lpbmi_full->bmiHeader.biWidth / ClientRect.Width() * LOWORD(pMsg->lParam);
|
|
int nVScrollPos = (float)m_lpbmi_full->bmiHeader.biHeight / ClientRect.Height() * HIWORD(pMsg->lParam);
|
|
SCROLLBARINFO sbi; int nMinPos, nMaxPos;
|
|
sbi.cbSize = sizeof(SCROLLBARINFO);
|
|
GetScrollBarInfo(m_hWnd, OBJID_HSCROLL, &sbi);
|
|
if (!(sbi.rgstate[0] & STATE_SYSTEM_INVISIBLE))
|
|
{
|
|
GetScrollRange(SB_HORZ, &nMinPos, &nMaxPos);
|
|
if (nHScrollPos > nMaxPos)
|
|
nHScrollPos = nMaxPos;
|
|
PostMessage(WM_HSCROLL, MAKEWPARAM(SB_THUMBTRACK, nHScrollPos), NULL);
|
|
}
|
|
GetScrollBarInfo(m_hWnd, OBJID_VSCROLL, &sbi);
|
|
if (!(sbi.rgstate[0] & STATE_SYSTEM_INVISIBLE))
|
|
{
|
|
GetScrollRange(SB_VERT, &nMinPos, &nMaxPos);
|
|
if (nVScrollPos > nMaxPos)
|
|
nVScrollPos = nMaxPos;
|
|
PostMessage(WM_VSCROLL, MAKEWPARAM(SB_THUMBTRACK, nVScrollPos), NULL);
|
|
}
|
|
|
|
ClientToScreen(ClientRect);
|
|
ClipCursor(ClientRect);
|
|
}
|
|
else
|
|
{
|
|
ClipCursor(NULL);
|
|
}
|
|
case WM_LBUTTONDOWN:
|
|
case WM_LBUTTONUP:
|
|
case WM_RBUTTONDOWN:
|
|
case WM_RBUTTONUP:
|
|
case WM_LBUTTONDBLCLK:
|
|
case WM_RBUTTONDBLCLK:
|
|
case WM_MBUTTONDOWN:
|
|
case WM_MBUTTONUP:
|
|
case WM_MBUTTONDBLCLK:
|
|
case WM_MOUSEWHEEL:
|
|
{
|
|
MSG msg;
|
|
memcpy(&msg, pMsg, sizeof(MSG));
|
|
int xPos = (int)(short)LOWORD(pMsg->lParam) + GetScrollPos(SB_HORZ);
|
|
int yPos = (int)(short)HIWORD(pMsg->lParam) + GetScrollPos(SB_VERT);
|
|
msg.lParam = MAKELPARAM(xPos, yPos);
|
|
msg.pt.x = xPos;
|
|
msg.pt.y = yPos;
|
|
SendCommand(&msg);
|
|
}
|
|
break;
|
|
case WM_KEYDOWN:
|
|
if (pMsg->wParam == VK_RETURN && GetKeyState(VK_CONTROL)&0x8000 && GetKeyState(VK_MENU)&0x8000)
|
|
{
|
|
FullScreen();
|
|
if (GetKeyState(VK_SCROLL) & 0x0001)
|
|
{
|
|
CRect ClientRect;
|
|
GetClientRect(ClientRect);
|
|
ClientToScreen(ClientRect);
|
|
ClipCursor(ClientRect);
|
|
}
|
|
return TRUE;
|
|
}
|
|
case WM_KEYUP:
|
|
if (pMsg->wParam == VK_RETURN && GetKeyState(VK_CONTROL)&0x8000 && GetKeyState(VK_MENU)&0x8000)
|
|
{
|
|
return TRUE;
|
|
}
|
|
case WM_SYSKEYUP:
|
|
case WM_SYSKEYDOWN:
|
|
if (pMsg->wParam != VK_SCROLL)
|
|
{
|
|
MSG msg;
|
|
memcpy(&msg, pMsg, sizeof(MSG));
|
|
ScreenToClient(&msg.pt);
|
|
msg.pt.x += GetScrollPos(SB_HORZ);
|
|
msg.pt.y += GetScrollPos(SB_VERT);
|
|
SendCommand(&msg);
|
|
if (pMsg->wParam == VK_RETURN || pMsg->wParam == VK_ESCAPE || pMsg->wParam == VK_F4)
|
|
return TRUE;
|
|
}
|
|
if (pMsg->wParam == VK_SCROLL)
|
|
{
|
|
if (GetKeyState(VK_SCROLL) & 0x0001)
|
|
{
|
|
CRect ClientRect;
|
|
GetClientRect(ClientRect);
|
|
ClientToScreen(ClientRect);
|
|
ClipCursor(ClientRect);
|
|
}
|
|
else ClipCursor(NULL);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return CDialog::PreTranslateMessage(pMsg);
|
|
}
|
|
|
|
void CScreenSpyDlg::PostNcDestroy()
|
|
{
|
|
// TODO: Add your specialized code here and/or call the base class
|
|
delete this;
|
|
CDialog::PostNcDestroy();
|
|
}
|
|
|
|
void CScreenSpyDlg::SendCommand(MSG* pMsg)
|
|
{
|
|
if (!m_bIsCtrl)
|
|
return;
|
|
|
|
LPBYTE lpData = new BYTE[sizeof(MSG) + 1];
|
|
lpData[0] = COMMAND_SCREEN_CONTROL;
|
|
memcpy(lpData + 1, pMsg, sizeof(MSG));
|
|
m_iocpServer->Send(m_pContext, lpData, sizeof(MSG) + 1);
|
|
|
|
delete[] lpData;
|
|
}
|
|
|
|
void CScreenSpyDlg::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
|
|
{
|
|
// TODO: Add your message handler code here and/or call default
|
|
SCROLLINFO si;
|
|
si.cbSize = sizeof(SCROLLINFO);
|
|
si.fMask = SIF_ALL;
|
|
GetScrollInfo(SB_HORZ, &si);
|
|
|
|
int nPrevPos = si.nPos;
|
|
switch(nSBCode)
|
|
{
|
|
case SB_LEFT:
|
|
si.nPos = si.nMin;
|
|
break;
|
|
case SB_RIGHT:
|
|
si.nPos = si.nMax;
|
|
break;
|
|
case SB_LINELEFT:
|
|
if (si.nPos > si.nMin)
|
|
si.nPos--;
|
|
break;
|
|
case SB_LINERIGHT:
|
|
if (si.nPos < si.nMax)
|
|
si.nPos++;
|
|
break;
|
|
case SB_PAGELEFT:
|
|
if (si.nPos > si.nMin)
|
|
si.nPos = max(si.nMin, si.nPos - (int)si.nPage);
|
|
break;
|
|
case SB_PAGERIGHT:
|
|
if (si.nPos < si.nMax)
|
|
si.nPos = min(si.nMax, si.nPos + (int)si.nPage);
|
|
break;
|
|
case SB_THUMBPOSITION:
|
|
case SB_THUMBTRACK:
|
|
si.nPos = nPos;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
si.fMask = SIF_POS;
|
|
SetScrollInfo(SB_HORZ, &si, TRUE);
|
|
// ScrollWindow(nPrevPos - si.nPos, 0);
|
|
OnPaint();
|
|
|
|
CDialog::OnHScroll(nSBCode, nPos, pScrollBar);
|
|
}
|
|
|
|
void CScreenSpyDlg::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar)
|
|
{
|
|
// TODO: Add your message handler code here and/or call default
|
|
SCROLLINFO si;
|
|
si.cbSize = sizeof(SCROLLINFO);
|
|
si.fMask = SIF_ALL;
|
|
GetScrollInfo(SB_VERT, &si);
|
|
|
|
int nPrevPos = si.nPos;
|
|
switch(nSBCode)
|
|
{
|
|
case SB_TOP:
|
|
si.nPos = si.nMin;
|
|
break;
|
|
case SB_BOTTOM:
|
|
si.nPos = si.nMax;
|
|
break;
|
|
case SB_LINEUP:
|
|
if (si.nPos > si.nMin)
|
|
si.nPos--;
|
|
break;
|
|
case SB_LINEDOWN:
|
|
if (si.nPos < si.nMax)
|
|
si.nPos++;
|
|
break;
|
|
case SB_PAGEUP:
|
|
if (si.nPos > si.nMin)
|
|
si.nPos = max(si.nMin, si.nPos - (int)si.nPage);
|
|
break;
|
|
case SB_PAGEDOWN:
|
|
if (si.nPos < si.nMax)
|
|
si.nPos = min(si.nMax, si.nPos + (int)si.nPage);
|
|
break;
|
|
case SB_THUMBPOSITION:
|
|
case SB_THUMBTRACK:
|
|
si.nPos = nPos;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
si.fMask = SIF_POS;
|
|
SetScrollInfo(SB_VERT, &si, TRUE);
|
|
// ScrollWindow(0, nPrevPos - si.nPos);
|
|
OnPaint();
|
|
|
|
CDialog::OnVScroll(nSBCode, nPos, pScrollBar);
|
|
}
|
|
|
|
void CScreenSpyDlg::UpdateLocalClipboard(char *buf, int len)
|
|
{
|
|
if (!::OpenClipboard(NULL))
|
|
return;
|
|
|
|
::EmptyClipboard();
|
|
HGLOBAL hglbCopy = GlobalAlloc(GPTR, len);
|
|
if (hglbCopy != NULL) {
|
|
// Lock the handle and copy the text to the buffer.
|
|
LPTSTR lptstrCopy = (LPTSTR) GlobalLock(hglbCopy);
|
|
memcpy(lptstrCopy, buf, len);
|
|
GlobalUnlock(hglbCopy); // Place the handle on the clipboard.
|
|
SetClipboardData(CF_TEXT, hglbCopy);
|
|
GlobalFree(hglbCopy);
|
|
}
|
|
CloseClipboard();
|
|
}
|
|
|
|
void CScreenSpyDlg::SendLocalClipboard()
|
|
{
|
|
if (!::OpenClipboard(NULL))
|
|
return;
|
|
HGLOBAL hglb = GetClipboardData(CF_TEXT);
|
|
if (hglb == NULL)
|
|
{
|
|
::CloseClipboard();
|
|
return;
|
|
}
|
|
int nPacketLen = GlobalSize(hglb) + 1;
|
|
LPSTR lpstr = (LPSTR) GlobalLock(hglb);
|
|
LPBYTE lpData = new BYTE[nPacketLen];
|
|
lpData[0] = COMMAND_SCREEN_SET_CLIPBOARD;
|
|
memcpy(lpData + 1, lpstr, nPacketLen - 1);
|
|
::GlobalUnlock(hglb);
|
|
::CloseClipboard();
|
|
m_iocpServer->Send(m_pContext, lpData, nPacketLen);
|
|
delete[] lpData;
|
|
}
|
|
|
|
void CScreenSpyDlg::SendNext()
|
|
{
|
|
BYTE bBuff = COMMAND_NEXT;
|
|
m_iocpServer->Send(m_pContext, &bBuff, 1);
|
|
}
|
|
|
|
LRESULT CScreenSpyDlg::OnMoving(WPARAM wParam, LPARAM lParam)
|
|
{
|
|
SystemParametersInfo(SPI_GETWINARRANGING, 0, (LPVOID)&m_bWinArrange, 0);
|
|
SystemParametersInfo(SPI_GETSNAPSIZING, 0, (LPVOID)&m_bSnapSizing, 0);
|
|
SystemParametersInfo(SPI_SETWINARRANGING, 0, (LPVOID)TRUE, 0);
|
|
SystemParametersInfo(SPI_SETSNAPSIZING, 0, (LPVOID)FALSE, 0);
|
|
return FALSE;
|
|
}
|
|
|
|
void CScreenSpyDlg::OnMove(int x, int y)
|
|
{
|
|
CDialog::OnMove(x, y);
|
|
|
|
// TODO: Add your message handler code here
|
|
SystemParametersInfo(SPI_SETSNAPSIZING, 0, (LPVOID)m_bSnapSizing, 0);
|
|
SystemParametersInfo(SPI_SETWINARRANGING, 0, (LPVOID)m_bWinArrange, 0);
|
|
}
|
|
|
|
LRESULT CScreenSpyDlg::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
|
|
{
|
|
// TODO: Add your specialized code here and/or call the base class
|
|
if (message == WM_POWERBROADCAST && wParam == PBT_APMQUERYSUSPEND)
|
|
{
|
|
return BROADCAST_QUERY_DENY; // 拦截系统待机, 休眠的请求
|
|
}
|
|
if (message == WM_ACTIVATE && LOWORD(wParam) != WA_INACTIVE && !HIWORD(wParam) && m_bIsFullScreen)
|
|
{
|
|
SetWindowPos(&wndTopMost, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
|
|
return TRUE;
|
|
}
|
|
if (message == WM_ACTIVATE && LOWORD(wParam) == WA_INACTIVE && m_bIsFullScreen)
|
|
{
|
|
SetWindowPos(&wndNoTopMost, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
|
|
return TRUE;
|
|
}
|
|
|
|
return CDialog::WindowProc(message, wParam, lParam);
|
|
}
|