windows下一种图标合成和显示方式

已于 2024-08-09 15:05:41 修改
阅读量111 收藏
点赞数
文章标签： windows
于 2023-04-10 10:20:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_37567738/article/details/130053952
版权

本程序用于在任务栏合成显示自定义图标。

#pragma once


#include <windows.h>



HICON myCreateIcon(HWND hwnd, HICON hicon);

VOID setOverLay(HWND hWnd, HICON hIcon, const WCHAR* description);

VOID resetOverLay(HWND hWnd);

void setMyIcon(HWND hwnd);

//int __stdcall iconthread();




#include "overlapIcon.h"

#include "apifuns.h"

#include "main.h"

#include <windows.h>
#include <wingdi.h>
#include "resource.h"

#pragma pack(1)


typedef struct
{
	//biSizeImage表示掩码数据区的大小（XOR和AND
	BITMAPINFOHEADER icHeader; // DIB header

//像素数据的排列次序：
//icColors[256]   //假设是32x32的256色的icon
//icXOR[1024] //32x32
//icAND[128]  //32x32/8每个像素之要1bit //icAND = x*y/8

//dwBytesInres 16936 = 40 + biSizeImage
//biSizeImage:16896,64*64*4=16384, and table 512 bytes

// 	RGBQUAD icColors[1]; // Color table //颜色表的大小取决于icon文件中所用到的颜色数对于16，24位或者32位色的图像就不需要颜色表
// 	BYTE icXOR[1]; // DIB bits for XOR mask
// 	BYTE icAND[1]; // DIB bits for AND mask
} ICONIMAGE, * LPICONIMAGE;

typedef struct
{
	BYTE bWidth; // Width, in pixels, of the image
	BYTE bHeight; //biHeight在这里是像素高度的两倍，因为是XOR掩码区和AND掩码区高度之和
	BYTE bColorCount; // Number of colors in image (0 if >=8bpp)
	BYTE bReserved; // Reserved ( must be 0)
	WORD wPlanes; // Color Planes
	WORD wBitCount; // Bits per pixel
	DWORD dwBytesInRes; // How many bytes in this resource?
	DWORD dwImageOffset; // Where in the file is this image?
} ICONDIRENTRY, * LPICONDIRENTRY;

typedef struct
{
	WORD idReserved; // Reserved (must be 0)
	WORD idType; // Resource Type (1 for icons)
	WORD idCount; // How many images?
	ICONDIRENTRY idEntries[1]; // An entry for each image (idCount of 'em)
} ICONDIR, * LPICONDIR;




#pragma pack()

HICON getAppIcon(HWND hwnd);
int copyScanline(BYTE* dst, BYTE* src, int src_line_size, int dst_line_size, int height);
BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM lParam);
int blendPixel(BYTE* dst, BYTE* src, int src_line_size, int dst_line_size, int src_height, int backgroundWeigh);




#define PIXERL_BLEND_APP_ICON_WEIGH 120




int compressBmp(BYTE* line, int line_size, int bytesperpix, int src_height) {
	DWORD* src_ptr = (DWORD*)line;
	DWORD* dst_ptr = (DWORD*)(line + bytesperpix);
	for (int i = 0; i < src_height; i++)
	{
		for (int j = 0; j < line_size / bytesperpix / 2; j += 2)
		{
			src_ptr[j] = (src_ptr[j] + dst_ptr[j]) / 2;
		}
		dst_ptr += line_size;
		src_ptr += line_size;
	}

	src_ptr = (DWORD*)line;
	dst_ptr = (DWORD*)line + line_size;
	for (int i = 0; i < src_height / 2; i++)
	{
		for (int j = 0; j < line_size / sizeof(DWORD) / 2; j++)
		{
			src_ptr[j] = (src_ptr[j] + dst_ptr[j]) / 2;
		}
		dst_ptr = dst_ptr + line_size * 2;
		src_ptr = src_ptr + line_size * 2;
	}
	return TRUE;
}

int copyScanline(BYTE* dst, BYTE* src, int src_line_size, int dst_line_size, int src_height) {
	BYTE* dst_ptr = dst;
	BYTE* src_ptr = src;
	for (int i = 0; i < src_height; i++)
	{
		memcpy(dst_ptr, src_ptr, src_line_size);
		dst_ptr += dst_line_size;
		src_ptr += src_line_size;
	}
	return TRUE;
}


