我的DUILIB常用库

最新推荐文章于 2021-07-23 17:06:49 发布
最新推荐文章于 2021-07-23 17:06:49 发布
阅读量1k 收藏
点赞数
分类专栏： C/C++ Windows 文章标签： duilib 库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Meta_Cpp/article/details/48548363
版权

头文件:

#pragma once

//
// MyLib V1.0
// 
// 适用字符集: Unicode
//

#if USE_MFC 
	typedef CString String;
	#define MYTRACE TRACE
#else // DuiLib
	typedef CDuiString String;
	#define MYTRACE DUI__Trace 
#endif

namespace MyLib
{
	//
	// 当前应用程序路径
	extern String MODULE_PATH_WITHBS;	// 带反斜杠
	extern String MODULE_PATH_NOBS;	// 不带反斜杠
	extern std::string ANSI_MODULE_PATH_WITHBS;
	extern std::string ANSI_MODULE_PATH_NOBS;
	//
	// 初始化应用程序路径变量
	void InitModulePaths();


	//
	// 获取程序的运行完整路径
	// 参数:
	//		bBkSlash: 路径末尾是否加"\", 默认不加
	//		module: 程序模块, 默认NULL, 当前程序
	// 返回值:
	//		完整路径
	//
	String GetModulePath(BOOL bBkSlash = FALSE, HMODULE module = NULL); 

	//
	// 获取程序的运行完整路径ANSI
	// 参数:
	//		bBkSlash: 路径末尾是否加"\", 默认不加
	//		module: 程序模块, 默认NULL, 当前程序
	// 返回值:
	//		完整路径ANSI
	//
	std::string GetModulePathAnsi(BOOL bBkSlash = FALSE, HMODULE module = NULL); 

	//
	// 窗口句柄获取结构体
	typedef struct tagWNDINFO
	{
		DWORD	dwProcessId;	// 进程ID
		HWND	hWnd;			// 存放所获取的句柄	
		HWND	hParWnd;		// 父窗口句柄(获取子窗口句柄)
		int		nType;			// 获取句柄类型
		String  strClass;		// 控件类型
		String  strName;		// 控件名称
	} WNDINFO, *LPWNDINFO;
	enum 
	{
		WND_ENUM_VISIBLE = 0,			// 窗口可见
		WND_ENUM_NAME  = 1,				// 窗口名字完全匹配
		WND_ENUM_CLASS = 2,				// 窗口类型完全匹配
		WND_ENUM_NAMECLASS = 3,			// 窗口名字类型完全匹配
		WND_ENUM_NAME_LIKE = 4,			// 窗口名字部分匹配
		WND_ENUM_CLASS_LIKE = 5,		// 窗口类型部分匹配
		WND_ENUM_NAMECLASS_LIKE = 6,	// 窗口名字类型部分匹配
	};
	#define SYMBOL_NOT_FOUND (-1)

//
// 获取耗时

	//
	//	设置开始时间 
	// 
	void BeginTime();
	//
	//  设置结束时间
	void EndTime();
	//
	// 获取时间间隔
	// 返回值:
	//		
	
	enum
	{
		TIME_IN_MS,	// 毫秒
		TIME_IN_S,
	};
	DWORD GetTime(int nType = TIME_IN_MS);

	//
	// 根据程序名字获取进程ID
	// 参数:
	//		strProcess: 进程名, 如process.exe
	// 返回值:
	//		成功则返回进程ID, 失败返回-1
	//
	DWORD GetProcessIdByName(String strProcess);

	//
	// 默认窗口遍历函数
	// 参数:
	//		hWnd: EnumWindows/EnumChildWindows 所枚举得到的窗口句柄
	//		lParam: 传入的参数
	// 返回值:
	//		窗口不是所需的窗口返回TRUE, 否则返回FALSE
	//
	BOOL CALLBACK DefWndEnumProc(HWND hWnd, LPARAM lParam);

	//
	// 获取窗口句柄函数
	// 参数:
	//		pWndInfo: 窗口句柄获取结构体指针
	//		pEnumCallback: 回调函数, 默认为DefWndEnumProc
	// 返回值:
	//		成功返回对应HWND, 失败返回NULL
	//
	HWND GetProcessHwnd(LPWNDINFO pWndInfo, BOOL (CALLBACK *pEnumCallback)(HWND hWnd,LPARAM lParam) = DefWndEnumProc);

