win32 最小化工具

最新推荐文章于 2022-01-28 16:35:50 发布
最新推荐文章于 2022-01-28 16:35:50 发布
阅读量1.4k 收藏 1
点赞数
分类专栏： 软件 文章标签： C++ windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/fulianzhou/article/details/75270062
版权

本文是仿照Trayconizer软件制作。

本文的最小化工具是能够随意控制一个程序并使之最小化，恢复的软件。如在命令行中运行：

Trayconizer.exe C;\windows\notepad.exe; 

将会打开一个记事本，当点击最小化按钮时，会影藏到后台运行，并在托盘中显示记事本的图标，双击记事本恢复窗口，右键点击弹出“Restore”，“Close”菜单。当记事本关闭后，工具软件也会关闭。工具软件是一直在后台运行的，不会显示窗口。

用到了3个枚举窗口函数。

// 枚举窗口函数
BOOL CALLBACK fnAdd(HWND hwnd,LPARAM lParam)
{
	ShowWindowAsync(hwnd,SW_MINIMIZE);
	return TRUE;
}

// 枚举窗口，将图标从图片删除,Restore菜单
BOOL CALLBACK fnDelRestore(HWND hwnd,LPARAM lParam)
{
	Shell_NotifyIcon(NIM_DELETE,&g_nid);
	ShowWindowAsync(hwnd,SW_SHOW);
	ShowWindowAsync(hwnd,SW_RESTORE);
	SetForegroundWindow(hwnd);
	return TRUE;
}

// 枚举窗口函数,将图标从托盘删除，Close菜单
BOOL CALLBACK fnDelClose(HWND hwnd,LPARAM lParam)
{
	Shell_NotifyIcon(NIM_DELETE,&g_nid);
	PostMessage(hwnd,WM_CLOSE,0,0);
	return TRUE;
}

使用钩子来截取应用程序的最小化消息。

// 窗口最小化处理函数
void CALLBACK MinProc(HWINEVENTHOOK hWinEventHook,DWORD dwEvent,HWND hwnd,LONG idObject,LONG idChild,DWORD dwEventThread,DWORD dwMsEventTime)
{
#ifdef _DEBUG_
	WCHAR pwchMsg[128] = { 0 };
	wsprintf(pwchMsg,_T("%x %x\n"),dwEvent,dwEventThread);
	WriteConsole(g_hOutput,pwchMsg,wcslen(pwchMsg),NULL,NULL);
#endif

	if(dwEvent == EVENT_SYSTEM_MINIMIZESTART) // 最小化
	{
		g_nid.cbSize = sizeof(NOTIFYICONDATA);
		g_nid.uID = MY_TRAY_ICON_ID;
		g_nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
		g_nid.hWnd = g_hWnd;
		g_nid.uCallbackMessage = WM_MYMSG;
		wcscpy_s(g_nid.szTip,g_pwchCmdLine);

		HICON hIcon = (HICON)SendMessage(hwnd,WM_GETICON,ICON_SMALL,0);
		if(NULL == hIcon)
		{
			hIcon = (HICON)SendMessage(hwnd,WM_GETICON,ICON_SMALL2,0);
			if(hIcon == NULL)
			{
				hIcon = (HICON)SendMessage(hwnd,WM_GETICON,ICON_BIG,0);
				if(hIcon == NULL)
				{
					hIcon = (HICON)GetClassLong(hwnd,GCL_HICON);
					if(hIcon == NULL)
					{
						SHFILEINFO stFileInfo;
						::SHGetFileInfo(g_pwchCmdLine,0,&stFileInfo,sizeof(stFileInfo),SHGFI_ICON);
						hIcon = stFileInfo.hIcon;
						if(NULL==hIcon)
							hIcon = LoadIcon(g_hInst,MAKEINTRESOURCE(IDI_TRAYCONIZER));
					}
				}
			}
		}
		g_nid.hIcon = hIcon;
		Shell_NotifyIcon(NIM_ADD,&g_nid);
		ShowWindow(hwnd,SW_HIDE);
	}
/*
	else if(dwEvent == EVENT_SYSTEM_MINIMIZEEND)
	{
		EnumThreadWindows(g_dwTrayPid,fnDelRestore,0);
	}
	else if(dwEvent == EVENT_OBJECT_DESTROY) // 关闭
	{
		SendMessage(g_hWnd,WM_CLOSE,0,0);
	}*/
}
使用线程监视应用进程是否已经关闭。 