int blendScanline(BYTE* dst, BYTE* src, int src_line_size, int dst_line_size, int src_height, int backgroundWeigh) {
	BYTE* dst_ptr = dst;
	BYTE* src_ptr = src;
	for (int i = 0; i < src_height; i++)
	{
		for (int j = 0; j < src_line_size; j++)
		{
			BYTE src_byte = src_ptr[j];
			BYTE dst_byte = dst_ptr[j];
			BYTE v = (src_byte * (255 - backgroundWeigh) + dst_byte * backgroundWeigh) / 255;

			dst_ptr[j] = v;
		}

		dst_ptr += dst_line_size;
		src_ptr += src_line_size;
	}
	return TRUE;
}



int blendPixel(BYTE* dst, BYTE* src, int src_line_size, int dst_line_size, int src_height, int backgroundWeigh) {
	if (backgroundWeigh)
	{
		return blendScanline(dst, src, src_line_size, dst_line_size, src_height, backgroundWeigh);
	}
	else {
		return copyScanline(dst, src, src_line_size, dst_line_size, src_height);
	}
	return 0;
}


BOOL CALLBACK myEnumWindowsProc(HWND hwnd, LPARAM lParam)
{
	/*
	* Remarks
	The EnumWindows function does not enumerate child windows,
	with the exception of a few top-level windows owned by the
	system that have the WS_CHILD style.
	*/
	//    EnumChildWindows(hwnd, EnumChildProc, lParam); 接着获取子窗口
	int result = 0;

	HWND hwnd_owner = GetWindow(hwnd, GW_OWNER);
	int isvisible = IsWindowVisible(hwnd);

	if (hwnd_owner == 0 && isvisible)
	{
		wchar_t title[256];
		GetWindowTextW(hwnd, title, 256);

		wchar_t classname[256];
		GetClassName(hwnd, classname, 256);

		if (wcscmp(classname, L"Progman") == 0 || wcscmp(classname, L"WorkerW") == 0)
		{
			return false;
		}

		WCHAR procsid[MAX_PATH];
		WCHAR procimage[MAX_PATH];
		ULONG sessionid = 0;
		WCHAR procboxname[64] = { 0 };
		DWORD dwProcessID = 0;

		result = GetWindowThreadProcessId(hwnd, &dwProcessID);
		result = SbieApi_QueryProcess((HANDLE)dwProcessID, procboxname, procimage, procsid, &sessionid);

		// 		mylog(L"window class name:%ws,title:%ws,visible:%d,owner:%x,pid:%d,boxname:%ws,session id:%d,procsid:%ws,image:%ws\r\n",
		// 			classname, title, isvisible, hwnd_owner, dwProcessID, procboxname, sessionid, procsid, procimage);

		if (procboxname[0] == 0)
		{
			//mylog(L"process:%ws,pid:%d already in box:%ws\r\n", procimage, msg->process_id, procboxname);
			return FALSE;
		}

		myCreateIcon(hwnd, 0);
	}

	return true;
}


// int __stdcall iconthread() {
// 	while (TRUE)
// 	{
// 		Sleep(2000);
// 		EnumWindows(myEnumWindowsProc, 0);
// 	}
// }


HICON getAppIcon(HWND hwnd) {

	HICON hicon_app = reinterpret_cast<HICON>(::SendMessageW(hwnd, WM_GETICON, ICON_BIG, 0));

	if (hicon_app == 0) {
#ifdef _WIN64
		hicon_app = (HICON)GetClassLongPtr(hwnd, GCLP_HICON);
#else
		hicon_app = (HICON)GetClassLongPtr(hwnd, GCL_HICON);
#endif	
	}

	if (hicon_app == 0) {
		hicon_app = ::LoadIcon(GetModuleHandleW(0), MAKEINTRESOURCE(0));
	}

	if (hicon_app == 0) {
		hicon_app = ::LoadIcon(0, IDI_APPLICATION);
	}
	return hicon_app;
}





/*
CreateDIBSection 该函数创建应用程序可以直接写入的、与设备无关的位图（DIB）
使用这个函数前，要先建立兼容的内存设备上下文m_hdc，准备好位图信息BITMAPINFO m_bmi;
它怎么使用内存呢？ 这个函数会在m_hdc内存块上将void * m_pImageData指向一块信息头后面的区域，指定为数据区。
事实上还没分配内存空间，指针后面的m_ZoomSize.x*m_ZoomSize.x*4大小的空间并没有为数据预留，在真正赋值的时候才会占用空间。
那么怎么释放这些空间呢？不是自己分配的就不用自己释放，系统在释放m_hdc这个内存设备上下文的时候就会释放了。
但是要记得在适当的地方用DeleteDC(m_hdc)释放掉m_hdc哦。如果m_hbitmap被selectobject，记住要先将其换出,DeleteDC(m_hdc)才能把那块数据区域收回哦!
*/


char* back_icon_file_data = 0;