	//
	// 如果采用DuiLib, 仿MFC CFileFind的类
#if (!USE_MFC)
	class CFileFind
	{
	public:
		CFileFind() : m_hFile(INVALID_HANDLE_VALUE) {}
		BOOL FindFile(String strPath);
		BOOL FindNextFile();
		BOOL IsDirectory();
		BOOL IsDots();
		String GetFilePath();
		String GetFileName();
		void Close();
	private:
		String m_strPath;
		HANDLE m_hFile;
		WIN32_FIND_DATA m_win32FindData;
	};
#endif // !USE_MFC

	//
	// 字符转换: ANSI, UNICODE 

	//
	// UTF8的ANSI字符串转换为UNICODE字符串
	// 参数:
	//		szUtf8: ansi utf8字符串
	// 返回值:
	//		转换结果
	//
	String ANSI_to_UTF8(const char* szUtf8);

	//
	// ANSI字符串转换为GBK集UNICODE字符串
	// 参数:
	//		szAnsi: ansi字符串
	// 返回值:
	//		转换结果
	//
	String ANSI_to_GBK(const char *szAnsi);
	
	//
	// ANSI字符串转换为UNICODE字符串
	// 参数:
	//		szAnsi: ansi字符串
	// 返回值:
	//		转换后的UNICODE字符串
	//
	String ANSI_to_UNICODE(const char * szAnsi);

	//
	// UNICODE字符串转换为ANSI字符串
	// 参数:
	//		strUnicode: UNICODE字符串
	// 返回值:
	//		转换后的ansi字符串指针
	// 备注:
	//		使用后需要delete指针,　否则内存泄漏
	//
	char * UNICODE_to_ANSI(String strUnicode);

	//
	// UNICODE字符串转换为ANSI字符串
	// 参数:
	//		strUnicode: UNICODE字符串
	//		strRet: 要存储的string
	// 返回值:
	//		无,解决内存泄漏问题
	//
	void UNICODE_to_ANSI(String strUnicode, string &strRet);


	//
	// ANSI字符串转换为UTF-8 UNICODE字符串
	// 参数:
	//		szAnsi: ANSI字符串
	// 返回值:
	//		转换后的ansi字符串指针
	// 备注:
	//		使用后需要delete指针,　否则内存泄漏
	//
	String  Char_To_UTF8(const char *szAnsi);

	//
	// 执行一条DOS命令
	// 参数:
	//		strCmd: DOS命令
	// 返回值:
	//		执行成功TRUE,否则FALSE
	//
	BOOL MyCreatePipeProcess(String strCmd);

	//
	// 执行一条DOS命令并将结果保存到字符串参数中
	// 参数:
	//		strCmd: DOS命令
	//		strResult: 执行结果
	// 返回值:
	//		执行成功TRUE,否则FALSE
	//
	BOOL MyCreatePipeProcess(String strCmd, String &strResult);

	//
	// 执行一条DOS命令并将结果写入文件中
	// 参数:
	//		strCmd: DOS命令
	//		strResult: 执行结果
	// 返回值:
	//		执行成功TRUE,否则FALSE
	//
	BOOL MyCreatePipeProcessToFile(String strCmd, String strFile);

	//
	// 杀死进程
	// 参数:
	//		strExename: exe进程名
	// 返回值:
	//		无
	//
	void KillProcessByName(String strExename);

	//
	// 获取文件长度
	// 参数:
	//		strPath: 文件绝对路径
	// 返回值:
	//		文件大小(long)
	//
	long GetFileSize(String strPath);
	//
	// 去除字符串头尾的空白字符
	// 参数:
	//		str: 要去除空白字符的字符串
	// 返回值:
	//		返回去除空白字符后的字符串
	String CleanString(String str);
}; // namespace MyLib


实现文件:

#include "stdafx.h"
#include "MyLib.h"

#include <TlHelp32.h>