// 等待进程关闭，然后结束进程
DWORD CALLBACK WaitForClose(LPVOID lpParam)
{
	HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS,FALSE,g_dwTrayPid);
	WaitForSingleObject(hProc,INFINITE);
	SendMessage(g_hWnd,WM_CLOSE,0,0);
	return 0;
}

完整源码： 

// Traynizer.cpp : 定义应用程序的入口点。
//

#include "stdafx.h"
#include "Trayconizer.h"
#include "shellapi.h"

//#define _DEBUG_

HINSTANCE g_hInst = NULL;

const int WM_MYMSG           =   WM_USER + 1;
const int MY_TRAY_ICON_ID    = 152;
const int IDM_RESTORE   =   2001;
const int IDM_CLOSE     =   2002;
const LPWSTR gc_aMinimize = _T("-minimize");

HWND g_hWnd = NULL;
LPWSTR g_lpAppName = _T("Win32");
WCHAR g_pwchCmdLine[128];
NOTIFYICONDATA g_nid = { 0 };
DWORD g_dwTrayPid,g_dwTrayTid;

#ifdef _DEBUG_
HANDLE g_hOutput = NULL;  // 输出窗口句柄
#endif


// 主窗口回调函数
LRESULT CALLBACK WinProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam);
// 枚举窗口函数，将图标添加到托盘
BOOL CALLBACK fnAdd(HWND hwnd,LPARAM lParam);
// 枚举窗口函数，将图标从托盘删除，Restore菜单
BOOL CALLBACK fnDelRestore(HWND hwnd,LPARAM lParam);
// 枚举窗口函数，将图标从图片删除，Close菜单
BOOL CALLBACK fnDelClose(HWND hwnd,LPARAM lParam);
// 窗口最小化处理函数
void CALLBACK MinProc(HWINEVENTHOOK hWinEventHook,DWORD dwEvent,HWND hwnd,LONG idObject,LONG idChild,DWORD dwEventThread,DWORD dwMsEventTime);
// 等待进程关闭
DWORD CALLBACK WaitForClose(LPVOID lpParam);
// 结束进程
BOOL TerminateProcessFromID(DWORD id);
// 解析命令行
BOOL DecordCmdLine(LPWSTR lpwstrCmd);