HICON myCreateIcon(HWND hwnd, HICON hicon)
{
	//__debugbreak();


	int result = 0;

	HICON h_myicon = (HICON)LoadImageW(g_dllModule, (WCHAR*)IDI_ICON1, IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);


	return 0;
	setOverLay(hwnd, h_myicon, (WCHAR*)L"Warning");

	// 	result = SendMessageW(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)h_myicon);
	// 	result = SendMessageW(hwnd, WM_SETICON, ICON_BIG, (LPARAM)h_myicon);

	return 0;

	DWORD dw = 0;

	HDC hdcScreen = GetDC(NULL);

	HICON hicon_app = 0;
	if (hicon == 0)
	{
		hicon_app = getAppIcon(hwnd);
	}
	else {
		hicon_app = hicon;
	}

	ICONINFO iconInfo_app;
	result = GetIconInfo(hicon_app, &iconInfo_app);
	BITMAP bmpIcon_app;
	result = GetObjectW(iconInfo_app.hbmColor, sizeof(BITMAP), &bmpIcon_app);
	if (bmpIcon_app.bmWidth % 8 || bmpIcon_app.bmHeight % 8 || bmpIcon_app.bmBitsPixel % 8)
	{
		return FALSE;
	}

#define ICON_FILE

#ifdef  ICON_FILE

	// 	HRSRC res = FindResourceW(g_dllModule, (WCHAR*)IDI_ICON1, RT_GROUP_ICON);
	// 	HGLOBAL resGlobal = LoadResource(g_dllModule, res);
	// 	DWORD size = SizeofResource(g_dllModule, res);
	// 	BYTE* ptr = (BYTE*)LockResource(resGlobal);

	HICON hicon_res = (HICON)LoadImageW(g_dllModule, (WCHAR*)IDI_ICON1, IMAGE_ICON, 16, 16, LR_DEFAULTCOLOR);
	//HICON hicon_res = LoadIconW(g_dllModule, (WCHAR*)IDI_ICON1);
	ICONINFO iconInfo_res;
	result = GetIconInfo(hicon_res, &iconInfo_res);

	HDC hdcResIcon = CreateCompatibleDC(hdcScreen);
	SelectObject(hdcResIcon, iconInfo_res.hbmColor);

	BITMAP bmp_res_icon;
	GetObjectW(iconInfo_res.hbmColor, sizeof(BITMAP), &bmp_res_icon);

	BITMAPINFO stback_icon_bmpinfo = { 0 };
	BITMAPINFOHEADER* back_icon_bmpinfo = &stback_icon_bmpinfo.bmiHeader;
	stback_icon_bmpinfo.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	stback_icon_bmpinfo.bmiHeader.biBitCount = bmp_res_icon.bmBitsPixel;
	stback_icon_bmpinfo.bmiHeader.biPlanes = bmp_res_icon.bmPlanes;
	stback_icon_bmpinfo.bmiHeader.biXPelsPerMeter = 0;
	stback_icon_bmpinfo.bmiHeader.biYPelsPerMeter = 0;
	stback_icon_bmpinfo.bmiHeader.biHeight = bmp_res_icon.bmHeight;
	stback_icon_bmpinfo.bmiHeader.biWidth = bmp_res_icon.bmWidth;
	stback_icon_bmpinfo.bmiHeader.biSizeImage = bmp_res_icon.bmHeight * bmp_res_icon.bmWidth * bmp_res_icon.bmBitsPixel / 8;

	BYTE* back_icon_pixel = (BYTE*) new char[stback_icon_bmpinfo.bmiHeader.biSizeImage + 0x1000];
	result = GetDIBits(hdcResIcon, iconInfo_res.hbmColor, 0, bmp_res_icon.bmHeight, back_icon_pixel, &stback_icon_bmpinfo, 0);
#else
	if (back_icon_file_data == 0)
	{
		WCHAR filename[MAX_PATH];
		GetModuleFileNameW(g_dllModule, filename, MAX_PATH);
		WCHAR* ptr = wcsrchr(filename, L'\\');
		if (ptr)
		{
			ptr[1] = 0;
			lstrcatW(filename, L"boxed_icon16.ico");
		}
		HANDLE hf_icon_back = CreateFileW(filename, GENERIC_READ, 0, 0, OPEN_EXISTING, 0, 0);
		if (hf_icon_back == INVALID_HANDLE_VALUE)
		{
			log(L"CreateFileW:%ws error", filename);
			return FALSE;
		}

		int back_icon_filesize = GetFileSize(hf_icon_back, 0);

		back_icon_file_data = new char[back_icon_filesize + 0x1000];

		result = ReadFile(hf_icon_back, back_icon_file_data, back_icon_filesize, &dw, 0);
		CloseHandle(hf_icon_back);
	}

	LPICONDIR back_icondir = (LPICONDIR)back_icon_file_data;
	LPICONDIRENTRY back_icondir_entry = (LPICONDIRENTRY)back_icondir->idEntries;
	BITMAPINFOHEADER* back_icon_bmpinfo = (BITMAPINFOHEADER*)(back_icon_file_data + sizeof(ICONDIR));
	BYTE* back_icon_pixel = (BYTE*)back_icon_bmpinfo + sizeof(BITMAPINFOHEADER);
	if (back_icondir_entry->bWidth % 8 || back_icondir_entry->bHeight % 8 || back_icondir_entry->wBitCount % 8)
	{
		return FALSE;
	}
	back_icon_bmpinfo->biHeight = back_icon_bmpinfo->biHeight / 2;

	// 	compressBmp(back_icon_pixel, back_icon_bmpinfo->biWidth*back_icon_bmpinfo->biBitCount / 8,
	// 		back_icon_bmpinfo->biBitCount/8, back_icon_bmpinfo->biHeight);
	// 	back_icon_bmpinfo->biWidth = back_icon_bmpinfo->biWidth / 2;
	// 	back_icon_bmpinfo->biHeight = back_icon_bmpinfo->biHeight / 2;
	// 	back_icon_bmpinfo->biSizeImage = back_icon_bmpinfo->biSizeImage / 2;
	// 
	// 	back_icondir_entry->bWidth = back_icondir_entry->bWidth / 2;
	// 	back_icondir_entry->bHeight = back_icondir_entry->bHeight / 2;
	// 	back_icondir_entry->dwBytesInRes = back_icondir_entry->dwBytesInRes / 2;

	int icon_width = 0;
	int icon_height = 0;
	if (back_icon_bmpinfo->biWidth > bmpIcon_app.bmWidth)
	{
		icon_width = back_icon_bmpinfo->biWidth;
	}
	else {
		icon_width = bmpIcon_app.bmWidth;
	}

	if (back_icon_bmpinfo->biHeight > bmpIcon_app.bmHeight)
	{
		icon_height = back_icon_bmpinfo->biHeight;
	}
	else {
		icon_height = bmpIcon_app.bmHeight;
	}
#endif


	BITMAPINFO bmpinfo_addicon = { 0 };
	bmpinfo_addicon.bmiHeader.biSize = back_icon_bmpinfo->biSize;
	bmpinfo_addicon.bmiHeader.biBitCount = back_icon_bmpinfo->biBitCount;
	bmpinfo_addicon.bmiHeader.biPlanes = back_icon_bmpinfo->biPlanes;
	bmpinfo_addicon.bmiHeader.biXPelsPerMeter = back_icon_bmpinfo->biXPelsPerMeter;
	bmpinfo_addicon.bmiHeader.biYPelsPerMeter = back_icon_bmpinfo->biYPelsPerMeter;
	bmpinfo_addicon.bmiHeader.biHeight = back_icon_bmpinfo->biHeight;			// icon_height;
	bmpinfo_addicon.bmiHeader.biWidth = back_icon_bmpinfo->biWidth;				// icon_width;
	bmpinfo_addicon.bmiHeader.biSizeImage = back_icon_bmpinfo->biSizeImage;		// icon_height*icon_width*bmpinfo_addicon.bmiHeader.biBitCount / 8;

	if (0)
	{
		HDC hdcBackground = CreateCompatibleDC(hdcScreen);

		BYTE* background_pixel_buffer = 0;

		HBITMAP hbmp_Background = CreateDIBSection(hdcBackground, (BITMAPINFO*)&bmpinfo_addicon,
			DIB_RGB_COLORS, (void**)&background_pixel_buffer, NULL, 0);

		//memcpy(background_pixel_buffer, back_icon_pixel, back_icondir_entry->bHeight* back_icondir_entry->bWidth* back_icondir_entry->wBitCount / 8);
		memset(background_pixel_buffer, 0xff,
			bmpinfo_addicon.bmiHeader.biHeight * bmpinfo_addicon.bmiHeader.biWidth * bmpinfo_addicon.bmiHeader.biBitCount / 8);
		copyScanline(background_pixel_buffer, back_icon_pixel, back_icon_bmpinfo->biWidth * back_icon_bmpinfo->biBitCount / 8,
			bmpinfo_addicon.bmiHeader.biWidth * bmpinfo_addicon.bmiHeader.biBitCount / 8, back_icon_bmpinfo->biHeight);
		SelectObject(hdcBackground, hbmp_Background);
		//SetDIBits(hdcBackground,hbmp_Background, 0,back_icondir_entry->bHeight, &background_pixel_buffer, (BITMAPINFO*)back_icon_bmpinfo,0 );

		DeleteDC(hdcBackground);
		DeleteObject(hbmp_Background);
	}

	//DrawIconEx
	//CreateIcon
	//CreateBitmap

	HDC hdc_tmp = CreateCompatibleDC(hdcScreen);
	HBITMAP hbmp_tmp = iconInfo_app.hbmColor;
	SelectObject(hdc_tmp, hbmp_tmp);

	BITMAP bmp_tmp;
	result = GetObjectW(hbmp_tmp, sizeof(BITMAP), &bmp_tmp);

	BITMAPINFO bmpinfo_app = { 0 };
	bmpinfo_app.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	bmpinfo_app.bmiHeader.biBitCount = bmpIcon_app.bmBitsPixel;
	bmpinfo_app.bmiHeader.biPlanes = bmpIcon_app.bmPlanes;
	bmpinfo_app.bmiHeader.biXPelsPerMeter = 0;
	bmpinfo_app.bmiHeader.biYPelsPerMeter = 0;
	bmpinfo_app.bmiHeader.biHeight = bmpIcon_app.bmHeight;
	bmpinfo_app.bmiHeader.biWidth = bmpIcon_app.bmWidth;
	bmpinfo_app.bmiHeader.biSizeImage = bmpinfo_app.bmiHeader.biHeight * bmpinfo_app.bmiHeader.biWidth * bmpinfo_app.bmiHeader.biBitCount / 8;

	BYTE* pixel_tmp_buf = (BYTE*)new char[bmpinfo_app.bmiHeader.biSizeImage + 0x1000];
	result = GetDIBits(hdc_tmp, hbmp_tmp, 0, bmpIcon_app.bmHeight, pixel_tmp_buf, &bmpinfo_app, 0);

	// 	HDC hdcApp_icon_mask = CreateCompatibleDC(hdcScreen);
	// 	SelectObject(hdcApp_icon_mask, iconInfo_app.hbmMask);
	// 	BYTE* pixel_icon_mask = (BYTE*)new char[bmpIcon_app.bmWidth * bmpIcon_app.bmHeight * bmpIcon_app.bmBitsPixel / 8 + 0x1000];
	// 	result = GetDIBits(hdcApp_icon_mask, iconInfo_app.hbmMask, 0, bmpIcon_app.bmHeight, pixel_icon_mask, &bmpinfo_app, 0);

	HDC hdcback_icon_mask = CreateCompatibleDC(hdcScreen);
	SelectObject(hdcback_icon_mask, iconInfo_res.hbmMask);
	BYTE* pixel_icon_res_mask = (BYTE*)new char[bmp_res_icon.bmWidth * bmp_res_icon.bmHeight * bmp_res_icon.bmBitsPixel / 8 + 0x1000];
	result = GetDIBits(hdcback_icon_mask, iconInfo_res.hbmMask, 0, bmp_res_icon.bmHeight, pixel_icon_res_mask, &stback_icon_bmpinfo, 0);

	if (bmpIcon_app.bmWidth < bmpinfo_addicon.bmiHeader.biWidth || bmpIcon_app.bmHeight < bmpinfo_addicon.bmiHeader.biHeight)
	{
		blendPixel(pixel_tmp_buf, pixel_icon_res_mask, back_icon_bmpinfo->biWidth * back_icon_bmpinfo->biBitCount / 8,
			bmpinfo_app.bmiHeader.biWidth * bmpinfo_app.bmiHeader.biBitCount / 8, back_icon_bmpinfo->biHeight, PIXERL_BLEND_APP_ICON_WEIGH);

		blendPixel(pixel_tmp_buf, back_icon_pixel, back_icon_bmpinfo->biWidth * back_icon_bmpinfo->biBitCount / 8,
			bmpinfo_app.bmiHeader.biWidth * bmpinfo_app.bmiHeader.biBitCount / 8, back_icon_bmpinfo->biHeight, PIXERL_BLEND_APP_ICON_WEIGH);
	}
	else
	{
		blendPixel(pixel_tmp_buf, pixel_icon_res_mask, back_icon_bmpinfo->biWidth * back_icon_bmpinfo->biBitCount / 8,
			bmpinfo_app.bmiHeader.biWidth * bmpinfo_app.bmiHeader.biBitCount / 8, back_icon_bmpinfo->biHeight, 0);

		blendPixel(pixel_tmp_buf, back_icon_pixel, back_icon_bmpinfo->biWidth * back_icon_bmpinfo->biBitCount / 8,
			bmpinfo_app.bmiHeader.biWidth * bmpinfo_app.bmiHeader.biBitCount / 8, back_icon_bmpinfo->biHeight, 0);
	}
	SetDIBits(hdc_tmp, hbmp_tmp, 0, bmpIcon_app.bmHeight, pixel_tmp_buf, &bmpinfo_app, 0);

	// 	BLENDFUNCTION bf = { 0 };
	// 	bf.BlendOp = AC_SRC_OVER;
	// 	bf.BlendFlags = 0;
	// 	bf.AlphaFormat = 0;
	// 	bf.SourceConstantAlpha = PIXERL_BLEND_APP_ICON_WEIGH;
	// 	result = AlphaBlend(hdc_tmp , 0, 0, back_icondir_entry->bWidth, back_icondir_entry->bHeight, hdcBackground,
	// 	 		0, 0, back_icondir_entry->bWidth, back_icondir_entry->bHeight, bf);


	HPEN hpen = CreatePen(PS_SOLID, 1, 0x00ff00);
	HPEN hpenOld = (HPEN)SelectObject(hdc_tmp, hpen);
	HBRUSH nullbrush = (HBRUSH)GetStockObject(NULL_BRUSH);
	SelectObject(hdc_tmp, nullbrush);

	//	POINT p = { 0 };
	// 	MoveToEx(hdc_tmp, 0, 0, &p);
	// 	LineTo(hdc_tmp, 0, bmpinfo_app.bmiHeader.biHeight);
	// 	LineTo(hdc_tmp, bmpinfo_app.bmiHeader.biWidth, bmpinfo_app.bmiHeader.biHeight);
	// 	LineTo(hdc_tmp, bmpinfo_app.bmiHeader.biWidth, 0);
	// 	LineTo(hdc_tmp, 0, 0);
	// 	HBRUSH hbrush = CreateSolidBrush(0x0);
	// 	HBRUSH hbrushOld = (HBRUSH)SelectObject(hdc_tmp, hbrush);
	//Rectangle(hdc_tmp, 0, 0, bmpIcon_app.bmWidth, bmpIcon_app.bmHeight);
	//Rectangle(hdc_tmp, 0, bmpinfo_addicon.bmiHeader.biHeight, bmpinfo_addicon.bmiHeader.biWidth, bmpIcon_app.bmHeight);
	// 	Rectangle(hdc_tmp, 0, 0, bmpinfo_addicon.bmiHeader.biWidth, bmpinfo_addicon.bmiHeader.biHeight);
	// 	Rectangle(hdc_tmp, 0, 0, bmpinfo_addicon.bmiHeader.biWidth, bmpinfo_addicon.bmiHeader.biHeight);
	// 	SelectObject(hdc_tmp, hbrushOld);

	SelectObject(hdc_tmp, hpenOld);
	// 	DeleteObject(hbrush);
	DeleteObject(hpen);
	DeleteObject(nullbrush);

	// Icons require masks to indicate transparent and opaque areas. Since this
	// simple example has no transparent areas, we use a fully opaque mask.
// 	char* lpicon_mask_bits = 0;
// 	HBITMAP hbmp_icon_Mask = CreateDIBSection(hdcScreen, (BITMAPINFO*)&bmpinfo_app, DIB_RGB_COLORS, (void**)&lpicon_mask_bits, NULL, 0);
// 	memset(lpicon_mask_bits, 0xff, bmpinfo_app.bmiHeader.biHeight * bmpinfo_app.bmiHeader.biWidth * bmpinfo_app.bmiHeader.biBitCount / 8);

	ICONINFO iconinfo_new = { 0 };
	iconinfo_new.fIcon = TRUE;
	iconinfo_new.hbmMask = iconInfo_app.hbmMask;
	iconinfo_new.hbmColor = hbmp_tmp;
	HICON hIconNew = CreateIconIndirect(&iconinfo_new);

	result = SendMessageW(hwnd, WM_SETICON, ICON_SMALL, (LPARAM)hIconNew);
	result = SendMessageW(hwnd, WM_SETICON, ICON_BIG, (LPARAM)hIconNew);
	result = SendMessageW(hwnd, WM_SETICON, ICON_SMALL2, (LPARAM)hIconNew);

	// 	SendMessage(GetWindow(hwnd, GW_OWNER), WM_SETICON, ICON_BIG, (LPARAM)hIconNew);
	// 	SendMessage(GetWindow(hwnd, GW_OWNER), WM_SETICON, ICON_SMALL, (LPARAM)hIconNew);

	ReleaseDC(NULL, hdcScreen);

	DeleteDC(hdc_tmp);
	DeleteObject(hbmp_tmp);
	//DeleteObject(hbmp_icon_Mask);
	DeleteObject(iconInfo_app.hbmColor);
	DeleteObject(iconInfo_app.hbmMask);

	//DeleteObject(bmpIcon_app);
	DeleteDC(hdcResIcon);

	DeleteDC(hdcback_icon_mask);
	DeleteObject(hicon_res);

	delete[]pixel_icon_res_mask;

	delete[] pixel_tmp_buf;

	delete[]back_icon_pixel;

	// 	NOTIFYICONDATA  nid = { 0 };
	// 	nid.cbSize = sizeof(nid);
	// 	nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
	// 	lstrcpyW(nid.szTip, L"我的任务栏图标");
	// 	nid.hWnd = hwnd;
	// 	nid.uCallbackMessage = 0;
	// 	nid.hIcon = hIcon;
	// 	result = Shell_NotifyIcon(NIM_MODIFY, &nid);

	DeleteObject(hIconNew);

	//mylog(L"mycreateicon complete");

	return hIconNew;
}