//
namespace MyLib
{

//
// 当前应用程序路径
String MODULE_PATH_WITHBS;	// 带反斜杠
String MODULE_PATH_NOBS;	// 不带反斜杠
std::string ANSI_MODULE_PATH_WITHBS;
std::string ANSI_MODULE_PATH_NOBS;

//
// 时间变量
SYSTEMTIME stBegin;
SYSTEMTIME stEnd;

String GetModulePath(BOOL bBkSlash /*= FALSE*/, HMODULE module /*= NULL*/)
{
	wchar_t wstrPath[MAX_PATH+1] = {0};

	DWORD dwRet = ::GetModuleFileNameW(module, wstrPath, MAX_PATH);
	ASSERT(dwRet > 0);	// 返回0代表失败

	// 返回如: E:\test\win.exe
	String strPath(wstrPath);
	int nPos = strPath.ReverseFind(TEXT('\\'));

	if (bBkSlash)
	{
		nPos += 1;
	}
	strPath = strPath.Left(nPos);

	return strPath;
}

std::string GetModulePathAnsi(BOOL bBkSlash /*= FALSE*/, HMODULE module /*= NULL*/)
{
	char strPath[MAX_PATH] = {0};
	DWORD dwRet = ::GetModuleFileNameA(module, strPath, MAX_PATH);
	
	std::string path(strPath);
	int nPos = path.find_last_of('\\');
	if (!bBkSlash)
	{
		return path.substr(0, nPos);
	}
	else
	{
		return path.substr(0, nPos+1);
	}
}

void InitModulePaths()
{
	MODULE_PATH_WITHBS = GetModulePath(TRUE);
	MODULE_PATH_NOBS = GetModulePath(FALSE);
	ANSI_MODULE_PATH_WITHBS = GetModulePathAnsi(TRUE);
	ANSI_MODULE_PATH_NOBS = GetModulePathAnsi(FALSE);
}

//
// 计算短时耗时,
void BeginTime()
{
	GetLocalTime(&stBegin);
}

void EndTime()
{
	GetLocalTime(&stEnd);
}

DWORD GetTime(int nType)
{
	DWORD nMilliSecond = 0;

	nMilliSecond += (stEnd.wHour - stBegin.wHour) * 60 * 60 * 1000;
	nMilliSecond += (stEnd.wMinute - stBegin.wMinute) * 60 * 1000;
	nMilliSecond += (stEnd.wSecond - stBegin.wSecond) * 1000;
	nMilliSecond += (stEnd.wMilliseconds - stBegin.wMilliseconds);

	if (nType == TIME_IN_S)
	{
		return (nMilliSecond / 1000);
	}
	else
	{
		return nMilliSecond;
	}
}

DWORD GetProcessIdByName(String strProcess)
{
	HANDLE hSnapShot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS,0); // 进程快照
	PROCESSENTRY32 pe;
	pe.dwSize = sizeof(PROCESSENTRY32); 

	if (!Process32First(hSnapShot,&pe))  
	{          
		return -1;    
	}

	while (Process32Next(hSnapShot,&pe))  
	{               
		if(!strProcess.CompareNoCase(pe.szExeFile))    
		{  
			::CloseHandle(hSnapShot);
			return pe.th32ProcessID;
		} 
	}
	::CloseHandle(hSnapShot);
	return -1;
}