// 主函数
int APIENTRY _tWinMain(HINSTANCE hInstance,
                       HINSTANCE hPrevInstance,
                       LPTSTR    lpCmdLine,
                       int       nCmdShow)
{
#ifdef _DEBUG_
	AllocConsole();
	g_hOutput = GetStdHandle(STD_OUTPUT_HANDLE);
#endif

	//wcscpy(lpCmdLine,_T("-minimize C:\\windows\\notepad.exe"));

	BOOL bFlag = DecordCmdLine(lpCmdLine);

/*********************************************** 进程创建过程 **/
	STARTUPINFO si = { 0 };
	si.cb = sizeof(STARTUPINFO);

	PROCESS_INFORMATION pi = { 0 };
	
	if(wcslen(lpCmdLine)<=0)
	{
		MessageBoxW(NULL,
			_T("Trayconizer 1.1.1, by WhitSoft Development\n")
			_T("http://www.whitsoftdev.com/trayconizer/\n")
			_T("\n")
			_T("The easiest way to use Trayconizer is to set the target of a shortcut to the path of the Trayconizer executable f")
			_T("ollowed by the path of the program you want to Trayconize. For example:\n")
			_T("C:\\path\\to\\Trayconizer.exe C:\\Windows\\Regedit.exe\n")
			_T("\n")
			_T("You can also tell Trayconizer to start the program in the Trayconized state using the -minimize command line swit")
			_T("ch. For example:\n")
			_T("C:\\path\\to\\Trayconizer.exe -minimize C:\\Windows\\Regedit.exe\n")
			_T("\n")
			_T("Note that not all programs can be Trayconized, so your mileage may vary. Enjoy!"),
			_T("Trayconizer"),
			0x40u);
		ExitProcess(0);
		return 0;
	}

	if(!CreateProcess(NULL,lpCmdLine,0,0,0,0,0,0,&si,&pi))
	{
		WCHAR pwchMsg[128];
		DWORD dwErr = GetLastError();
		
		if(dwErr == 740)
		{
			wsprintf(pwchMsg,_T("Unable to start %s . require Administrator!"),lpCmdLine);
		}
		else
		{
			wsprintf(pwchMsg,_T("Unable to start %s . %d"),lpCmdLine,GetLastError());
		}
		MessageBox(NULL,pwchMsg,_T("Trayconizer"),MB_OK | MB_ICONINFORMATION);
		ExitProcess(0);
		return 0;
	}

	g_dwTrayPid= pi.dwProcessId;
	g_dwTrayTid = pi.dwThreadId;
	WaitForInputIdle(pi.hProcess,0xffffffff);
	
#ifdef _DEBUG_
	WCHAR pwchMsg[128];
	wsprintf(pwchMsg,_T("pid:%d tid:%d\n"),g_dwTrayPid,g_dwTrayTid);
	WriteConsole(g_hOutput,pwchMsg,wcslen(pwchMsg),NULL,NULL);
#endif
	CloseHandle(pi.hProcess);
	CloseHandle(pi.hThread);

	wcscpy(g_pwchCmdLine,lpCmdLine);

	
/*********************************************************/

/***************  主窗口创建过程 ***************/
	HWND hwnd = FindWindow(g_lpAppName,_T("Trayconizer"));
	if(hwnd)
	{
		g_hWnd = hwnd;
	}
	else
	{
		WNDCLASS wndcls = { 0 };
		wndcls.style = CS_HREDRAW | CS_VREDRAW;
		wndcls.cbClsExtra = 0;
		wndcls.cbWndExtra = 0;
		wndcls.hInstance = hInstance;
		wndcls.lpfnWndProc = WinProc;
		wndcls.lpszClassName = g_lpAppName;
		wndcls.hIcon = LoadIcon(NULL,MAKEINTRESOURCE(IDI_TRAYCONIZER));
		wndcls.hCursor = LoadCursor(NULL,IDC_ARROW);
		wndcls.lpszMenuName = NULL;
		wndcls.hbrBackground = static_cast<HBRUSH>(GetStockObject(WHITE_BRUSH));

		if(!RegisterClass(&wndcls)){
			MessageBox(NULL,_T("注册窗口类失败"),_T("tips"),MB_ICONINFORMATION | MB_OK);
			return 0;
		}
		g_hWnd = CreateWindow(g_lpAppName,_T("Trayconizer"),WS_OVERLAPPEDWINDOW,
			0,0,0,0,
			NULL,NULL,hInstance,0);
		if(g_hWnd == NULL)
		{
			MessageBox(NULL,_T("窗口创建失败!"),0,0);
			TerminateProcessFromID(g_dwTrayPid);
			ExitProcess(0);
			return 0;
		}
		g_hInst = hInstance;
	}


/****************************************************/
	if(!SetWinEventHook(EVENT_MIN,EVENT_MAX,NULL,MinProc,g_dwTrayPid,g_dwTrayTid,WINEVENT_OUTOFCONTEXT))
	{
		WCHAR pwchMsg[64];
		wsprintf(pwchMsg,_T("SetWinEventHook failed . %d"),GetLastError());
		MessageBox(NULL,pwchMsg,0,MB_ICONINFORMATION | MB_OK);
		TerminateProcessFromID(g_dwTrayPid);
		ExitProcess(0);
		return 0;
	}

	if(bFlag) // 最小化窗口
	{
		if(!EnumThreadWindows(g_dwTrayTid,fnAdd,0))
		{
			DWORD dwErr = GetLastError();
			WCHAR lpwstr[64] = { 0 };
			wsprintf(lpwstr,_T("EnumThreadWindows failed . %d"),dwErr);
			MessageBox(NULL,lpwstr,_T("Trayconizer"),MB_OK | MB_ICONINFORMATION);
			TerminateProcessFromID(g_dwTrayPid);
			SendMessage(g_hWnd,WM_CLOSE,-1,0);
			ExitProcess(0);
			return 0;
		}
	}

	DWORD dwId;
	HANDLE hThrd = CreateThread(NULL,NULL,WaitForClose,NULL,0,&dwId);
	if(NULL == hThrd)
	{
		WCHAR pwchMsg[64];
		wsprintf(pwchMsg,_T("CreateThread failed . %d"),GetLastError());
		MessageBox(NULL,pwchMsg,_T("tip"),MB_OK | MB_ICONINFORMATION);
		TerminateProcessFromID(g_dwTrayPid);
		SendMessage(g_hWnd,WM_CLOSE,0,0);
		ExitProcess(0);
		return 0;
	}

	MSG msg;
	while(GetMessage(&msg,NULL,0,0))
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}
	return 0;
}