#include <ShObjIdl.h>


VOID setOverLay(HWND hWnd, HICON hIcon, const WCHAR* description)
{


	ITaskbarList3* ptbl;

	HRESULT hr = CoCreateInstance(CLSID_TaskbarList, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&ptbl));
	if (SUCCEEDED(hr)) {

		// Attach the toolbar to the thumbnail.
		hr = ptbl->SetOverlayIcon(hWnd, hIcon, description);


	}
	else {

	}
	ptbl->Release();

	//mylog(L"setOverLay end");
}

VOID resetOverLay(HWND hWnd)
{
	//mylog(L"resetOverLay start");

	ITaskbarList3* ptbl;

	HRESULT hr = CoCreateInstance(CLSID_TaskbarList, NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&ptbl));

	if (SUCCEEDED(hr)) {
		// Attach the toolbar to the thumbnail.
		hr = ptbl->SetOverlayIcon(hWnd, NULL, (const WCHAR*)L"");

		//mylog(L"resetOverLay SetOverlayIcon result:%d error code:%d", hr, GetLastError());
	}
	else {
		//mylog(L"resetOverLay CoCreateInstance error code:%d", GetLastError());
	}
	ptbl->Release();

	//mylog(L"resetOverLay end");
}
satadriver
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
如何合并两个图标库
(づ｡◕‿‿◕｡)づgigi奋斗在前端和刷题中╮(╯﹏╰)╭
11-01 6407
最近在项目中碰到了要合并两个icon库的需求：我们项目本来用的是bootstrap提供的glyphicons，但是现在需要用一个别的库的icon，想把这两个库合并在一起供项目使用，研究了一番后整理个教程吧~利用https://icomoon.io/app/#/select 这一工具进行这两种图标库的合并，操作步骤如下：导入图标库点击页面左上角的import icons，分别导入我们本地的两个字体，注
windows 控制台图标加载
evil_darker的专栏
06-22 651
#include "stdafx.h"#include #include "resource.h"#include int _tmain(int argc, _TCHAR* argv[]){    HWND   hwnd=GetConsoleWindow();       SendMessage(hwnd,WM_SETICON,ICON_SMALL,(LPARA
Windows获取系统托盘图标
风斜夜的博客
12-01 3521
         对于Win7系统，程序的托盘图标最终是放置在和XP一样的ToolbarWindow32工具条窗口，但是有两个地方，同样是ToolbarWindow32工具条窗口，父窗口是不一样的。在右下角可见区域，ToolbarWindow32工具条窗口的父窗口是SysPager窗口，遍历方法同XP一样。对于掩藏的ToolbarWindow32工具条窗口，必须通过点击桌面右下角的可见区域左边的...