BOOL CALLBACK DefWndEnumProc(HWND hWnd, LPARAM lParam)
{
	DWORD dwProcId;
	GetWindowThreadProcessId(hWnd, &dwProcId);

	LPWNDINFO pInfo = (LPWNDINFO)lParam;
	if (dwProcId == pInfo->dwProcessId)
	{
		WCHAR wstrTmp1[257] = {0};
		WCHAR wstrTmp2[257] = {0};
		
		GetClassName(hWnd, (LPWSTR)wstrTmp1, 256);
		GetWindowText(hWnd, (LPWSTR)wstrTmp2, 256);

		String strClass = wstrTmp1;
		String strName = wstrTmp2;

		switch (pInfo->nType)
		{
		case WND_ENUM_NAME:			// 名称完全匹配
			if (!strName.CompareNoCase(pInfo->strName))
			{
				pInfo->hWnd = hWnd;
				return FALSE;
			}
			break;

		case WND_ENUM_NAME_LIKE:	// 名称部分匹配
			if (strName.Find(pInfo->strName) != SYMBOL_NOT_FOUND)
			{
				pInfo->hWnd = hWnd;
				return FALSE;
			}
			break;

		case WND_ENUM_CLASS:		// 类型完全匹配
			if (!strClass.CompareNoCase(pInfo->strClass))
			{
				pInfo->hWnd = hWnd;
				return FALSE;
			}
			break;

		case WND_ENUM_CLASS_LIKE:	// 类型部分匹配
			if (strClass.Find(pInfo->strClass) != SYMBOL_NOT_FOUND)
			{
				pInfo->hWnd = hWnd;
				return FALSE;
			}
			break;

		case WND_ENUM_NAMECLASS:	// 名称类型完全匹配
			if (!strName.CompareNoCase(pInfo->strName) &&
				!strClass.CompareNoCase(pInfo->strClass))
			{
				pInfo->hWnd = hWnd;
				return FALSE;
			}
			break;

		case WND_ENUM_NAMECLASS_LIKE:	// 名称类型部分匹配
			if ((strClass.Find(pInfo->strClass) != SYMBOL_NOT_FOUND) &&
				(strName.Find(pInfo->strName) != SYMBOL_NOT_FOUND))
			{
				pInfo->hWnd = hWnd;
				return FALSE;
			}
			break;

		case WND_ENUM_VISIBLE:			// 窗口可见
			if (IsWindowVisible(hWnd))
			{
				pInfo->hWnd = hWnd;
				return FALSE;
			}
			break;
		default:
			break;
		}
	}
	return TRUE;
}


HWND GetProcessHwnd(LPWNDINFO pWndInfo, BOOL (CALLBACK *pEnumCallback)(HWND hWnd,LPARAM lParam))
{
	pWndInfo->hWnd = NULL;
	if (pWndInfo->hParWnd == NULL)		// 查找父窗口
	{
		EnumWindows(pEnumCallback, (LPARAM)pWndInfo);
	}
	else	// 查找子窗口句柄 
	{
		EnumChildWindows(pWndInfo->hParWnd, pEnumCallback, (LPARAM)pWndInfo);
	}
	return pWndInfo->hWnd;
}



//
#if (!USE_MFC)
	BOOL CFileFind::FindNextFile()
	{
		if (m_hFile == INVALID_HANDLE_VALUE)
		{
			return FALSE;
		}
		return ::FindNextFileW(m_hFile, &m_win32FindData);
	}

	BOOL CFileFind::FindFile(String strPath)
	{
		int nPos = strPath.ReverseFind(TEXT('\\'));
		m_strPath = strPath.Left(nPos+1);

		m_hFile = FindFirstFile(strPath, &m_win32FindData);

		return  (m_hFile != INVALID_HANDLE_VALUE);
	}

	BOOL CFileFind::IsDirectory()
	{
		return m_win32FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY;
	}

	BOOL CFileFind::IsDots()
	{
		if (m_win32FindData.cFileName[0] == TEXT('.'))
		{
			return TRUE;
		}
		return FALSE;
	}

	String CFileFind::GetFileName()
	{
		String strFilename;
		strFilename = m_win32FindData.cFileName;
		return strFilename;
	}

	String CFileFind::GetFilePath()
	{
		String strPath;
		strPath = m_strPath;
		strPath += m_win32FindData.cFileName;
		return strPath;
	}

	void CFileFind::Close()
	{
		if (m_hFile != INVALID_HANDLE_VALUE)
		{
			FindClose(m_hFile);
		}
	}
#endif // !USE_MFC 
//