//解析命令行
BOOL DecordCmdLine(LPWSTR lpwstrCmd)
{
	int len = wcslen(lpwstrCmd);
	LPWSTR lpwstrtmp = new WCHAR[len];
	memset(lpwstrtmp,0,sizeof(lpwstrtmp));
	if(*lpwstrCmd == _T('-'))
	{
		int ispace = 0;
		for(ispace =0;ispace<len;ispace++)
		{
			lpwstrtmp[ispace] = lpwstrCmd[ispace];
			if(lpwstrCmd[ispace] == _T(' ')) 
			{
				lpwstrtmp[ispace] = 0;;
				break;
			}
		}
		if(ispace != 0 && ispace < len) 
		{		
			if(wcscmp(lpwstrtmp,gc_aMinimize) == 0)
			{
				LPWSTR lpwstrNewCmd = new WCHAR[len-ispace+2];
				memset(lpwstrNewCmd,0,sizeof(lpwstrNewCmd));
				int j = 0;
				for(int i=ispace+1;i<len;i++,j++)
					lpwstrNewCmd[j] = lpwstrCmd[i];
				lpwstrNewCmd[j] = 0;
				wcscpy(lpwstrCmd,lpwstrNewCmd);
				delete[] lpwstrNewCmd;
				return TRUE;
			}
		}
	}
	return FALSE;
}

// 窗口回调函数
LRESULT CALLBACK WinProc(HWND hwnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
	switch (msg)
	{
	case WM_CLOSE:
		PostQuitMessage(0);
		return 1;
	case WM_COMMAND:
		{
			switch(wParam)
			{
			case IDM_CLOSE:
				EnumThreadWindows(g_dwTrayTid,fnDelClose,0);
				PostMessage(g_hWnd,WM_CLOSE,0,0);
				return 0;
			case IDM_RESTORE:
				EnumThreadWindows(g_dwTrayTid,fnDelRestore,0);
				return 0;
			}
		}break;
	case WM_MYMSG:
		switch(lParam)
		{
		case WM_LBUTTONDBLCLK:
			EnumThreadWindows(g_dwTrayTid,fnDelRestore,0);
			break;
		case WM_RBUTTONUP:
			{
				POINT pt;
				GetCursorPos(&pt);
				HMENU hMenu = CreatePopupMenu();
				AppendMenu(hMenu,MF_INSERT,IDM_RESTORE,_T("Restore"));
				AppendMenu(hMenu,MF_INSERT,IDM_CLOSE,_T("Close"));
				SetMenuDefaultItem(hMenu,IDM_RESTORE,0);
				TrackPopupMenu(hMenu,TPM_RIGHTBUTTON,pt.x,pt.y,NULL,hwnd,NULL);
				DestroyMenu(hMenu);
			}break;
		}
		break;
	}
	return DefWindowProc(hwnd,msg,wParam,lParam);
}
// 枚举窗口函数
BOOL CALLBACK fnAdd(HWND hwnd,LPARAM lParam)
{
	ShowWindowAsync(hwnd,SW_MINIMIZE);
	return TRUE;
}