Windows数据类型探幽
小生物语
04-21 2356
Windows数据类型(一) 　　由微软Windows操作系统所支持的各种数据类型是用来定义函数的返回值、函数和消息的参数以及结构体成员（因为Win32程序是用C语言来编写，所以没有“类”这个概念）的。这些数据类型定义了上述元素的尺码（在内存中的，也就是占用内存的字节数）和含义。笔者以前一直不太注意这些东西，结果在程序设计时可谓步履维艰。不同类型的常/变量，在程序用扮演的角色相去甚远，了解
图标合成工具......
05-16
图标合成工具，把多个图标合成bmp，或者分成多个图标。
快捷方式图标去箭头
02-03
桌面快捷方式的图标是箭头图标和原始快捷方式图标合成的新图标。 有污染的图标自然不是理想的代替箭头的图标。 而系统自带的透明图标会带来黑方块遮挡这个后遗症。 猜测用透明图标的话，在某一特定时刻系统会检测到...
Mico and Sico:将图像文件合并为一个 Windows 图标 (.ico) 文件。-开源
07-12
在IT行业中，Windows图标（.ico）文件是一种特殊格式，用于在操作系统中显示应用程序和文件的图标。这种格式允许在一个文件中包含多个不同尺寸和颜色深度的图像，以适应不同的屏幕分辨率和显示需求。"Mico"和"Sico...
讯飞离线合成语音.zip
12-24
同时，“程序图标都是MFC默认的图标”表明该程序可能使用了Microsoft Foundation Classes (MFC)库来开发，MFC是微软提供的一种C++类库，用于构建Windows应用程序，它简化了UI设计和Windows API的使用。 “语音合成...
odc.rar_iszqr_语音合成与识别
09-20
综合以上信息，我们可以推测这个项目是一个使用C#语言开发的Windows应用程序，它实现了语音合成和识别功能，并且利用多线程技术优化了性能。用户界面（UI）由至少两个窗体构成，源代码组织良好，遵循了良好的编程...
delphi合成图片.rar
06-16
在本项目中，"delphi合成图片.rar" 是一个Delphi编程环境下的工程压缩包，主要目的是教初学者如何在Delphi中进行图像处理，尤其是图片合成和转换为BMP格式。Delphi是一款强大的Windows应用程序开发工具，它使用...
QQiphone在线图标合成
01-26
零工具合成QQ的iphone在线图标，不用ps，不用装软件，只有一个文件，开源哦亲
css图标合并——ClipPath Sprites技术
朝阳39的博客
11-10 831
为了方便图标管理，往往会把众多小图标合在一个SVG元素中，这种处理技术称为“ClipPath Sprites技术”。 实现原理：使用clip-path对合并后的内联svg图标进行裁剪显示。 1. 合并图标得到ClipPath Sprites代码 打开图标合并工具 https://www.zhangxinxu.com/sp/svgo/ 通过上传或粘贴的方式，将原始svg小图标添加到合并工具中，工具会自动生成ClipPath Sprites代码 原始svg小图标可以从阿里图标库 、Font Awesome
推荐一个在线的icon图片合成工具（CSS Sprite）
菜菜的博客
12-20 2781
作为一枚前端coder，拿到设计稿时便已构思好了这个页面的布局，要用到的元素，UI该怎么切图，怎么实现性能最优，这些都是一个前端在coding中必须把控好的原则。 前端性能优化有很多入口，如今一些网站丰富多彩，绚丽夺目，图片元素占了很大一部分比例，所以处理好图片的加载、减少网络请求是非常有必要的，CSS Sprite就是一种方式。 CSS Sprite（c...
`kill -9` 和 `pkill`
最新发布
喝醉酒的小白
08-13 248
提供了更多的灵活性和选择性，可以发送不同的信号并针对一组进程执行操作。在实际使用中，应根据具体需求和场景选择合适的命令。是一个简单直接的命令，用于强制杀死指定的单个进程，而。
Leetcode刷题：链表
JTB__JJ的博客
08-10 289
这个题解题思路还是挺有意思的用双指针，快指针一次走两格，慢指针一次走一格。这个的证明用举例子就行，他们两个再相遇之前的几种情况举出来就行。然后根据下面这幅图可以列出两个指针时间相等的式子。这里n必是大于等于1的逻辑思考一下就知道了。根据得出来的式子可以知道，让一个指针位于起点一个指针位于相遇点，以每次一格的速度往前走，最后会在环形入口节点相遇。思路就是自己造一个虚拟节点避免掉要再考虑头节点的值=target值的特殊情况。关键点在于对头节点的处理。
C#中的通信（写单线圈和写多线圈）
weixin_64532720的博客
08-08 371
【代码】C#中的通信（写单线圈和写多线圈）
C语言:基于单链表实现通讯录项目
枫叶栀子的博客
08-08 719
之前我们用顺序表实现了通讯录，这次我们使用单链表实现。我们定义五个文件，是包含了单链表的结构，及各类库文件声明，各个单链表接口声明用于实现各类单链表接口Contact.h是包含了通讯录的结构，各个通讯录接口声明Contact.c用于实现通讯录接口test.c用作测试和实现通讯录的菜单，控制增删查改的选项。
Spring事务管理：原理与五种配置方式解析
"本文将深入探讨Spring事务的原理以及如何通过五种不同的方式来配置Spring事务，包括编程式和声明式事务的实现方法。" 在Spring框架中，事务管理是核心功能之一，它确保了数据操作的一致性和完整性。Spring事务管理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值