//
// 字符串转换 ANSI UNICODE

	String ANSI_to_UTF8(const char* szUtf8)
	{
		int wcsLen = ::MultiByteToWideChar(CP_UTF8, NULL, szUtf8, strlen(szUtf8), NULL, 0);

		wchar_t* wszString = new wchar_t[wcsLen + 1];

		::MultiByteToWideChar(CP_UTF8, NULL, szUtf8, strlen(szUtf8), wszString, wcsLen);

		wszString[wcsLen] = TEXT('\0');

		CDuiString ret = wszString;
		delete wszString;

		return ret;
	}
	String ANSI_to_GBK(const char *szAnsi)
	{
		const char* s = szAnsi; 
		int wcsLen = ::MultiByteToWideChar(CP_UTF8, NULL, s, strlen(s), NULL, 0);
		wchar_t* pwStr = new wchar_t[wcsLen + 1];

		::MultiByteToWideChar(CP_UTF8, NULL, s, strlen(s), pwStr, wcsLen);
		pwStr[wcsLen] = '\0';

		String strRet(pwStr);
		delete[] pwStr;

		return strRet;
	}

	String ANSI_to_UNICODE(const char * szAnsi)
	{
		//ansi 转换为UNICODE
		int wcsLen = ::MultiByteToWideChar(CP_ACP, NULL, szAnsi, strlen(szAnsi), NULL, 0);
		wchar_t * pwStr = new wchar_t[wcsLen + 1];

		::MultiByteToWideChar(CP_ACP, NULL, szAnsi, strlen(szAnsi), pwStr, wcsLen);
		pwStr[wcsLen] = '\0';

		String strRet(pwStr);
		delete []pwStr;

		return strRet;
	}

	char * UNICODE_to_ANSI(String strUnicode)
	{
		int nLen = ::WideCharToMultiByte(CP_ACP, NULL, (LPCWSTR)(strUnicode.GetData()),
							strUnicode.GetLength(), NULL, 0, NULL, NULL);

		char *szAnsi = new char [nLen + 1];

		::WideCharToMultiByte(CP_ACP,NULL, (LPCWSTR)strUnicode.GetData(),
						strUnicode.GetLength(), szAnsi, nLen, NULL, NULL);
		szAnsi[nLen] = '\0';

		return szAnsi;
	}

	void UNICODE_to_ANSI(String strUnicode, string &strRet)
	{
		char *pBuffer = UNICODE_to_ANSI(strUnicode);
		strRet = pBuffer;
		delete pBuffer;
	}

	String  Char_To_UTF8(const char *szAnsi)
	{
		int wcsLen = ::MultiByteToWideChar(CP_UTF8, NULL, szAnsi, strlen(szAnsi), NULL, 0);

		wchar_t* wszString = new wchar_t[wcsLen + 1];

		//转换
		::MultiByteToWideChar(CP_UTF8, NULL, szAnsi, strlen(szAnsi), wszString, wcsLen);

		//最后加上'\0'
		wszString[wcsLen] = '\0';

		int nLen = WideCharToMultiByte( CP_ACP, 0, wszString, -1, NULL, 0, NULL, NULL );
		if (nLen == 0)
		{			
			delete wszString;
			return _T("");
		}		
		String str(wszString);

		delete wszString;
		return str;
	}