// 枚举窗口，将图标从图片删除,Restore菜单
BOOL CALLBACK fnDelRestore(HWND hwnd,LPARAM lParam)
{
	Shell_NotifyIcon(NIM_DELETE,&g_nid);
	ShowWindowAsync(hwnd,SW_SHOW);
	ShowWindowAsync(hwnd,SW_RESTORE);
	SetForegroundWindow(hwnd);
	return TRUE;
}

// 枚举窗口函数,将图标从托盘删除，Close菜单
BOOL CALLBACK fnDelClose(HWND hwnd,LPARAM lParam)
{
	Shell_NotifyIcon(NIM_DELETE,&g_nid);
	PostMessage(hwnd,WM_CLOSE,0,0);
	return TRUE;
}

// 窗口最小化处理函数
void CALLBACK MinProc(HWINEVENTHOOK hWinEventHook,DWORD dwEvent,HWND hwnd,LONG idObject,LONG idChild,DWORD dwEventThread,DWORD dwMsEventTime)
{
#ifdef _DEBUG_
	WCHAR pwchMsg[128] = { 0 };
	wsprintf(pwchMsg,_T("%x %x\n"),dwEvent,dwEventThread);
	WriteConsole(g_hOutput,pwchMsg,wcslen(pwchMsg),NULL,NULL);
#endif

	if(dwEvent == EVENT_SYSTEM_MINIMIZESTART) // 最小化
	{
		g_nid.cbSize = sizeof(NOTIFYICONDATA);
		g_nid.uID = MY_TRAY_ICON_ID;
		g_nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
		g_nid.hWnd = g_hWnd;
		g_nid.uCallbackMessage = WM_MYMSG;
		wcscpy_s(g_nid.szTip,g_pwchCmdLine);

		HICON hIcon = (HICON)SendMessage(hwnd,WM_GETICON,ICON_SMALL,0);
		if(NULL == hIcon)
		{
			hIcon = (HICON)SendMessage(hwnd,WM_GETICON,ICON_SMALL2,0);
			if(hIcon == NULL)
			{
				hIcon = (HICON)SendMessage(hwnd,WM_GETICON,ICON_BIG,0);
				if(hIcon == NULL)
				{
					hIcon = (HICON)GetClassLong(hwnd,GCL_HICON);
					if(hIcon == NULL)
					{
						SHFILEINFO stFileInfo;
						::SHGetFileInfo(g_pwchCmdLine,0,&stFileInfo,sizeof(stFileInfo),SHGFI_ICON);
						hIcon = stFileInfo.hIcon;
						if(NULL==hIcon)
							hIcon = LoadIcon(g_hInst,MAKEINTRESOURCE(IDI_TRAYCONIZER));
					}
				}
			}
		}
		g_nid.hIcon = hIcon;
		Shell_NotifyIcon(NIM_ADD,&g_nid);
		ShowWindow(hwnd,SW_HIDE);
	}
/*
	else if(dwEvent == EVENT_SYSTEM_MINIMIZEEND)
	{
		EnumThreadWindows(g_dwTrayPid,fnDelRestore,0);
	}
	else if(dwEvent == EVENT_OBJECT_DESTROY) // 关闭
	{
		SendMessage(g_hWnd,WM_CLOSE,0,0);
	}*/
}
// 等待进程关闭，然后结束进程
DWORD CALLBACK WaitForClose(LPVOID lpParam)
{
	HANDLE hProc = OpenProcess(PROCESS_ALL_ACCESS,FALSE,g_dwTrayPid);
	WaitForSingleObject(hProc,INFINITE);
	SendMessage(g_hWnd,WM_CLOSE,0,0);
	return 0;
}
// 通过进程ID关闭进程
BOOL TerminateProcessFromID(DWORD id)
{
	HANDLE hProcess = OpenProcess(PROCESS_ALL_ACCESS,FALSE,id);
	if(hProcess!=NULL)
	{
		return TerminateProcess(hProcess,0);
	}
	CloseHandle(hProcess);
	return FALSE;
}




Python win32gui 模块：窗口操作方法代码实例
轩逸云的博客
12-25 2770
‌状态共享‌：如果需要在多个回调函数之间共享状态（比如计数或标志），可以创建一个可变对象（如列表或字典），并将其作为可选参数传递。这样，回调函数就可以修改这个对象，并且这些修改在后续的回调中可见。‌传递数据‌：可以将任何需要的数据作为这个可选参数传递给回调函数。例如，传递一个列表或字典，以便在回调函数中收集或更新数据。‌控制枚举‌：可以使用这个参数来控制枚举的过程。例如，可以在回调函数中检查某个条件，如果满足，则通过修改这个参数来通知。
最小化工具
07-18
本文的最小化工具是能够随意控制一个程序并使之最小化，恢复的软件。如在命令行中运行： Trayconizer.exe C;\windows\notepad.exe; 将会打开一个记事本，当点击最小化按钮时，会影藏到后台运行，并在托盘中显示记事本的图标，双击记事本恢复窗口，右键点击弹出“Restore”，“Close”菜单。当记事本关闭后，工具软件也会关闭。工具软件是一直在后台运行的，不会显示窗口。
win32窗口的最小化，隐藏，和失去焦点
u011393161的博客
02-28 6812
最小化 是指点击右上角的最小化按钮后，窗口缩小到任务栏的状态，这种状态可以用IsIconic函数来检测 隐藏 是指任务栏上也看不到窗口的图标，有些程序右下角有托盘图标，造成缩小到托盘的效果，其实是隐藏了窗口，这种状态，可以用IsWindowVisible函数来检测 失去焦点 是指窗口ShowNormal状态下（非最大化显示），激活别的窗口（比如点击桌面），目标窗口失去焦点的状态，...
电脑小软件，超强最小化工具
05-25
比较实用的一个小工具！电脑小软件，超强最小化工具
pywin32 模拟鼠标 最小化窗口处理
莫问天涯，莫问归期
01-28 1649
pywin32 模拟鼠标 最小化窗口处理 无论窗口是否最小化，win32gui.FindWindow都是可以正常获取句柄的，但是在模拟鼠标键盘操作时可能受影响。 以如下代码为例： def find_flash_window(to_who): hwnd = win32gui.FindWindow(None, to_who) if (hwnd): win32gui.SetForegroundWindow(hwnd) rect = win32gui.GetWind
QTP调用win32 API 实现窗口的最小最大化
软件自动化测试专栏
08-03 2552
调用win32 API 实现窗口的最小最大化，特别应用在IE窗口操作上，可以有效的释放占用内存。 Public Function min_and_max(hwnd)         Extern.Declare micVoid ,"SendMessageA","user32.dll","SendMessageA",micHwnd,micInteger,micInteger,micInt
网络带宽测试工具-iperf-2.0.5-3-win32、netperf
最新发布
12-11
网络带宽测试工具iperf与netperf是网络性能测试领域中常用的两款软件，主要用于评估网络连接的速度和...它们的广泛使用和不断更新维护，使得网络测试变得更加标准化和专业化，为网络性能的提升提供了强有力的工具支持。
MemoryAnalyzer-win32.win32.x86-64.rar
04-09
《深入理解JVM OOM分析：MemoryAnalyzer-win32.win32.x86_64工具详解》 在Java开发过程中，内存管理是一项至关重要的任务，而Java虚拟机（JVM）中的内存溢出（Out of Memory，简称OOM）问题常常困扰着开发者。当...
Clover3.5.6-Win10文件资源管理器标签化工具
03-25
"Clover3.5.6-Win10文件资源管理器标签化工具"是一款专为Windows 10设计的增强型文件管理扩展软件，它引入了类似于浏览器的多标签功能，使得用户可以在同一窗口内同时打开多个文件夹，提高了文件管理和操作的效率。...
如何最小化一个exe
SHELLCODE_8BIT的博客
12-24 514
1.纯shellcode 2.用低版本来写，比较快 3.
Trayconizer.exe
12-10
能最小化进程的小工具，不错的，把进程 Trayconizer.exe：“启动进程” 就可以了
trayconizera托盘工具，附使用教程
07-16
当某些程序需要长时间开启，且程序没有托盘功能时，可使用此软件对软件进行托盘操作。
快捷键将应用程序最小化至托盘
05-23
仿QQ方式，通过快捷键方式（我设置的是Ctrl+Alt+E，可以随意修改），将应用程序在正常状态和最小化至托盘状态进行切换。
MinimizeToTrayTool(最小化到托盘工具)v7.0官方安装免费版
07-25
MinimizeToTrayTool是一款好用的系统优化软件。这款软件能够将任何程序最小化到系统托盘，对于大部分程序的窗口都是有效的，所以这是一个非常有用的小程序。 使用方法 　　1、安装后运行，这个软件会显示在系统托盘中。 　　2、在系统托盘图标上右击，选择【configure】菜单项，就可以打开设置界面。 　　3、这个时候你就可以在设置界面上看到一个像靶心一样的图标了，按住这个图标
最小化到托盘函数
移动开发记录
11-18 171
很多程序希望它能在后台运行，这时需要最小化到托盘，所以就有编写最小化到托盘函数的必要了。 其实是用到了NOTIFYICONDATA 结构 void TuoPan(HWND hwnd) { NOTIFYICONDATA nid; ZeroMemory(&amp;nid, sizeof(nid)); HGLOBAL hResource = LoadResource ((HINSTANCE)...
EnumThreadWindows枚举线程的所有窗口
Lyntion的Blog
11-29 5612
BOOL CALLBACK EnumThreadWndProc(HWND hwnd, LPARAM lParam ) { std::listHWND>* plist = (std::listHWND>*)lParam; plist->push_back(hwnd); return true; } int main(void) { CWnd* pWnd = CW
『爱软收藏』Trayconizer
编制者的专栏
06-14 2218
今天发现个不错的软件----Trayconizer Trayconizer 几乎可以将任何常见应用程序最小化到系统托盘，节省了宝贵的任务栏空间。效果图如下：  『使用说明』 使用方法很简单，在自己使用频繁的应用程序的快捷方式上点击右键，然后选择“属性”，接着在"目标"项右侧原有应用程序路径的前面加上Trayconizer.exe程序所在的路径： C:/Path/To/Trayc
纯C语言实现设置窗口大小 控制台窗口
热门推荐
yuanwow的博客
04-21 1万+
纯C语言实现设置窗口大小 如果想要修改屏幕缓冲区可以: COORD size = {w, h}; HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE); 如果只需要修改窗口大小可以: SMALL_RECT rc = {1,1, w, h}; SetConsoleWindowInfo(hOut ,true ,&rc); 注意:窗口大小不能超过缓冲区大...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值