//
// 创建进程 

	BOOL MyCreatePipeProcess(String strCmd)
	{
		String strRslt;
		return MyCreatePipeProcess(strCmd, strRslt);
	}

	BOOL MyCreatePipeProcessToFile(String strCmd, String strFile)
	{
		String strRslt;
		BOOL bRet = FALSE;

		bRet = MyCreatePipeProcess(strCmd, strRslt);
		if (!bRet)
		{
			return FALSE;
		}
		DeleteFile(strFile);
		
		FILE *pFile;
		_wfopen_s(&pFile, strFile, TEXT("w"));
		if (pFile == NULL)
		{
			return FALSE;
		}
		char *pBuffer = UNICODE_to_ANSI(strRslt);
		fwrite(pFile, 1, strlen(pBuffer), pFile);
		fclose(pFile);
		delete pBuffer;

		return TRUE;
	}

	BOOL MyCreatePipeProcess(String strCmd, String &strResult)
	{

		SECURITY_ATTRIBUTES sa;
		HANDLE hRead, hWrite;
		std::string result;
		sa.nLength = sizeof(SECURITY_ATTRIBUTES);
		sa.lpSecurityDescriptor = NULL;
		sa.bInheritHandle = TRUE;

		if (!CreatePipe(&hRead,&hWrite,&sa,0)) {
			strResult = TEXT("创建管道失败!");
			return FALSE;
		}

		STARTUPINFO si = {0};
		si.cb = sizeof(si);
		si.dwFlags |= STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES; // 使用默认的IO句柄

		si.hStdOutput = hWrite;
		si.hStdError = hWrite;

		si.wShowWindow = SW_HIDE;	//	显示控制台窗口  
		PROCESS_INFORMATION pi = {0};  
		MYTRACE(strCmd);
		if (!CreateProcess(NULL, (LPWSTR)strCmd.GetData(), NULL, NULL, TRUE, NULL, NULL, NULL, &si, &pi))  
		{  
			strResult = TEXT("创建进程失败!");
			return FALSE;
		}

		// 线程不再被访问,关闭句柄,不影响句柄运行
		CloseHandle(pi.hThread);	

		// 无限期等待线程执行完毕
		// 主线程被挂起
		WaitForSingleObject(pi.hProcess,INFINITE);

		DWORD dwExitCode;
		// 线程结束,获取返回码
		GetExitCodeProcess(pi.hProcess,
			&dwExitCode);

		// 关闭线程句柄
		CloseHandle(pi.hProcess);
		CloseHandle(hWrite);

		char buffer[257] = {0};
		DWORD dwBytesRead;
		strResult = TEXT("");
		while (ReadFile(hRead, buffer, 256, &dwBytesRead, NULL))
		{
			strResult += ANSI_to_UNICODE(buffer);
			memset(buffer, 0, 256);
		}
		MYTRACE(strResult);
		CloseHandle(hRead);

		return TRUE;
	}

	void KillProcessByName(String strExename)
	{
		String strCmd;

		strCmd = TEXT("taskkill /f /im ");
		strCmd += strExename;
		strCmd += TEXT(" /t");

		MyCreatePipeProcess(strCmd);
	}

	long GetFileSize(String strPath)
	{
		FILE *fp;
		_wfopen_s(&fp, strPath.GetData(), TEXT("rb"));
		if (fp == NULL)
		{
			return 0;
		}
		fseek(fp, 0, SEEK_END);
		long lRet = ftell(fp);
		fclose(fp);

		return lRet;
	}

	String CleanString(String str)
	{
		if (str.GetLength() < 2)
		{
			return str;
		}
		int eIndex = 0;
		TCHAR ch = 0;
		int sIndex = 0;

		for (int i = 0; i < str.GetLength(); i++)
		{
			ch = str.GetAt(i);
			if (ch > 0x20)	// 0x20: 空格符号s
			{
				sIndex = i;
				break;
			}
		}

		for (int i = str.GetLength()-1; i >= 0; i--)
		{
			ch = str.GetAt(i);
			if (ch > 0x20)
			{
				eIndex = i;
				break;
			}
		}

		if (eIndex <= sIndex)
		{
			return TEXT("XX");
		}

		str = str.Mid(sIndex, eIndex-sIndex+1);
		

		return str;
	}
}; // namespace MyLib


//


_Lulixue_
关注
专栏目录
DUILIB库中XML所以属性---详细
01-23
适合初学duilib的同学，里面有详细的属性列表及其解释
严重性 代码 说明 项目 文件 行 禁止显示状态 错误 C2065 “hFile”: 未声明的标识符 DuiLib E:\duilib\DuiLib\Control\UIGifAnim.cpp 328
wwhwayne的专栏
04-26 4978
duilib用高版本vs打开的时候会报如是错误 解决方案：把中文注释去掉就好了What the hell?
duilib底层机制剖析：窗体类与窗体句柄的关联
a539284554的博客
09-19 188
转载请说明原出处，谢谢~~ 看到群里朋友有人讨论WTL中的thunk技术，让我联想到了duilib的类似技术。这些技术都是为了解决c++封装的窗体类与窗体句柄的关联问题。 这里是三篇关于thunk技术的博客，不懂的朋友可以先看一下： WTL学习之旅(三)WTL中 Thunk技术本质(含代码) 深入剖析WTL—WTL框架窗口分析 （5...
Duilib中获取一段文字大小
u012335387的专栏
05-27 1912
记得以前在VC上开发的时候，遇到过怎么去求一段文字的高度，那时候的做法是先把文件写到内存上，然后获取内存的高度，今天查看Duilib的渲染引擎的时候，看到了另外以一种方法，故此记录下来。以便以后翻阅，后面有时间同样把以前的那种方法也贴上上来，以作比较。 SIZE CRenderEngine::GetTextSize( HDC hDC, CPaintManagerUI* pManager , LP
duilib开发基础：创建自定义控件的过程
积累点滴，保持自我
11-26 1093
转载自·http://blog.csdn.net/zhuhongshu/article/details/45362751 用Duilib开发界面时，很多情况下库自带的控件不满足需求，就需要基于Duilib建立自定义控件（自绘新的控件，或者用来封装win32的子窗体，来显示视频、网页等）。 在群里经常会有刚接触Duilib的朋友问题怎么建立自己的自定义控件，或者建立的控件无法正常创建出来。我简单写一篇博客，把创建自定义控件的完整过程，和一些注意事项说明一下。另外说一...
MFC使用duilib的几种方式
Troy的专栏
11-23 1万+
MFC流行了很多年的界面开发工具包，随着时代的进步，UI设计也有很大的改变，以前中规中矩的UI界面也开始变得美观漂亮起来。但是MFC受制于其绘制机制，做这些个性化的设计就力不从心了。最近几年随着DirectUI的流行，越来越多的产品开始使用这种技术来进行开发了。以DirectUI为技术基础的duilib类库，以其简单易用，功能不俗赢得了广大程序员的青睐。新的项目可以从你个头开始采用duilib开发
DuiLib_Ultimate-0.2_duilib_源码常用库.zip
10-25
DuiLib_Ultimate-0.2_duilib_源码常用库.zip文件包含了DuiLib的0.2版本，这个版本的源码以及一些常用的库，为开发者提供了一个完整的开发环境，便于深入理解和定制化。 DuiLib的核心特点包括： 1. **易于使用**：...
duilib_duilibTencent_duilib_tim_duilib微信_wechat_
09-29
2. **StdAfx.cpp** 和 **StdAfx.h**：标准预编译头文件，用于包含常用库和预处理指令，以减少编译时间。 3. **duilib.vcxproj.filters** 和 **duilib.vcxproj.user**：Visual Studio项目过滤器文件和用户配置文件，...
duilib打包及教程
05-31
最后，标签中的"vc"指的是Visual C++，它是开发Windows应用程序常用的IDE，与Duilib的集成非常紧密。通过Visual C++，你可以方便地调试代码，管理项目，以及进行打包操作。 总之，Duilib作为一个强大的界面库，为...
duilib开发工具
04-27
Duilib是一款基于Windows平台的UI库，主要用于快速开发桌面应用程序的用户界面。它采用C++编写，提供了丰富的控件和布局机制，使得开发者能够轻松创建出美观、高效的图形用户界面。下面将详细介绍duilib开发工具及其...
DuiLib属性
Lulixue的专栏
08-26 1826
duilib入门问题集
热门推荐
01-23 1万+
引入duilib时请确保引入头文件开始时先引入COMUTIL.H头文件 #include "COMUTIL.H" #include "UIlib.h" duilib基本程序结构 在stdafx.h文件中加入 #include "COMUTIL.H" #include "UIlib.h" using namespace DuiLib; #ifndef
《DuiLib学习》-- 基本知识及基本语法
qq_39579445的博客
07-23 822
1.#pragma comment 的使用方法 #pragma comment ( lib,"wpcap.lib" ) 表示链接wpcap.lib这个库。和在工程设置里写上链入wpcap.lib的效果一样（两种方式等价，或说一个隐式一个显式调用），不过这种方法写的 程序别人在使用你的代码的时候就不用再设置工程settings了。告诉连接器连接的时候要找ws2_32.lib，这样你就不用在linker的lib设置里指定这个lib了。 比如： ＃include "Mwic_32.h" #pragm
让Duilib多线程编程更容易
Skilla的专栏
11-18 9361
记得很久以前就听有人说过Duilib
Duilib在VS2019 UIGifAnim.cpp 下报错的问题--error C2065: “hFile”: 未声明的标识符
u012719076的博客
10-10 1751
源代码 从GitHub上下载的源代码，VS2013版本，然后我用VS2019编译的，平台升级后，报错error C2065: “hFile”: 未声明的标识符 最后在GitHub上找到答案了，把上图中绿色框中 中文注释去掉即可。。。。也是神奇呢 ...
DuiLib编译
Wite_Chen
11-01 1366
#编译环境（Win10+VS2015） DuiLib源代码下载地址 具体编译过程如下： 1、修改#include "StdAfx.h"为#include “…/StdAfx.h” 2、修改UIGifAnim.cpp属性值，去掉预编译头文件 3、编译提示hFile未声明，点击错误，在行323出空一行 编译好的DuiLib库下载 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值