HiEasyX  Ver 0.3.0
EasyX 全面扩展库
类 | 类型定义 | 枚举 | 函数 | 变量
HiEasyX 命名空间参考

类

class  Button
 按钮控件 更多...
 
class  Canvas
 画布 更多...
 
class  Container
 基础容器 更多...
 
class  ControlBase
 控件基础 更多...
 
class  DrawingProperty
 
struct  EasyWindow
 窗口 更多...
 
class  Gif
 
class  ImageBlock
 图像块 更多...
 
class  Layer
 图层 更多...
 
class  MouseDrag
 
class  MusicMCI
 
class  Page
 页控件 更多...
 
class  ProgressCtrl
 进度条控件 更多...
 
class  Scene
 
class  ScrollBar
 滚动条控件 更多...
 
class  Static
 静态（文本、图像）控件 更多...
 
class  SysButton
 系统按钮控件 更多...
 
class  SysCheckBox
 系统复选框控件 更多...
 
class  SysComboBox
 系统组合框控件 更多...
 
class  SysControlBase
 系统控件基础 更多...
 
class  SysEdit
 系统输入框控件 更多...
 
class  SysGroup
 系统控件分组标志 更多...
 
class  SysGroupBox
 
class  SysRadioButton
 系统单选框控件 更多...
 
class  SysStatic
 系统静态控件 更多...
 
class  Window
 窗口 更多...
 

类型定义

typedef void(* MESSAGE_PROC_FUNC) (ControlBase *_Ctrl, int _MsgId, ExMessage _ExMsg)
 控件消息处理函数 更多...
 
typedef void(* MESSAGE_PROC_FUNC_CLASS) (void *_This, ControlBase *_Ctrl, int _MsgId, ExMessage _ExMsg)
 支持静态类函数作为控件消息处理函数 更多...
 

枚举

enum  LayerOrder {
  LAYERORDER_BOTTOM_MOST, LAYERORDER_BOTTOM, LAYERORDER_NORMAL, LAYERORDER_TOP,
  LAYERORDER_TOP_MOST
}
 特殊图层顺序标识 更多...
 
enum  CtrlMessage {
  CM_OTHER, CM_HOVER, CM_HOVER_OVER, CM_PRESS,
  CM_PRESS_OVER, CM_CLICK, CM_DOUBLE_CLICK, CM_FOCUS,
  CM_FOCUS_OVER
}
 控件基础 更多...
 
enum  SysControlType {
  SCT_Unknown, SCT_Group, SCT_GroupBox, SCT_Static,
  SCT_Button, SCT_CheckBox, SCT_RadioButton, SCT_Edit,
  SCT_ComboBox
}
 支持的系统控件类型 更多...
 
enum  DrawMode {
  DM_Real, DM_Normal, DM_Fast, DM_VeryFast,
  DM_Fastest
}
 

函数

COLORREF MixAlphaColor (COLORREF cDst, COLORREF cSrc, bool isCalculated, BYTE alpha=255)
 根据透明度混合颜色 更多...
 
void CopyImage_Alpha (int x, int y, DWORD *pDst, int wDst, int hDst, DWORD *pSrc, int wSrc, int hSrc, RECT crop, BYTE alpha, bool bUseSrcAlpha, bool isCalculated)
 
IMAGE RotateImage_Alpha (IMAGE *pImg, double radian, COLORREF bkcolor=BLACK)
 旋转图像（保留透明信息，自适应大小） 更多...
 
IMAGE ZoomImage_Rough_Alpha (IMAGE *srcimg, int width, int height=0)
 缩放图像（粗糙的、即不插值的缩放，保留透明度信息） 更多...
 
IMAGE ZoomImage_Alpha (IMAGE *srcimg, int width, int height=0)
 缩放图像（双线性插值，保留透明度信息） 更多...
 
IMAGE ZoomImage_Win32_Alpha (IMAGE *srcimg, int width, int height=0)
 图像缩放（基于 Win32 API，比较快，保留透明度信息） 更多...
 
void DelayFPS (int fps, bool wait_long=false)
 根据目标帧率延时 更多...
 
void Gdiplus_Try_Starup ()
 注意，必须先启动 GDI+，才能使用下面的绘图函数 更多...
 
void Gdiplus_Shutdown ()
 关闭 GDI+ 更多...
 
Gdiplus::Color ConvertToGdiplusColor (COLORREF color, bool reserve_alpha=false)
 转换 COLORREF 到 Gdiplus::Color 更多...
 
void Gdiplus_Line (HDC hdc, float x1, float y1, float x2, float y2, Gdiplus::Color linecolor, float linewidth, Gdiplus::SmoothingMode smoothing_mode)
 画线 更多...
 
void Gdiplus_Polygon (HDC hdc, int points_num, Gdiplus::PointF *points, Gdiplus::Color linecolor, float linewidth, Gdiplus::SmoothingMode smoothing_mode)
 画多边形 更多...
 
void Gdiplus_SolidPolygon (HDC hdc, int points_num, Gdiplus::PointF *points, Gdiplus::Color fillcolor, Gdiplus::SmoothingMode smoothing_mode)
 画无边框填充多边形 更多...
 
void Gdiplus_Rectangle (HDC hdc, float x, float y, float w, float h, Gdiplus::Color linecolor, float linewidth, Gdiplus::SmoothingMode smoothing_mode)
 画矩形 更多...
 
void Gdiplus_SolidRectangle (HDC hdc, float x, float y, float w, float h, Gdiplus::Color fillcolor, Gdiplus::SmoothingMode smoothing_mode)
 画无边框填充矩形 更多...
 
void Gdiplus_Ellipse (HDC hdc, float x, float y, float w, float h, Gdiplus::Color linecolor, float linewidth, Gdiplus::SmoothingMode smoothing_mode)
 画椭圆 更多...
 
void Gdiplus_SolidEllipse (HDC hdc, float x, float y, float w, float h, Gdiplus::Color fillcolor, Gdiplus::SmoothingMode smoothing_mode)
 画无边框填充椭圆 更多...
 
void Gdiplus_Pie (HDC hdc, float x, float y, float w, float h, float stangle, float endangle, Gdiplus::Color linecolor, float linewidth, Gdiplus::SmoothingMode smoothing_mode)
 画饼状图（传入顺时针角度） 更多...
 
void Gdiplus_SolidPie (HDC hdc, float x, float y, float w, float h, float stangle, float endangle, Gdiplus::Color fillcolor, Gdiplus::SmoothingMode smoothing_mode)
 画无边框填充饼状图（传入顺时针角度） 更多...
 
void Gdiplus_Arc (HDC hdc, float x, float y, float w, float h, float stangle, float endangle, Gdiplus::Color linecolor, float linewidth, Gdiplus::SmoothingMode smoothing_mode)
 画圆弧（传入顺时针角度） 更多...
 
void EasyX_Gdiplus_Line (float x1, float y1, float x2, float y2, COLORREF linecolor, float linewidth=1, bool enable_alpha=false, bool enable_aa=true, IMAGE *pImg=nullptr)
 画直线 更多...
 
void EasyX_Gdiplus_Polygon (int points_num, POINT *points, COLORREF linecolor, float linewidth=1, bool enable_alpha=false, bool enable_aa=true, IMAGE *pImg=nullptr)
 画多边形 更多...
 
void EasyX_Gdiplus_SolidPolygon (int points_num, POINT *points, COLORREF fillcolor, bool enable_alpha=false, bool enable_aa=true, IMAGE *pImg=nullptr)
 画无边框填充多边形 更多...
 
void EasyX_Gdiplus_FillPolygon (int points_num, POINT *points, COLORREF linecolor, COLORREF fillcolor, float linewidth=1, bool enable_alpha=false, bool enable_aa=true, IMAGE *pImg=nullptr)
 画有边框填充多边形 更多...
 
void EasyX_Gdiplus_Rectangle (float x, float y, float w, float h, COLORREF linecolor, float linewidth=1, bool enable_alpha=false, bool enable_aa=true, IMAGE *pImg=nullptr)
 画矩形 更多...
 
void EasyX_Gdiplus_SolidRectangle (float x, float y, float w, float h, COLORREF fillcolor, bool enable_alpha=false, bool enable_aa=true, IMAGE *pImg=nullptr)
 画无边框填充矩形 更多...
 
void EasyX_Gdiplus_FillRectangle (float x, float y, float w, float h, COLORREF linecolor, COLORREF fillcolor, float linewidth=1, bool enable_alpha=false, bool enable_aa=true, IMAGE *pImg=nullptr)
 画有边框填充矩形 更多...
 
void EasyX_Gdiplus_Ellipse (float x, float y, float w, float h, COLORREF linecolor, float linewidth=1, bool enable_alpha=false, bool enable_aa=true, IMAGE *pImg=nullptr)
 画椭圆 更多...
 
void EasyX_Gdiplus_SolidEllipse (float x, float y, float w, float h, COLORREF fillcolor, bool enable_alpha=false, bool enable_aa=true, IMAGE *pImg=nullptr)
 画无边框填充椭圆 更多...
 
void EasyX_Gdiplus_FillEllipse (float x, float y, float w, float h, COLORREF linecolor, COLORREF fillcolor, float linewidth=1, bool enable_alpha=false, bool enable_aa=true, IMAGE *pImg=nullptr)
 画有边框填充椭圆 更多...
 
void EasyX_Gdiplus_Pie (float x, float y, float w, float h, float stangle, float endangle, COLORREF linecolor, float linewidth=1, bool enable_alpha=false, bool enable_aa=true, IMAGE *pImg=nullptr)
 画饼状图（传入逆时针角度） 更多...
 
void EasyX_Gdiplus_SolidPie (float x, float y, float w, float h, float stangle, float endangle, COLORREF fillcolor, bool enable_alpha=false, bool enable_aa=true, IMAGE *pImg=nullptr)
 画无边框填充饼状图（传入逆时针角度） 更多...
 
void EasyX_Gdiplus_FillPie (float x, float y, float w, float h, float stangle, float endangle, COLORREF linecolor, COLORREF fillcolor, float linewidth=1, bool enable_alpha=false, bool enable_aa=true, IMAGE *pImg=nullptr)
 画有边框填充饼状图（传入逆时针角度） 更多...
 
void EasyX_Gdiplus_Arc (float x, float y, float w, float h, float stangle, float endangle, COLORREF linecolor, float linewidth=1, bool enable_alpha=false, bool enable_aa=true, IMAGE *pImg=nullptr)
 画圆弧（传入逆时针角度） 更多...
 
DWORD * GetIconImageBuffer ()
 获取图标显存 更多...
 
IMAGE * GetIconImage ()
 获取图标对象（显存的拷贝） 更多...
 
void RenderStartScene ()
 渲染开场动画 更多...
 
int AllocID ()
 自动分配控件 ID 更多...
 
bool IsValidWindowIndex (int index)
 
bool IsFocusWindowExisted ()
 
EasyWindow & GetFocusWindow ()
 
int GetWindowIndex (HWND hWnd)
 
bool IsAnyWindow ()
 是否还存在未销毁的绘图窗口 更多...
 
bool IsAliveWindow (HWND hWnd=nullptr)
 判断一窗口是否还存在（未被关闭） 更多...
 
bool IsAliveWindow (int index)
 
void WaitForProcessing (int index)
 
void CopyImageToHDC (IMAGE *pImg, HDC hdc, RECT rct)
 
void WaitForTask (HWND hWnd=nullptr)
 阻塞等待某窗口任务完成 更多...
 
void FreeWindow (int index)
 
void closegraph_win32 (int index)
 
void closegraph_win32 (HWND hWnd=nullptr)
 关闭某一绘图窗口 更多...
 
void SetWndProcFunc (HWND hWnd, WNDPROC WindowProcess)
 设置某窗口的过程函数 更多...
 
IMAGE * GetWindowImage (HWND hWnd=nullptr)
 获取某窗口的图像指针 更多...
 
Canvas * GetWindowCanvas (HWND hWnd=nullptr)
 获取窗口画布指针 更多...
 
void BindWindowCanvas (Canvas *pCanvas, HWND hWnd)
 
void init_end (HWND hWnd=nullptr)
 初始化窗口结束后，可以用此函数阻塞等待目标窗口被关闭，然后函数返回 更多...
 
void AutoExit ()
 设置：当窗口都被销毁时，自动退出程序 更多...
 
HWND GetHWnd_win32 ()
 得到当前活动绘图窗口的句柄 更多...
 
EasyWindow GetWorkingWindow ()
 得到当前绘图窗口的详细信息 更多...
 
bool SetWorkingWindow (HWND hWnd)
 等待当前任务完成并设置活动窗口 更多...
 
void QuickDraw (UINT nSkipPixels, HWND hWnd=nullptr)
 设置加速绘制跳过多少像素点 更多...
 
DrawMode GetDrawMode ()
 获取全局绘制模式 更多...
 
void SetDrawMode (DrawMode mode)
 设置全局绘制模式 更多...
 
void SendUserRedrawMsg (HWND hWnd)
 
void RedrawWindow (HWND hWnd=nullptr)
 通知重绘绘图窗口（在 WM_PAINT 消息内绘图不需要使用此函数） 更多...
 
void FlushDrawing (int index, RECT rct={ 0 })
 
void FlushDrawing (RECT rct)
 
void EnableAutoFlush (bool enable)
 
bool BeginTask ()
 
void EndTask (bool flush=true)
 终止当前窗口任务 更多...
 
bool IsInTask (HWND hWnd)
 
void ResizeWindowImage (int index, RECT rct)
 
void ShowTray (NOTIFYICONDATA *nid)
 
void CreateTray (LPCTSTR lpszTrayName, HWND hWnd)
 
void DeleteTray (HWND hWnd=nullptr)
 删除某窗口的托盘 更多...
 
void SetTrayMenu (HMENU hMenu, HWND hWnd=nullptr)
 设置托盘菜单（允许在任何时候设置） 更多...
 
void SetTrayMenuProcFunc (void(*pFunc)(UINT), HWND hWnd=nullptr)
 设置托盘菜单消息处理函数 更多...
 
bool IsWindowSizeChanged (HWND hWnd=nullptr)
 判断某窗口的大小是否改变 更多...
 
bool GetCustomIconState ()
 获取自定义程序图标的启用状态 更多...
 
void SetCustomIcon (LPCTSTR lpszIcon, LPCTSTR lpszIconSm)
 
std::vector< ExMessage > & GetMsgVector (HWND hWnd)
 
void RemoveMessage (HWND hWnd)
 
void ClearMessage (BYTE filter, HWND hWnd)
 
bool IsNewMessage (BYTE filter, HWND hWnd)
 
ExMessage GetNextMessage (BYTE filter, HWND hWnd)
 
ExMessage getmessage_win32 (BYTE filter=-1, HWND hWnd=nullptr)
 阻塞等待，直到获取到一个新消息 更多...
 
void getmessage_win32 (ExMessage *msg, BYTE filter=-1, HWND hWnd=nullptr)
 阻塞等待，直到获取到一个新消息 更多...
 
bool peekmessage_win32 (ExMessage *msg, BYTE filter=-1, bool removemsg=true, HWND hWnd=nullptr)
 获取一个消息，立即返回是否获取成功 更多...
 
void flushmessage_win32 (BYTE filter=-1, HWND hWnd=nullptr)
 清除所有消息记录 更多...
 
bool MouseHit_win32 (HWND hWnd=nullptr)
 检查是否存在鼠标消息 更多...
 
MOUSEMSG GetMouseMsg_win32 (HWND hWnd=nullptr)
 阻塞等待，直到获取到一个新的鼠标消息 更多...
 
bool PeekMouseMsg_win32 (MOUSEMSG *pMsg, bool bRemoveMsg=true, HWND hWnd=nullptr)
 获取一个新的鼠标消息，立即返回是否获取成功 更多...
 
void FlushMouseMsgBuffer_win32 (HWND hWnd=nullptr)
 清空鼠标消息 更多...
 
ExMessage To_ExMessage (MOUSEMSG msg)
 MOUSEMSG 转 ExMessage 更多...
 
MOUSEMSG To_MouseMsg (ExMessage msgEx)
 
void PreSetWindowStyle (long lStyle)
 
void PreSetWindowStyleEx (long lStyleEx)
 
void PreSetWindowPos (int x, int y)
 在创建窗口前设置窗口位置，仅对此操作后首个新窗口生效 更多...
 
void PreSetWindowShowState (int nCmdShow)
 在创建窗口前设置窗口显示状态，仅对此操作后首个新窗口生效 更多...
 
int SetWindowStyle (long lNewStyle, HWND hWnd=nullptr)
 设置某窗口样式 更多...
 
int SetWindowExStyle (long lNewExStyle, HWND hWnd=nullptr)
 设置某窗口扩展样式 更多...
 
POINT GetWindowPos (HWND hWnd=nullptr)
 获取窗口位置 更多...
 
SIZE GetWindowSize (HWND hWnd=nullptr)
 获取窗口大小 更多...
 
void MoveWindow (int x, int y, HWND hWnd=nullptr)
 移动窗口 更多...
 
void MoveWindowRel (int dx, int dy, HWND hWnd=nullptr)
 相对移动窗口 更多...
 
void ResizeWindow (int w, int h, HWND hWnd=nullptr)
 重设窗口大小 更多...
 
void SetWindowTitle (LPCTSTR lpszTitle, HWND hWnd=nullptr)
 设置窗口标题文本 更多...
 
HICON GetDefaultAppIcon ()
 
void OnSize (int indexWnd)
 
void OnTray (int indexWnd, LPARAM lParam)
 
void OnTaskBarCreated (int indexWnd)
 
void RegisterExMessage (int indexWnd, UINT msg, WPARAM wParam, LPARAM lParam)
 
void OnPaint (int indexWnd, HDC hdc)
 
void OnMove (HWND hWnd)
 
void OnDestroy (int indexWnd, WPARAM wParam)
 
HWND OnSysCtrlCreate (int indexWnd, WPARAM wParam, LPARAM lParam)
 
LRESULT SysCtrlProc (int indexWnd, UINT msg, WPARAM wParam, LPARAM lParam, bool &bRet)
 
void OnCreate (int indexWnd, HWND hWnd, LPARAM lParam)
 
LRESULT CALLBACK WndProc (HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
 
void RegisterWndClass ()
 
EasyWindow & InitWindowStruct (EasyWindow &wnd, HWND hParent, int w, int h, WNDPROC WindowProcess)
 
void InitWindow (int w, int h, int flag, LPCTSTR lpszWndTitle, WNDPROC WindowProcess, HWND hParent, int *nDoneFlag, HWND *hWnd)
 
HWND initgraph_win32 (int w, int h, int flag, LPCTSTR lpszWndTitle, WNDPROC WindowProcess, HWND hParent)
 

变量

clock_t tRecord = 0
 
WNDCLASSEX g_WndClassEx
 窗口类 更多...
 
wchar_t g_lpszClassName [] = L"HiEasyX"
 窗口类名 更多...
 
ScreenSize g_screenSize
 显示器信息 更多...
 
HWND g_hConsole
 控制台句柄 更多...
 
HINSTANCE g_hInstance = GetModuleHandle(0)
 程序实例 更多...
 
std::vector< EasyWindow > g_vecWindows
 窗口表（管理多窗口） 更多...
 
int g_nFocusWindowIndex = NO_WINDOW_INDEX
 当前操作焦点窗口索引 更多...
 
bool g_isInTask = false
 标记处于任务中 更多...
 
HICON g_hIconDefault
 默认程序图标 更多...
 
LPCTSTR g_lpszCustomIcon = nullptr
 自定义程序图标资源，为空表示不使用 更多...
 
LPCTSTR g_lpszCustomIconSm = nullptr
 
HICON g_hCustomIcon
 自定义程序图标 更多...
 
HICON g_hCustomIconSm
 
bool g_isPreStyle = false
 是否预设窗口样式 更多...
 
bool g_isPreStyleEx = false
 是否预设窗口扩展样式 更多...
 
bool g_isPrePos = false
 是否预设窗口位置 更多...
 
bool g_isPreShowState = false
 是否预设窗口显示状态 更多...
 
long g_lPreStyle
 创建窗口前的预设样式 更多...
 
long g_lPreStyleEx
 创建窗口前的预设扩展样式 更多...
 
POINT g_pPrePos
 创建窗口前的预设窗口位置 更多...
 
int g_nPreCmdShow
 创建窗口前的预设显示状态 更多...
 
DrawMode g_fDrawMode = DM_Normal
 全局绘制模式 更多...
 
bool g_bAutoFlush = true
 是否自动刷新双缓冲 更多...
 
UINT g_uWM_TASKBARCREATED
 系统任务栏消息代码 更多...
 

类型定义说明

◆ MESSAGE_PROC_FUNC

typedef void(* HiEasyX::MESSAGE_PROC_FUNC) (ControlBase *_Ctrl, int _MsgId, ExMessage _ExMsg)

控件消息处理函数

参数
[in]_Ctrl传入控件指针
[in]_MsgId传入消息标识代码
[in]_ExMsg传入消息（鼠标坐标已变换到控件）

在文件 ControlBase.h 第 42 行定义.

◆ MESSAGE_PROC_FUNC_CLASS

typedef void(* HiEasyX::MESSAGE_PROC_FUNC_CLASS) (void *_This, ControlBase *_Ctrl, int _MsgId, ExMessage _ExMsg)

支持静态类函数作为控件消息处理函数

在文件 ControlBase.h 第 47 行定义.

枚举类型说明

◆ CtrlMessage

enum HiEasyX::CtrlMessage

控件基础

枚举值
CM_OTHER 

未特殊标识的其它消息

CM_HOVER 

悬停

CM_HOVER_OVER 

悬停结束

CM_PRESS 

按下

CM_PRESS_OVER 

按下结束

CM_CLICK 

单击

CM_DOUBLE_CLICK 

双击

CM_FOCUS 

获取焦点

CM_FOCUS_OVER 

丢失焦点

在文件 ControlBase.h 第 20 行定义.

21  {
22  CM_OTHER,
23  CM_HOVER,
24  CM_HOVER_OVER,
25  CM_PRESS,
26  CM_PRESS_OVER,
27  CM_CLICK,
28  CM_DOUBLE_CLICK,
29  CM_FOCUS,
30  CM_FOCUS_OVER,
31 
32  };

◆ DrawMode

enum HiEasyX::DrawMode 
    绘制模式（从缓冲区绘制到窗口）
 备注：
    一般使用 DM_Normal 即可。
枚举值
DM_Real 

完全按实际绘制（每次要求重绘都立即执行，可能导致程序卡顿）

DM_Normal 

正常绘制（现在和 DM_Real 是等价了）

DM_Fast 

快速绘制（发送 WM_USER_REDRAW 消息，可能跳过部分绘制）

DM_VeryFast 

极速绘制（发送 WM_USER_REDRAW 消息，可能跳过很多绘制）

DM_Fastest 

最快的绘制方式（发送 WM_USER_REDRAW 消息，可能跳过大部分绘制）

在文件 HiWindow.h 第 106 行定义.

107  {
108  DM_Real,
109  DM_Normal,
110  DM_Fast,
111  DM_VeryFast,
112  DM_Fastest,
113  };

◆ LayerOrder

enum HiEasyX::LayerOrder

特殊图层顺序标识

枚举值
LAYERORDER_BOTTOM_MOST 
LAYERORDER_BOTTOM 
LAYERORDER_NORMAL 
LAYERORDER_TOP 
LAYERORDER_TOP_MOST 

在文件 HiCanvas.h 第 859 行定义.

860  {
861  LAYERORDER_BOTTOM_MOST,
862  LAYERORDER_BOTTOM,
863  LAYERORDER_NORMAL,
864  LAYERORDER_TOP,
865  LAYERORDER_TOP_MOST
866  };

◆ SysControlType

enum HiEasyX::SysControlType

支持的系统控件类型

枚举值
SCT_Unknown 
SCT_Group 
SCT_GroupBox 
SCT_Static 
SCT_Button 
SCT_CheckBox 
SCT_RadioButton 
SCT_Edit 
SCT_ComboBox 

在文件 SysControlBase.h 第 19 行定义.

20  {
21  SCT_Unknown,
22  SCT_Group,
23  SCT_GroupBox,
24  SCT_Static,
25  SCT_Button,
26  SCT_CheckBox,
27  SCT_RadioButton,
28  SCT_Edit,
29  SCT_ComboBox,
30  };

函数说明

◆ AllocID()

int HiEasyX::AllocID ( )

自动分配控件 ID

在文件 SysControlBase.cpp 第 173 行定义.

174  {
175  static int id = 10086;
176  return id++;
177  }

◆ AutoExit()

void HiEasyX::AutoExit ( )

设置：当窗口都被销毁时，自动退出程序

在文件 HiWindow.cpp 第 324 行定义.

325  {
326  std::thread([]() {
327  init_end();
328  exit(0);
329  }).detach();
330  }

◆ BeginTask()

bool HiEasyX::BeginTask ( ) 
    为当前活动窗口启动任务
 备注：
    调用 EasyX 函数进行绘图或获取消息时，都应当启动任务。
返回
是否启动成功（若已在任务中也返回 true）

在文件 HiWindow.cpp 第 530 行定义.

531  {
532  // 不做窗口匹配判断，只检验是否处于任务中
533  if (!g_isInTask && IsFocusWindowExisted())
534  {
535  WaitForProcessing(g_nFocusWindowIndex);
536  g_isInTask = true;
537  }
538  return g_isInTask;
539  }

◆ BindWindowCanvas()

void HiEasyX::BindWindowCanvas ( Canvas *  pCanvas,
HWND  hWnd = nullptr 
) 
    绑定窗口画布指针
 备注：
    绑定后，使用画布绘图时将自动开启任务，无需用户开启，但不会自动刷新屏幕
参数
[in]pCanvas画布指针
[in]hWnd窗口句柄（为空表示当前活动窗口）

在文件 HiWindow.cpp 第 301 行定义.

302  {
303  int index = GetWindowIndex(hWnd);
304  if (IsAliveWindow(index))
305  {
306  g_vecWindows[index].pBufferImgCanvas = pCanvas;
307  pCanvas->BindToWindow(g_vecWindows[index].hWnd, g_vecWindows[index].pBufferImg);
308  }
309  }

◆ ClearMessage()

void HiEasyX::ClearMessage ( BYTE  filter,
HWND  hWnd 
)

在文件 HiWindow.cpp 第 690 行定义.

691  {
692  for (size_t i = 0; i < GetMsgVector(hWnd).size(); i++)
693  if (filter & GetExMessageType(GetMsgVector(hWnd)[i]))
694  GetMsgVector(hWnd).erase(GetMsgVector(hWnd).begin() + i--);
695  }

◆ closegraph_win32() [1/2]

void HiEasyX::closegraph_win32 ( HWND  hWnd = nullptr)

关闭某一绘图窗口

参数
[in]hWnd窗口句柄（为空代表所有绘图窗口）

在文件 HiWindow.cpp 第 245 行定义.

246  {
247  // 关闭全部
248  if (hWnd == nullptr)
249  {
250  for (int i = 0; i < (int)g_vecWindows.size(); i++)
251  {
252  if (g_vecWindows[i].isAlive)
253  {
254  // 必须交由原线程 DestroyWindow
255  // 发送 WM_DESTROY 时特殊标记 wParam 为 1，表示程序命令销毁窗口
256  SendMessage(g_vecWindows[i].hWnd, WM_DESTROY, 1, 0);
257  }
258  }
259  }
260  else if (IsAliveWindow(hWnd))
261  {
262  SendMessage(hWnd, WM_DESTROY, 1, 0);
263  }
264  }

◆ closegraph_win32() [2/2]

void HiEasyX::closegraph_win32 ( int  index)

在文件 HiWindow.cpp 第 202 行定义.

203  {
204  if (!IsAliveWindow(index))
205  {
206  return;
207  }
208 
209  // 先设置窗口死亡，再标识忙碌，等待任务结束
210  g_vecWindows[index].isAlive = false;
211  g_vecWindows[index].isBusyProcessing = true;
212  WaitForTask(g_vecWindows[index].hWnd);
213 
214  // 若已设置父窗口为模态窗口，则需要将父窗口恢复正常
215  if (g_vecWindows[index].hParent != nullptr)
216  {
217  EnableWindow(g_vecWindows[index].hParent, true);
218  SetForegroundWindow(g_vecWindows[index].hParent);
219  }
220 
221  // 卸载托盘
222  DeleteTray(g_vecWindows[index].hWnd);
223 
224  // 如果活动窗口被销毁，则需要重置活动窗口索引
225  if (index == g_nFocusWindowIndex)
226  {
227  g_nFocusWindowIndex = NO_WINDOW_INDEX;
228  }
229 
230  // 释放窗口内存
231  FreeWindow(index);
232 
233  // 关闭忙碌标识
234  g_vecWindows[index].isBusyProcessing = false;
235 
236  // 如果关闭此窗口后不存在任何窗口
237  if (!IsAnyWindow())
238  {
239  // 关闭 GDI+ 绘图环境
240  Gdiplus_Shutdown();
241  }
242  }

◆ ConvertToGdiplusColor()

Gdiplus::Color HiEasyX::ConvertToGdiplusColor ( COLORREF  color,
bool  reserve_alpha = false 
)

转换 COLORREF 到 Gdiplus::Color

参数
[in]color原颜色
[in]reserve_alpha是否保留 COLORREF 中的 alpha 值
返回
转换后的 Gdiplus::Color 色值

在文件 HiGdiplus.cpp 第 30 行定义.

31  {
32  return Gdiplus::Color(
33  reserve_alpha ? GetAValue(color) : 255,
34  GetRValue(color),
35  GetGValue(color),
36  GetBValue(color)
37  );
38  }

◆ CopyImage_Alpha()

void HiEasyX::CopyImage_Alpha ( int  x,
int  y,
DWORD *  pDst,
int  wDst,
int  hDst,
DWORD *  pSrc,
int  wSrc,
int  hSrc,
RECT  crop = { 0 },
BYTE  alpha = 255,
bool  bUseSrcAlpha = false,
bool  isCalculated = false 
) 
    快速复制图像（可开启透明通道）
 备注：
    若未启用任何透明通道，等同于直接复制图像。此时将保留原图像的透明度信息，否则不保留透明度信息。
参数
[in]x图像输出 x 坐标
[in]y图像输出 y 坐标
[in]pDst载体图像指针
[in]wDst载体图像宽
[in]hDst载体图像高
[in]pSrc待输出图像指针
[in]wSrc待输出图像宽
[in]hSrc待输出图像高
[in]crop待输出图像裁剪区域（right 或 bottom 为 0 表示不裁剪）
[in]alpha叠加透明度（透明 0 ~ 255 不透明）
[in]bUseSrcAlpha
    是否使用待输出图像透明度进行混合（须保证 IMAGE 中含有透明度信息）

备注： EasyX 中的图像一般无透明度（默认设为 0，即全透明），故一般不使用原图透明度。 通常只有 png 图像，或是特地生成的图像才含有透明度信息。 

参数

  

    
[in]isCalculated
    标记待输出图像是否已经计算好混合后的颜色（启用图像透明度时有效）

  

  



注意： png 图像像素颜色都已进行过混合运算。 开启后，原图像便不再计算混合颜色，只有载体图像参与计算。

在文件 HiCanvas.cpp 第 37 行定义.

38  {
39  // 裁剪起点或终点无效
40  if (crop.left > wSrc || crop.top > hSrc || crop.right < crop.left || crop.bottom < crop.top)
41  return;
42 
43  // 限制原图宽高
44  int limit_w = ((crop.right && crop.right < wSrc) ? crop.right : wSrc);
45  int limit_h = ((crop.bottom && crop.bottom < hSrc) ? crop.bottom : hSrc);
46 
47  // 标记不使用任何透明通道
48  bool bNoAlpha = false;
49  float fTransparent = alpha / 255.0f;
50  if (alpha == 255 && !bUseSrcAlpha) bNoAlpha = true;
51 
52  // 保证只有在使用原图透明度时，已计算标记才能开启
53  if (!bUseSrcAlpha) isCalculated = false;
54 
55  // i j -> 原图索引（若输出位置为负，则略过超出范围部分）
56  // nx ny -> 载体图像索引
57  for (int i = (x < 0 ? -x : 0) + crop.left, nx = i + x; i < limit_w && nx < wDst; i++, nx++)
58  {
59  for (int j = (y < 0 ? -y : 0) + crop.top, ny = j + y; j < limit_h && ny < hDst; j++, ny++)
60  {
61  int indexSrc = j * wSrc + i;
62  int indexDst = ny * wDst + nx;
63  if (indexSrc < 0 || indexDst < 0)
64  {
65  continue;
66  }
67  if (bNoAlpha)
68  {
69  pDst[indexDst] = pSrc[indexSrc];
70  }
71  else
72  {
73  pDst[indexDst] = MixAlphaColor(
74  pDst[indexDst],
75  bUseSrcAlpha ? pSrc[indexSrc] : SET_ALPHA(pSrc[indexSrc], 255),
76  isCalculated,
77  alpha
78  );
79  }
80  }
81  }
82  }

◆ CopyImageToHDC()

void HiEasyX::CopyImageToHDC ( IMAGE *  pImg,
HDC  hdc,
RECT  rct 
)

在文件 HiWindow.cpp 第 153 行定义.

154  {
155  //HDC hdc = GetDC(hWnd);
156  HDC hdcImg = GetImageHDC(pImg);
157  BitBlt(hdc, rct.left, rct.top, rct.right, rct.bottom, hdcImg, 0, 0, SRCCOPY);
158  //ReleaseDC(hWnd, hdc);
159  }

◆ CreateTray()

void HiEasyX::CreateTray ( LPCTSTR  lpszTrayName,
HWND  hWnd = nullptr 
) 
    为窗口创建一个托盘
 注意：
    在 HiEasyX 中，每个窗口仅能稳定占有一个托盘
参数
[in]lpszTrayName托盘提示文本
[in]hWnd窗口句柄（为空表示当前活动窗口）

在文件 HiWindow.cpp 第 576 行定义.

577  {
578  static int id = 0;
579 
580  int index = GetWindowIndex(hWnd);
581  if (IsAliveWindow(index))
582  {
583  HICON hIcon = g_hIconDefault;
584  if (g_lpszCustomIconSm)
585  hIcon = g_hCustomIconSm;
586  else if (g_lpszCustomIcon)
587  hIcon = g_hCustomIcon;
588 
589  g_vecWindows[index].isUseTray = true;
590  g_vecWindows[index].nid.cbSize = sizeof(NOTIFYICONDATA);
591  g_vecWindows[index].nid.hWnd = g_vecWindows[index].hWnd;
592  g_vecWindows[index].nid.uID = id++;
593  g_vecWindows[index].nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
594  g_vecWindows[index].nid.uCallbackMessage = WM_TRAY;
595  g_vecWindows[index].nid.hIcon = hIcon;
596  lstrcpy(g_vecWindows[index].nid.szTip, lpszTrayName);
597  ShowTray(&g_vecWindows[index].nid);
598  }
599  }

◆ DelayFPS()

void HiEasyX::DelayFPS ( int  fps,
bool  wait_long = false 
)

根据目标帧率延时

参数
[in]fps帧率
[in]wait_long是否长等待（降低占用）

在文件 HiFPS.cpp 第 11 行定义.

12  {
13  if (wait_long)
14  {
15  Sleep(500);
16  return;
17  }
18 
19  clock_t tNow = clock();
20  if (tRecord)
21  {
22  int delay = 1000 / fps - (tNow - tRecord);
23  if (delay > 0)
24  {
25  HpSleep(delay);
26  }
27  }
28  tRecord = clock();
29  }

◆ DeleteTray()

void HiEasyX::DeleteTray ( HWND  hWnd = nullptr)

删除某窗口的托盘

参数
[in]hWnd窗口句柄（为空表示当前活动窗口）

在文件 HiWindow.cpp 第 601 行定义.

602  {
603  int index = GetWindowIndex(hWnd);
604 
605  // 死窗口删除时会调用该函数，所以不判断窗口死活，只需要判断窗口是否存在
606  if (IsValidWindowIndex(index))
607  {
608  if (g_vecWindows[index].isUseTray)
609  {
610  g_vecWindows[index].isUseTray = false;
611  Shell_NotifyIcon(NIM_DELETE, &g_vecWindows[index].nid);
612  }
613  }
614  }

◆ EasyX_Gdiplus_Arc()

void HiEasyX::EasyX_Gdiplus_Arc ( float  x,
float  y,
float  w,
float  h,
float  stangle,
float  endangle,
COLORREF  linecolor,
float  linewidth,
bool  enable_alpha,
bool  enable_aa,
IMAGE *  pImg 
)

画圆弧（传入逆时针角度）

在文件 HiGdiplus.cpp 第 509 行定义.

522  {
523  Gdiplus_Arc(
524  GetImageHDC(pImg),
525  x, y, w, h, -stangle, -endangle,
526  ConvertToGdiplusColor(linecolor, enable_alpha),
527  linewidth,
528  enable_aa ? Gdiplus::SmoothingModeAntiAlias : Gdiplus::SmoothingModeDefault
529  );
530  }

◆ EasyX_Gdiplus_Ellipse()

void HiEasyX::EasyX_Gdiplus_Ellipse ( float  x,
float  y,
float  w,
float  h,
COLORREF  linecolor,
float  linewidth,
bool  enable_alpha,
bool  enable_aa,
IMAGE *  pImg 
)

画椭圆

在文件 HiGdiplus.cpp 第 389 行定义.

400  {
401  Gdiplus_Ellipse(
402  GetImageHDC(pImg),
403  x, y, w, h,
404  ConvertToGdiplusColor(linecolor, enable_alpha),
405  linewidth,
406  enable_aa ? Gdiplus::SmoothingModeAntiAlias : Gdiplus::SmoothingModeDefault
407  );
408  }

◆ EasyX_Gdiplus_FillEllipse()

void HiEasyX::EasyX_Gdiplus_FillEllipse ( float  x,
float  y,
float  w,
float  h,
COLORREF  linecolor,
COLORREF  fillcolor,
float  linewidth,
bool  enable_alpha,
bool  enable_aa,
IMAGE *  pImg 
)

画有边框填充椭圆

在文件 HiGdiplus.cpp 第 429 行定义.

441  {
442  EasyX_Gdiplus_SolidEllipse(x, y, w, h, fillcolor, enable_alpha, enable_aa, pImg);
443  EasyX_Gdiplus_Ellipse(x, y, w, h, linecolor, linewidth, enable_alpha, enable_aa, pImg);
444  }

◆ EasyX_Gdiplus_FillPie()

void HiEasyX::EasyX_Gdiplus_FillPie ( float  x,
float  y,
float  w,
float  h,
float  stangle,
float  endangle,
COLORREF  linecolor,
COLORREF  fillcolor,
float  linewidth,
bool  enable_alpha,
bool  enable_aa,
IMAGE *  pImg 
)

画有边框填充饼状图（传入逆时针角度）

在文件 HiGdiplus.cpp 第 490 行定义.

504  {
505  EasyX_Gdiplus_SolidPie(x, y, w, h, stangle, endangle, fillcolor, enable_alpha, enable_aa, pImg);
506  EasyX_Gdiplus_Pie(x, y, w, h, stangle, endangle, linecolor, linewidth, enable_alpha, enable_aa, pImg);
507  }

◆ EasyX_Gdiplus_FillPolygon()

void HiEasyX::EasyX_Gdiplus_FillPolygon ( int  points_num,
POINT *  points,
COLORREF  linecolor,
COLORREF  fillcolor,
float  linewidth,
bool  enable_alpha,
bool  enable_aa,
IMAGE *  pImg 
)

画有边框填充多边形

在文件 HiGdiplus.cpp 第 317 行定义.

327  {
328  EasyX_Gdiplus_SolidPolygon(points_num, points, fillcolor, enable_alpha, enable_aa, pImg);
329  EasyX_Gdiplus_Polygon(points_num, points, linecolor, linewidth, enable_alpha, enable_aa, pImg);
330  }

◆ EasyX_Gdiplus_FillRectangle()

void HiEasyX::EasyX_Gdiplus_FillRectangle ( float  x,
float  y,
float  w,
float  h,
COLORREF  linecolor,
COLORREF  fillcolor,
float  linewidth,
bool  enable_alpha,
bool  enable_aa,
IMAGE *  pImg 
)

画有边框填充矩形

在文件 HiGdiplus.cpp 第 372 行定义.

384  {
385  EasyX_Gdiplus_SolidRectangle(x, y, w, h, fillcolor, enable_alpha, enable_aa, pImg);
386  EasyX_Gdiplus_Rectangle(x, y, w, h, linecolor, linewidth, enable_alpha, enable_aa, pImg);
387  }

◆ EasyX_Gdiplus_Line()

void HiEasyX::EasyX_Gdiplus_Line ( float  x1,
float  y1,
float  x2,
float  y2,
COLORREF  linecolor,
float  linewidth,
bool  enable_alpha,
bool  enable_aa,
IMAGE *  pImg 
)

画直线

在文件 HiGdiplus.cpp 第 238 行定义.

249  {
250  Gdiplus_Line(
251  GetImageHDC(pImg),
252  x1, y1, x2, y2,
253  ConvertToGdiplusColor(linecolor, enable_alpha),
254  linewidth,
255  enable_aa ? Gdiplus::SmoothingModeAntiAlias : Gdiplus::SmoothingModeDefault
256  );
257  }

◆ EasyX_Gdiplus_Pie()

void HiEasyX::EasyX_Gdiplus_Pie ( float  x,
float  y,
float  w,
float  h,
float  stangle,
float  endangle,
COLORREF  linecolor,
float  linewidth,
bool  enable_alpha,
bool  enable_aa,
IMAGE *  pImg 
)

画饼状图（传入逆时针角度）

在文件 HiGdiplus.cpp 第 446 行定义.

459  {
460  Gdiplus_Pie(
461  GetImageHDC(pImg),
462  x, y, w, h, -stangle, -endangle,
463  ConvertToGdiplusColor(linecolor, enable_alpha),
464  linewidth,
465  enable_aa ? Gdiplus::SmoothingModeAntiAlias : Gdiplus::SmoothingModeDefault
466  );
467  }

◆ EasyX_Gdiplus_Polygon()

void HiEasyX::EasyX_Gdiplus_Polygon ( int  points_num,
POINT *  points,
COLORREF  linecolor,
float  linewidth,
bool  enable_alpha,
bool  enable_aa,
IMAGE *  pImg 
)

画多边形

在文件 HiGdiplus.cpp 第 259 行定义.

268  {
269  // 转换点的类型
270  Gdiplus::PointF* pPts = new Gdiplus::PointF[points_num];
271  for (int i = 0; i < points_num; i++)
272  {
273  pPts[i].X = (float)points[i].x;
274  pPts[i].Y = (float)points[i].y;
275  }
276 
277  Gdiplus_Polygon(
278  GetImageHDC(pImg),
279  points_num,
280  pPts,
281  ConvertToGdiplusColor(linecolor, enable_alpha),
282  linewidth,
283  enable_aa ? Gdiplus::SmoothingModeAntiAlias : Gdiplus::SmoothingModeDefault
284  );
285 
286  delete[] pPts;
287  }

◆ EasyX_Gdiplus_Rectangle()

void HiEasyX::EasyX_Gdiplus_Rectangle ( float  x,
float  y,
float  w,
float  h,
COLORREF  linecolor,
float  linewidth,
bool  enable_alpha,
bool  enable_aa,
IMAGE *  pImg 
)

画矩形

在文件 HiGdiplus.cpp 第 332 行定义.

343  {
344  Gdiplus_Rectangle(
345  GetImageHDC(pImg),
346  x, y, w, h,
347  ConvertToGdiplusColor(linecolor, enable_alpha),
348  linewidth,
349  enable_aa ? Gdiplus::SmoothingModeAntiAlias : Gdiplus::SmoothingModeDefault
350  );
351  }

◆ EasyX_Gdiplus_SolidEllipse()

void HiEasyX::EasyX_Gdiplus_SolidEllipse ( float  x,
float  y,
float  w,
float  h,
COLORREF  fillcolor,
bool  enable_alpha,
bool  enable_aa,
IMAGE *  pImg 
)

画无边框填充椭圆

在文件 HiGdiplus.cpp 第 410 行定义.

420  {
421  Gdiplus_SolidEllipse(
422  GetImageHDC(pImg),
423  x, y, w, h,
424  ConvertToGdiplusColor(fillcolor, enable_alpha),
425  enable_aa ? Gdiplus::SmoothingModeAntiAlias : Gdiplus::SmoothingModeDefault
426  );
427  }

◆ EasyX_Gdiplus_SolidPie()

void HiEasyX::EasyX_Gdiplus_SolidPie ( float  x,
float  y,
float  w,
float  h,
float  stangle,
float  endangle,
COLORREF  fillcolor,
bool  enable_alpha,
bool  enable_aa,
IMAGE *  pImg 
)

画无边框填充饼状图（传入逆时针角度）

在文件 HiGdiplus.cpp 第 469 行定义.

481  {
482  Gdiplus_SolidPie(
483  GetImageHDC(pImg),
484  x, y, w, h, -stangle, -endangle,
485  ConvertToGdiplusColor(fillcolor, enable_alpha),
486  enable_aa ? Gdiplus::SmoothingModeAntiAlias : Gdiplus::SmoothingModeDefault
487  );
488  }

◆ EasyX_Gdiplus_SolidPolygon()

void HiEasyX::EasyX_Gdiplus_SolidPolygon ( int  points_num,
POINT *  points,
COLORREF  fillcolor,
bool  enable_alpha,
bool  enable_aa,
IMAGE *  pImg 
)

画无边框填充多边形

在文件 HiGdiplus.cpp 第 289 行定义.

297  {
298  // 转换点的类型
299  Gdiplus::PointF* pPts = new Gdiplus::PointF[points_num];
300  for (int i = 0; i < points_num; i++)
301  {
302  pPts[i].X = (float)points[i].x;
303  pPts[i].Y = (float)points[i].y;
304  }
305 
306  Gdiplus_SolidPolygon(
307  GetImageHDC(pImg),
308  points_num,
309  pPts,
310  ConvertToGdiplusColor(fillcolor, enable_alpha),
311  enable_aa ? Gdiplus::SmoothingModeAntiAlias : Gdiplus::SmoothingModeDefault
312  );
313 
314  delete[] pPts;
315  }

◆ EasyX_Gdiplus_SolidRectangle()

void HiEasyX::EasyX_Gdiplus_SolidRectangle ( float  x,
float  y,
float  w,
float  h,
COLORREF  fillcolor,
bool  enable_alpha,
bool  enable_aa,
IMAGE *  pImg 
)

画无边框填充矩形

在文件 HiGdiplus.cpp 第 353 行定义.

363  {
364  Gdiplus_SolidRectangle(
365  GetImageHDC(pImg),
366  x, y, w, h,
367  ConvertToGdiplusColor(fillcolor, enable_alpha),
368  enable_aa ? Gdiplus::SmoothingModeAntiAlias : Gdiplus::SmoothingModeDefault
369  );
370  }

◆ EnableAutoFlush()

void HiEasyX::EnableAutoFlush ( bool  enable) 
    是否启用自动刷新双缓冲
 备注：
    默认情况下是自动刷新双缓冲的，即每次结束窗口任务时，EndTask 会根据传入的参数，
    决定要不要标记“需要刷新双缓冲”，标记后，窗口将会在下一次遇到重绘消息的时候刷新双缓冲。
    但是，在频繁重绘的情况下，由于多线程协调问题，自动刷新的效率可能会变低。
    所以你可以关闭自动刷新双缓冲，相应地，你需要使用 FlushDrawing 函数手动刷新双缓冲。

在文件 HiWindow.cpp 第 525 行定义.

526  {
527  g_bAutoFlush = enable;
528  }

◆ EndTask()

void HiEasyX::EndTask ( bool  flush = true)

终止当前窗口任务

参数
[in]flush是否标记需要更新双缓冲（但不会自动刷新窗口）

在文件 HiWindow.cpp 第 541 行定义.

542  {
543  if (g_isInTask)
544  {
545  if (flush && IsFocusWindowExisted())
546  {
547  GetFocusWindow().isNeedFlush = true;
548  //FlushDrawing(g_nFocusWindowIndex);
549  }
550 
551  g_isInTask = false;
552  }
553  }

◆ FlushDrawing() [1/2]

void HiEasyX::FlushDrawing ( int  index,
RECT  rct = { 0 } 
)

在文件 HiWindow.cpp 第 429 行定义.

429  { 0 })
430  {
431  if (!IsAliveWindow(index))
432  {
433  return;
434  }
435 
436  int w = g_vecWindows[index].pImg->getwidth();
437  int h = g_vecWindows[index].pImg->getheight();
438 
439  // 是否全部更新
440  bool isAllFlush = !(rct.left && rct.top && rct.right && rct.bottom);
441 
442  // 双缓冲的两层画布
443  DWORD* dst = GetImageBuffer(g_vecWindows[index].pImg);
444  DWORD* src = GetImageBuffer(g_vecWindows[index].pBufferImg);
445 
446  // 部分重绘时，修正重绘区域
447  RECT rctCorrected = rct;
448  if (!isAllFlush)
449  {
450  if (rct.left < 0) rctCorrected.left = 0;
451  if (rct.top < 0) rctCorrected.top = 0;
452  if (rct.right > w) rctCorrected.right = w;
453  if (rct.bottom > h) rctCorrected.bottom = h;
454  }
455 
456  // 不跳过像素的模式
457  if (g_vecWindows[index].nSkipPixels == 0)
458  {
459  // 全部更新
460  if (isAllFlush)
461  {
462  // fastest
463  memcpy(dst, src, sizeof(DWORD) * w * h);
464  }
465  // 部分更新
466  else
467  {
468  for (int x = rctCorrected.left; x < rctCorrected.right; x++)
469  {
470  for (int y = rctCorrected.top; y < rctCorrected.bottom; y++)
471  {
472  int index = x + y * w;
473  dst[index] = src[index];
474  }
475  }
476  }
477  }
478  // 跳过像素的模式
479  else
480  {
481  // 全部更新
482  if (isAllFlush)
483  {
484  int len = w * h;
485  for (int i = 0; i < len; i++) // 线性遍历画布
486  {
487  if (dst[i] == src[i]) // 若两画布某位置色彩重叠，则跳过接下来的 n 个像素点
488  {
489  i += g_vecWindows[index].nSkipPixels;
490  continue;
491  }
492  dst[i] = src[i];
493  }
494  }
495  // 部分更新
496  else
497  {
498  for (int y = rctCorrected.top; y < rctCorrected.bottom; y++) // 在矩形区域内遍历画布
499  {
500  for (int x = rctCorrected.left; x < rctCorrected.right; x++)
501  {
502  int index = x + y * w;
503  if (dst[index] == src[index]) // 若两画布某位置色彩重叠，则在 x 方向上跳过接下来的 n 个像素点
504  {
505  x += g_vecWindows[index].nSkipPixels;
506  continue;
507  }
508  dst[index] = src[index];
509  }
510  }
511  }
512  }
513  }// FlushDrawing

◆ FlushDrawing() [2/2]

void HiEasyX::FlushDrawing ( RECT  rct = { 0 }) 
    更新当前活动窗口的双缓冲
 注意：
    由于安全性问题，必须在窗口任务内调用此函数，否则不会更新双缓冲。
 备注：
    若要重绘窗口请使用 RedrawWindow
 示例：

BEGIN_TASK();


hiex::FlushDrawing({ 200,200,300,300 });


END_TASK(false);    // 注意，结束任务时标记 false 表示不更新双缓冲，因为上面已经更新过了


REDRAW_WINDOW();
参数
[in]rct双缓冲更新区域（坐标都为 0 表示全部区域）

在文件 HiWindow.cpp 第 516 行定义.

517  {
518  // 为了防止用户更新双缓冲时窗口拉伸导致画布冲突，必须在窗口任务内调用此函数
519  if (IsInTask())
520  {
521  FlushDrawing(g_nFocusWindowIndex, rct);
522  }
523  }

◆ flushmessage_win32()

void HiEasyX::flushmessage_win32 ( BYTE  filter = -1,
HWND  hWnd = nullptr 
)

清除所有消息记录

参数
[in]filter消息筛选方式
[in]hWnd窗口句柄（为空代表当前活动窗口）

在文件 HiWindow.cpp 第 753 行定义.

754  {
755  ClearMessage(filter, hWnd);
756  }

◆ FlushMouseMsgBuffer_win32()

void HiEasyX::FlushMouseMsgBuffer_win32 ( HWND  hWnd = nullptr)

清空鼠标消息

参数
[in]hWnd窗口句柄（为空代表当前活动窗口）

在文件 HiWindow.cpp 第 777 行定义.

778  {
779  ClearMessage(EM_MOUSE, hWnd);
780  }

◆ FreeWindow()

void HiEasyX::FreeWindow ( int  index)

在文件 HiWindow.cpp 第 174 行定义.

175  {
176  if (!IsValidWindowIndex(index))
177  {
178  return;
179  }
180 
181  // 閲婃斁缁樺浘缂撳啿
182  if (g_vecWindows[index].pImg)
183  {
184  delete g_vecWindows[index].pImg;
185  g_vecWindows[index].pImg = nullptr;
186  }
187  if (g_vecWindows[index].pBufferImg)
188  {
189  delete g_vecWindows[index].pBufferImg;
190  g_vecWindows[index].pBufferImg = nullptr;
191  }
192 
193  // 閲婃斁娑堟伅鍒楄〃鍐呭瓨
194  std::vector<ExMessage>().swap(g_vecWindows[index].vecMessage);
195 
196  //DestroyWindow(g_vecWindows[index].hWnd);
197  //PostQuitMessage(0);
198  }

◆ Gdiplus_Arc()

void HiEasyX::Gdiplus_Arc ( HDC  hdc,
float  x,
float  y,
float  w,
float  h,
float  stangle,
float  endangle,
Gdiplus::Color  linecolor,
float  linewidth,
Gdiplus::SmoothingMode  smoothing_mode 
)

画圆弧（传入顺时针角度）

在文件 HiGdiplus.cpp 第 216 行定义.

228  {
229  Gdiplus_Try_Starup();
230  Gdiplus::Graphics graphics(hdc);
231  Gdiplus::Pen pen(linecolor, linewidth);
232 
233  graphics.SetPixelOffsetMode(Gdiplus::PixelOffsetModeHalf);
234  graphics.SetSmoothingMode(smoothing_mode);
235  graphics.DrawArc(&pen, x, y, w, h, stangle, endangle);
236  }

◆ Gdiplus_Ellipse()

void HiEasyX::Gdiplus_Ellipse ( HDC  hdc,
float  x,
float  y,
float  w,
float  h,
Gdiplus::Color  linecolor,
float  linewidth,
Gdiplus::SmoothingMode  smoothing_mode 
)

画椭圆

在文件 HiGdiplus.cpp 第 134 行定义.

144  {
145  Gdiplus_Try_Starup();
146  Gdiplus::Graphics graphics(hdc);
147  Gdiplus::Pen pen(linecolor, linewidth);
148 
149  graphics.SetPixelOffsetMode(Gdiplus::PixelOffsetModeHalf);
150  graphics.SetSmoothingMode(smoothing_mode);
151  graphics.DrawEllipse(&pen, x, y, w, h);
152  }

◆ Gdiplus_Line()

void HiEasyX::Gdiplus_Line ( HDC  hdc,
float  x1,
float  y1,
float  x2,
float  y2,
Gdiplus::Color  linecolor,
float  linewidth,
Gdiplus::SmoothingMode  smoothing_mode 
)

画线

在文件 HiGdiplus.cpp 第 40 行定义.

50  {
51  Gdiplus_Try_Starup();
52  Gdiplus::Graphics graphics(hdc);
53  Gdiplus::Pen pen(linecolor, linewidth);
54 
55  graphics.SetPixelOffsetMode(Gdiplus::PixelOffsetModeHalf);
56  graphics.SetSmoothingMode(smoothing_mode);
57  graphics.DrawLine(&pen, x1, y1, x2, y2);
58  }

◆ Gdiplus_Pie()

void HiEasyX::Gdiplus_Pie ( HDC  hdc,
float  x,
float  y,
float  w,
float  h,
float  stangle,
float  endangle,
Gdiplus::Color  linecolor,
float  linewidth,
Gdiplus::SmoothingMode  smoothing_mode 
)

画饼状图（传入顺时针角度）

在文件 HiGdiplus.cpp 第 173 行定义.

185  {
186  Gdiplus_Try_Starup();
187  Gdiplus::Graphics graphics(hdc);
188  Gdiplus::Pen pen(linecolor, linewidth);
189 
190  graphics.SetPixelOffsetMode(Gdiplus::PixelOffsetModeHalf);
191  graphics.SetSmoothingMode(smoothing_mode);
192  graphics.DrawPie(&pen, x, y, w, h, stangle, endangle);
193  }

◆ Gdiplus_Polygon()

void HiEasyX::Gdiplus_Polygon ( HDC  hdc,
int  points_num,
Gdiplus::PointF *  points,
Gdiplus::Color  linecolor,
float  linewidth,
Gdiplus::SmoothingMode  smoothing_mode 
)

画多边形

在文件 HiGdiplus.cpp 第 60 行定义.

68  {
69  Gdiplus_Try_Starup();
70  Gdiplus::Graphics graphics(hdc);
71  Gdiplus::Pen pen(linecolor, linewidth);
72 
73  graphics.SetPixelOffsetMode(Gdiplus::PixelOffsetModeHalf);
74  graphics.SetSmoothingMode(smoothing_mode);
75  graphics.DrawLines(&pen, points, points_num);
76  }

◆ Gdiplus_Rectangle()

void HiEasyX::Gdiplus_Rectangle ( HDC  hdc,
float  x,
float  y,
float  w,
float  h,
Gdiplus::Color  linecolor,
float  linewidth,
Gdiplus::SmoothingMode  smoothing_mode 
)

画矩形

在文件 HiGdiplus.cpp 第 95 行定义.

105  {
106  Gdiplus_Try_Starup();
107  Gdiplus::Graphics graphics(hdc);
108  Gdiplus::Pen pen(linecolor, linewidth);
109 
110  graphics.SetPixelOffsetMode(Gdiplus::PixelOffsetModeHalf);
111  graphics.SetSmoothingMode(smoothing_mode);
112  graphics.DrawRectangle(&pen, x, y, w, h);
113  }

◆ Gdiplus_Shutdown()

void HiEasyX::Gdiplus_Shutdown ( )

关闭 GDI+

在文件 HiGdiplus.cpp 第 21 行定义.

22  {
23  if (g_bStarup)
24  {
25  Gdiplus::GdiplusShutdown(g_Token);
26  g_bStarup = false;
27  }
28  }

◆ Gdiplus_SolidEllipse()

void HiEasyX::Gdiplus_SolidEllipse ( HDC  hdc,
float  x,
float  y,
float  w,
float  h,
Gdiplus::Color  fillcolor,
Gdiplus::SmoothingMode  smoothing_mode 
)

画无边框填充椭圆

在文件 HiGdiplus.cpp 第 154 行定义.

163  {
164  Gdiplus_Try_Starup();
165  Gdiplus::Graphics graphics(hdc);
166  Gdiplus::SolidBrush brush(fillcolor);
167 
168  graphics.SetPixelOffsetMode(Gdiplus::PixelOffsetModeHalf);
169  graphics.SetSmoothingMode(smoothing_mode);
170  graphics.FillEllipse(&brush, x, y, w, h);
171  }

◆ Gdiplus_SolidPie()

void HiEasyX::Gdiplus_SolidPie ( HDC  hdc,
float  x,
float  y,
float  w,
float  h,
float  stangle,
float  endangle,
Gdiplus::Color  fillcolor,
Gdiplus::SmoothingMode  smoothing_mode 
)

画无边框填充饼状图（传入顺时针角度）

在文件 HiGdiplus.cpp 第 195 行定义.

206  {
207  Gdiplus_Try_Starup();
208  Gdiplus::Graphics graphics(hdc);
209  Gdiplus::SolidBrush brush(fillcolor);
210 
211  graphics.SetPixelOffsetMode(Gdiplus::PixelOffsetModeHalf);
212  graphics.SetSmoothingMode(smoothing_mode);
213  graphics.FillPie(&brush, x, y, w, h, stangle, endangle);
214  }

◆ Gdiplus_SolidPolygon()

void HiEasyX::Gdiplus_SolidPolygon ( HDC  hdc,
int  points_num,
Gdiplus::PointF *  points,
Gdiplus::Color  fillcolor,
Gdiplus::SmoothingMode  smoothing_mode 
)

画无边框填充多边形

在文件 HiGdiplus.cpp 第 78 行定义.

85  {
86  Gdiplus_Try_Starup();
87  Gdiplus::Graphics graphics(hdc);
88  Gdiplus::SolidBrush brush(fillcolor);
89 
90  graphics.SetPixelOffsetMode(Gdiplus::PixelOffsetModeHalf);
91  graphics.SetSmoothingMode(smoothing_mode);
92  graphics.FillPolygon(&brush, points, points_num);
93  }

◆ Gdiplus_SolidRectangle()

void HiEasyX::Gdiplus_SolidRectangle ( HDC  hdc,
float  x,
float  y,
float  w,
float  h,
Gdiplus::Color  fillcolor,
Gdiplus::SmoothingMode  smoothing_mode 
)

画无边框填充矩形

在文件 HiGdiplus.cpp 第 115 行定义.

124  {
125  Gdiplus_Try_Starup();
126  Gdiplus::Graphics graphics(hdc);
127  Gdiplus::SolidBrush brush(fillcolor);
128 
129  graphics.SetPixelOffsetMode(Gdiplus::PixelOffsetModeHalf);
130  graphics.SetSmoothingMode(smoothing_mode);
131  graphics.FillRectangle(&brush, x, y, w, h);
132  }

◆ Gdiplus_Try_Starup()

void HiEasyX::Gdiplus_Try_Starup ( )

注意，必须先启动 GDI+，才能使用下面的绘图函数

启动 GDI+，如果已经启动则直接返回

在文件 HiGdiplus.cpp 第 12 行定义.

13  {
14  if (!g_bStarup)
15  {
16  Gdiplus::GdiplusStartup(&g_Token, &g_Input, nullptr);
17  g_bStarup = true;
18  }
19  }

◆ GetCustomIconState()

bool HiEasyX::GetCustomIconState ( )

获取自定义程序图标的启用状态

在文件 HiWindow.cpp 第 650 行定义.

651  {
652  return g_lpszCustomIcon;
653  }

◆ GetDefaultAppIcon()

HICON HiEasyX::GetDefaultAppIcon ( )

在文件 HiWindow.cpp 第 893 行定义.

894  {
895  static HBITMAP hBmp = Image2Bitmap(GetIconImage(), true);
896  static HICON hIcon = Bitmap2Icon(hBmp);
897  static bool init = false;
898  if (!init)
899  {
900  DeleteObject(hBmp);
901  init = true;
902  }
903  return hIcon;
904  }

◆ GetDrawMode()

DrawMode HiEasyX::GetDrawMode ( )

获取全局绘制模式

在文件 HiWindow.cpp 第 376 行定义.

377  {
378  return g_fDrawMode;
379  }

◆ GetFocusWindow()

EasyWindow& HiEasyX::GetFocusWindow ( )

在文件 HiWindow.cpp 第 68 行定义.

69  {
70  static EasyWindow wndEmpty;
71  if (IsFocusWindowExisted())
72  {
73  return g_vecWindows[g_nFocusWindowIndex];
74  }
75  else
76  {
77  wndEmpty = {};
78  return wndEmpty;
79  }
80  }

◆ GetHWnd_win32()

HWND HiEasyX::GetHWnd_win32 ( )

得到当前活动绘图窗口的句柄

在文件 HiWindow.cpp 第 332 行定义.

333  {
334  return IsFocusWindowExisted() ? GetFocusWindow().hWnd : nullptr;
335  }

◆ GetIconImage()

IMAGE * HiEasyX::GetIconImage ( )

获取图标对象（显存的拷贝）

在文件 HiIcon.cpp 第 75 行定义.

76 {
77  static IMAGE img(HIICON_WIDTH, HIICON_HEIGHT);
78  static bool init = false;
79  if (!init)
80  {
81  DWORD* p = GetImageBuffer(&img);
82  memcpy(p, pBuf, HIICON_WIDTH * HIICON_HEIGHT * sizeof DWORD);
83  init = true;
84  }
85 
86  return &img;
87 }

◆ GetIconImageBuffer()

DWORD * HiEasyX::GetIconImageBuffer ( )

获取图标显存

参见
图标大小 HIICON_WIDTH, HIICON_HEIGHT
返回
显存指针

在文件 HiIcon.cpp 第 70 行定义.

71 {
72  return pBuf;
73 }

◆ getmessage_win32() [1/2]

ExMessage HiEasyX::getmessage_win32 ( BYTE  filter = -1,
HWND  hWnd = nullptr 
)

阻塞等待，直到获取到一个新消息

参数
[in]filter消息筛选方式
[in]hWnd窗口句柄（为空代表当前活动窗口）
返回
获取到的消息

在文件 HiWindow.cpp 第 728 行定义.

729  {
730  while (!IsNewMessage(filter, hWnd)) HpSleep(1);
731  ExMessage msg = GetNextMessage(filter, hWnd);
732  RemoveMessage(hWnd);
733  return msg;
734  }

◆ getmessage_win32() [2/2]

void HiEasyX::getmessage_win32 ( ExMessage *  msg,
BYTE  filter = -1,
HWND  hWnd = nullptr 
)

阻塞等待，直到获取到一个新消息

参数
[out]msg返回获取到的消息
[in]filter消息筛选方式
[in]hWnd窗口句柄（为空代表当前活动窗口）

在文件 HiWindow.cpp 第 736 行定义.

737  {
738  ExMessage msgEx = getmessage_win32(filter);
739  if (msg) *msg = msgEx;
740  }

◆ GetMouseMsg_win32()

MOUSEMSG HiEasyX::GetMouseMsg_win32 ( HWND  hWnd = nullptr)

阻塞等待，直到获取到一个新的鼠标消息

参数
[in]hWnd窗口句柄（为空代表当前活动窗口）
返回
鼠标消息

在文件 HiWindow.cpp 第 763 行定义.

764  {
765  ExMessage msgEx = getmessage_win32(EM_MOUSE, hWnd);
766  return To_MouseMsg(msgEx);
767  }

◆ GetMsgVector()

std::vector<ExMessage>& HiEasyX::GetMsgVector ( HWND  hWnd)

在文件 HiWindow.cpp 第 664 行定义.

665  {
666  static std::vector<ExMessage> vec;
667  int index = GetWindowIndex(hWnd);
668  if (IsAliveWindow(index))
669  {
670  return g_vecWindows[index].vecMessage;
671  }
672  else
673  {
674  vec.clear();
675  return vec;
676  }
677  }

◆ GetNextMessage()

ExMessage HiEasyX::GetNextMessage ( BYTE  filter,
HWND  hWnd 
)

在文件 HiWindow.cpp 第 709 行定义.

710  {
711  if (IsNewMessage(filter, hWnd))
712  {
713  for (size_t i = 0; i < GetMsgVector(hWnd).size(); i++)
714  {
715  if (filter & GetExMessageType(GetMsgVector(hWnd)[i]))
716  {
717  for (size_t j = 0; j < i; j++)
718  {
719  RemoveMessage(hWnd);
720  }
721  return GetMsgVector(hWnd)[0];
722  }
723  }
724  }
725  return {};
726  }

◆ GetWindowCanvas()

Canvas * HiEasyX::GetWindowCanvas ( HWND  hWnd = nullptr)

获取窗口画布指针

参数
[in]hWnd窗口句柄（为空表示当前活动窗口）
返回
画布指针，若未绑定画布则返回空

在文件 HiWindow.cpp 第 288 行定义.

289  {
290  int index = GetWindowIndex(hWnd);
291  if (IsAliveWindow(index))
292  {
293  return g_vecWindows[index].pBufferImgCanvas;
294  }
295  else
296  {
297  return nullptr;
298  }
299  }

◆ GetWindowImage()

IMAGE * HiEasyX::GetWindowImage ( HWND  hWnd = nullptr)

获取某窗口的图像指针

参数
[in]hWnd窗口句柄（为空表示当前活动窗口）
返回
缓冲区图像指针

在文件 HiWindow.cpp 第 275 行定义.

276  {
277  int index = GetWindowIndex(hWnd);
278  if (IsAliveWindow(index))
279  {
280  return g_vecWindows[index].pBufferImg;
281  }
282  else
283  {
284  return nullptr;
285  }
286  }

◆ GetWindowIndex()

int HiEasyX::GetWindowIndex ( HWND  hWnd)

在文件 HiWindow.cpp 第 85 行定义.

86  {
87  if (hWnd == nullptr)
88  {
89  return g_nFocusWindowIndex;
90  }
91  int index = NO_WINDOW_INDEX;
92  for (int i = 0; i < (int)g_vecWindows.size(); i++)
93  {
94  if (hWnd == g_vecWindows[i].hWnd)
95  {
96  index = i;
97  break;
98  }
99  }
100  return index;
101  }

◆ GetWindowPos()

POINT HiEasyX::GetWindowPos ( HWND  hWnd = nullptr)

获取窗口位置

参数
[in]hWnd窗口句柄（为空代表当前活动窗口）
返回
窗口位置

在文件 HiWindow.cpp 第 851 行定义.

852  {
853  if (!hWnd) hWnd = GetFocusWindow().hWnd;
854  RECT rct;
855  GetWindowRect(hWnd, &rct);
856  return { rct.left, rct.top };
857  }

◆ GetWindowSize()

SIZE HiEasyX::GetWindowSize ( HWND  hWnd = nullptr)

获取窗口大小

参数
[in]hWnd窗口句柄（为空代表当前活动窗口）
返回
窗口大小

在文件 HiWindow.cpp 第 859 行定义.

860  {
861  if (!hWnd) hWnd = GetFocusWindow().hWnd;
862  RECT rct;
863  GetWindowRect(hWnd, &rct);
864  return { rct.right - rct.left, rct.bottom - rct.top };
865  }

◆ GetWorkingWindow()

EasyWindow HiEasyX::GetWorkingWindow ( )

得到当前绘图窗口的详细信息

在文件 HiWindow.cpp 第 337 行定义.

338  {
339  return GetFocusWindow();
340  }

◆ init_end()

void HiEasyX::init_end ( HWND  hWnd = nullptr)

初始化窗口结束后，可以用此函数阻塞等待目标窗口被关闭，然后函数返回

参数
[in]hWnd目标窗口（为空代表所有窗口）

在文件 HiWindow.cpp 第 311 行定义.

312  {
313  if (hWnd)
314  {
315  int index = GetWindowIndex(hWnd);
316  while (IsAliveWindow(index))
317  Sleep(100);
318  }
319  else
320  while (IsAnyWindow())
321  Sleep(100);
322  }

◆ initgraph_win32()

HWND HiEasyX::initgraph_win32 ( int  w = 640,
int  h = 480,
int  flag = EW_NORMAL,
LPCTSTR  lpszWndTitle = L"",
WNDPROC  WindowProcess = nullptr,
HWND  hParent = nullptr 
) 
    创建 Win32 绘图窗口（异于原生 EasyX 窗口）
 备注：
    窗口默认支持双击消息、调整大小（使用 EnableResizing 宏设置是否可以调整大小）
参数
[in]w窗口宽
[in]h窗口高
[in]flag窗口样式（EW_ 系列宏，默认为 EW_NORMAL）
[in]lpszWndTitle窗口标题
[in]WindowProcess窗口过程函数
[in]hParent父窗口句柄
返回
创建的窗口句柄
Bug:
不建议大批量创建绘图窗口，如果必要，请适当添加延时，否则可能导致未知问题。
窗口过程函数规范

函数签名： LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);

注意事项： 若要以默认方式处理消息，则返回 HIWINDOW_DEFAULT_PROC 即可（不要使用 DefWindowProc 函数）

示例函数：

LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
switch (msg)
{
case WM_PAINT:
BEGIN_TASK_WND(hWnd);
circle(100, 100, 70);
END_TASK();
break;
case WM_CLOSE:
DestroyWindow(hWnd);
break;
case WM_DESTROY:
// TODO: 在此处释放申请的内存
PostQuitMessage(0);
break;
default:
return HIWINDOW_DEFAULT_PROC; // 标识使用默认消息处理函数继续处理
// 若要以默认方式处理，请勿使用此语句
//return DefWindowProc(hWnd, msg, wParam, lParam);
break;
}
return 0;
}

在文件 HiWindow.cpp 第 1630 行定义.

1631  {
1632  // 标记是否已经完成窗口创建任务
1633  int nDoneFlag = 0;
1634  HWND hWnd = nullptr;
1635 
1636  // 存在父窗口时，实现模态窗口
1637  if (hParent)
1638  {
1639  // 禁用父窗口（该窗口被销毁后，父窗口将会恢复正常）
1640  EnableWindow(hParent, false);
1641  }
1642 
1643  std::thread(InitWindow, w, h, flag, lpszWndTitle, WindowProcess, hParent, &nDoneFlag, &hWnd).detach();
1644 
1645  while (nDoneFlag == 0) Sleep(50); // 等待窗口创建完成
1646  if (nDoneFlag == -1)
1647  {
1648  if (hParent) // 创建子窗口失败，则使父窗口恢复正常
1649  {
1650  EnableWindow(hParent, true);
1651  }
1652  return nullptr;
1653  }
1654  else
1655  {
1656  // 预设背景色
1657  if (SetWorkingWindow(hWnd) && BeginTask())
1658  {
1659  setbkcolor(CLASSICGRAY);
1660  settextcolor(BLACK);
1661  setlinecolor(BLACK);
1662  setfillcolor(BLACK);
1663  cleardevice();
1664  EndTask();
1665  RedrawWindow();
1666  }
1667 
1668  return hWnd;
1669  }
1670  }

◆ InitWindow()

void HiEasyX::InitWindow ( int  w,
int  h,
int  flag,
LPCTSTR  lpszWndTitle,
WNDPROC  WindowProcess,
HWND  hParent,
int *  nDoneFlag,
HWND *  hWnd 
)

在文件 HiWindow.cpp 第 1426 行定义.

1427  {
1428  static int nWndCount = 0; // 已创建窗口计数（用于生成窗口标题）
1429  std::wstring wstrTitle; // 窗口标题
1430  EasyWindow wnd; // 窗口信息
1431  int nFrameW, nFrameH; // 窗口标题栏宽高（各个窗口可能不同）
1432  int nIndexWnd = nWndCount; // 记录这个窗口的 id
1433 
1434  // 可能多个窗口同时在创建，为了防止预设窗口属性交叉，先备份数据，让出全局变量
1435  bool isPreStyle = g_isPreStyle;
1436  bool isPreStyleEx = g_isPreStyleEx;
1437  bool isPrePos = g_isPrePos;
1438  bool isPreShowState = g_isPreShowState;
1439  long lPreStyle = g_lPreStyle;
1440  long lPreStyleEx = g_lPreStyleEx;
1441  POINT pPrePos = g_pPrePos;
1442  int nPreCmdShow = g_nPreCmdShow;
1443 
1444  g_isPreStyle = false;
1445  g_isPreStyleEx = false;
1446  g_isPrePos = false;
1447  g_isPreShowState = false;
1448 
1449  // 未设置标题
1450  if (lstrlen(lpszWndTitle) == 0)
1451  {
1452  wstrTitle = L"EasyX_" + (std::wstring)GetEasyXVer() + L" HiEasyX (" _HIEASYX_VER_STR_ + L")";
1453  if (nWndCount != 0)
1454  {
1455  wstrTitle += L" ( WindowID: " + std::to_wstring(nWndCount + 1) + L" )";
1456  }
1457  }
1458  else
1459  {
1460  wstrTitle = lpszWndTitle;
1461  }
1462 
1463  // 第一次创建窗口 --- 初始化各项数据
1464  if (nWndCount == 0)
1465  {
1466  // 发布模式下渲染开场动画
1467 #ifndef _DEBUG
1468 #ifndef _NO_START_ANIMATION_
1469 
1470  // 渲染开场动画
1471  RenderStartScene();
1472 
1473 #endif // _NO_START_ANIMATION_
1474 #endif // RELEASE
1475 
1476  // 获取分辨率
1477  g_screenSize = GetScreenSize();
1478 
1479  // 默认程序图标
1480  g_hIconDefault = GetDefaultAppIcon();
1481 
1482  // 注册窗口类
1483  RegisterWndClass();
1484  g_hConsole = GetConsoleWindow();
1485 
1486  // 隐藏控制台
1487  if (g_hConsole)
1488  {
1489  ShowWindow(g_hConsole, SW_HIDE);
1490  }
1491 
1492  // 获取系统任务栏自定义的消息代码
1493  g_uWM_TASKBARCREATED = RegisterWindowMessage(TEXT("TaskbarCreated"));
1494  }
1495 
1496  // 如果现在不存在任何窗口
1497  if (!IsAnyWindow())
1498  {
1499  // 初始化 GDI+ 绘图环境
1500  Gdiplus_Try_Starup();
1501  }
1502 
1503  // 控制台
1504  if (g_hConsole && flag & EW_SHOWCONSOLE)
1505  {
1506  ShowWindow(g_hConsole, flag & SW_NORMAL);
1507  }
1508 
1509  // 用户在创建窗口时设置的窗口属性
1510  long user_style = WS_OVERLAPPEDWINDOW;
1511  if (flag & EW_NOMINIMIZE) // 剔除最小化按钮
1512  {
1513  user_style &= ~WS_MINIMIZEBOX & ~WS_MAXIMIZEBOX & ~WS_SIZEBOX;
1514  }
1515  // 此方法不行，在下面处理此属性
1516  /*if (flag & EW_NOCLOSE)
1517  {
1518  user_style &= ~WS_SYSMENU;
1519  }*/
1520  if (flag & EW_DBLCLKS) // 支持双击
1521  {
1522  user_style |= CS_DBLCLKS;
1523  }
1524 
1525  // 在创建窗口前将窗口加入容器，预设句柄为空，方便过程函数接收 WM_CREATE 消息
1526  InitWindowStruct(wnd, hParent, w, h, WindowProcess);
1527  g_vecWindows.push_back(wnd);
1528 
1529  // 创建窗口
1530  for (int i = 0;; i++)
1531  {
1532  // 最终确定使用的窗口样式
1533  long final_style = user_style;
1534  if (isPreStyle)
1535  final_style = lPreStyle;
1536  final_style |= WS_CLIPCHILDREN; // 必须加入此样式
1537 
1538  // 最终确定使用的窗口扩展样式
1539  long final_style_ex = WS_EX_WINDOWEDGE;
1540  if (isPreStyleEx)
1541  final_style_ex = lPreStyleEx;
1542 
1543  wnd.hWnd = CreateWindowEx(
1544  final_style_ex,
1545  g_lpszClassName,
1546  wstrTitle.c_str(),
1547  final_style,
1548  CW_USEDEFAULT, CW_USEDEFAULT,
1549  w, h, // 宽高现在这样设置，稍后获取边框大小后再调整
1550  hParent,
1551  nullptr,
1552  g_hInstance,
1553  nullptr
1554  );
1555 
1556  if (wnd.hWnd)
1557  {
1558  // 创建窗口成功后，再将句柄记录
1559  g_vecWindows[g_vecWindows.size() - 1].hWnd = wnd.hWnd;
1560  break;
1561  }
1562 
1563  // 三次创建窗口失败，不再尝试
1564  else if (i == 2)
1565  {
1566  std::wstring str = std::to_wstring(GetLastError());
1567  MessageBox(nullptr, (L"Error creating window: " + str).c_str(), L"[Error]", MB_OK | MB_ICONERROR);
1568  *nDoneFlag = -1;
1569  return;
1570  }
1571  }
1572 
1573  // 剔除关闭按钮
1574  if (flag & EW_NOCLOSE)
1575  {
1576  HMENU hmenu = GetSystemMenu(wnd.hWnd, false);
1577  RemoveMenu(hmenu, SC_CLOSE, MF_BYCOMMAND);
1578  }
1579 
1580  // 抢夺窗口焦点
1581  SetWorkingWindow(wnd.hWnd);
1582 
1583  *hWnd = wnd.hWnd;
1584 
1585  // 窗口创建完毕
1586  nWndCount++;
1587 
1588  // 注意：
1589  // 必须在显示窗口前标记已经完成创建窗口。
1590  // 因为可以在自定义过程函数中创建子窗口，若是不在显示窗口前标记窗口创建完成，
1591  // 就会导致父窗口过程函数阻塞，接下来显示窗口就会阻塞，进而导致整个窗口假死。
1592  *nDoneFlag = 1;
1593 
1594  //** 显示窗口等后续处理 **//
1595 
1596  // 获取边框大小，补齐绘图区大小
1597  RECT rcClient, rcWnd;
1598  GetClientRect(wnd.hWnd, &rcClient);
1599  GetWindowRect(wnd.hWnd, &rcWnd);
1600  nFrameW = (rcWnd.right - rcWnd.left) - rcClient.right;
1601  nFrameH = (rcWnd.bottom - rcWnd.top) - rcClient.bottom;
1602 
1603  int px = 0, py = 0;
1604  if (isPrePos)
1605  {
1606  px = pPrePos.x;
1607  py = pPrePos.y;
1608  }
1609  SetWindowPos(
1610  wnd.hWnd,
1611  HWND_TOP,
1612  px, py,
1613  w + nFrameW, h + nFrameH,
1614  isPrePos ? 0 : SWP_NOMOVE
1615  );
1616 
1617  ShowWindow(wnd.hWnd, isPreShowState ? nPreCmdShow : SW_SHOWNORMAL);
1618  UpdateWindow(wnd.hWnd);
1619 
1620  // 消息派发，阻塞
1621  // 窗口销毁后会自动退出
1622  MSG Msg;
1623  while (GetMessage(&Msg, 0, 0, 0) > 0)
1624  {
1625  TranslateMessage(&Msg);
1626  DispatchMessage(&Msg);
1627  }
1628  }

◆ InitWindowStruct()

EasyWindow& HiEasyX::InitWindowStruct ( EasyWindow &  wnd,
HWND  hParent,
int  w,
int  h,
WNDPROC  WindowProcess 
)

在文件 HiWindow.cpp 第 1402 行定义.

1403  {
1404  wnd.isAlive = true;
1405  wnd.hWnd = nullptr;
1406  wnd.hParent = hParent;
1407  wnd.pImg = new IMAGE(w, h);
1408  wnd.pBufferImg = new IMAGE(w, h);
1409  wnd.pBufferImgCanvas = nullptr;
1410  wnd.isNeedFlush = false;
1411  wnd.funcWndProc = WindowProcess;
1412  wnd.vecMessage.reserve(MSG_RESERVE_SIZE);
1413  wnd.isUseTray = false;
1414  wnd.nid = { 0 };
1415  wnd.isUseTrayMenu = false;
1416  wnd.hTrayMenu = nullptr;
1417  wnd.funcTrayMenuProc = nullptr;
1418  wnd.isNewSize = false;
1419  wnd.isBusyProcessing = false;
1420  wnd.nSkipPixels = 0;
1421  wnd.vecSysCtrl.reserve(SYSCTRL_RESERVE_SIZE);
1422  return wnd;
1423  }

◆ IsAliveWindow() [1/2]

bool HiEasyX::IsAliveWindow ( HWND  hWnd = nullptr)

判断一窗口是否还存在（未被关闭）

参数
[in]hWnd窗口句柄（为空表示当前活动窗口）
返回
是否存在

在文件 HiWindow.cpp 第 111 行定义.

112  {
113  if (hWnd)
114  {
115  int index = GetWindowIndex(hWnd);
116  if (IsValidWindowIndex(index))
117  {
118  return g_vecWindows[index].isAlive;
119  }
120  else
121  {
122  return false;
123  }
124  }
125  else
126  {
127  return IsFocusWindowExisted();
128  }
129  }

◆ IsAliveWindow() [2/2]

bool HiEasyX::IsAliveWindow ( int  index)

在文件 HiWindow.cpp 第 131 行定义.

132  {
133  return IsValidWindowIndex(index) && g_vecWindows[index].isAlive;
134  }

◆ IsAnyWindow()

bool HiEasyX::IsAnyWindow ( )

是否还存在未销毁的绘图窗口

在文件 HiWindow.cpp 第 103 行定义.

104  {
105  for (auto& i : g_vecWindows)
106  if (i.isAlive)
107  return true;
108  return false;
109  }

◆ IsFocusWindowExisted()

bool HiEasyX::IsFocusWindowExisted ( )

在文件 HiWindow.cpp 第 62 行定义.

63  {
64  return IsValidWindowIndex(g_nFocusWindowIndex);
65  }

◆ IsInTask()

bool HiEasyX::IsInTask ( HWND  hWnd = nullptr) 
    判断某窗口是否在任务中
 备注：
    窗口任务是队列式的，只有活动窗口可能处在任务中。
    故若传入窗口不是活动窗口，将直接返回 false。
参数
[in]hWnd窗口句柄（为空表示当前活动窗口）
返回
是否在任务中

在文件 HiWindow.cpp 第 555 行定义.

556  {
557  return g_isInTask && (hWnd ? GetFocusWindow().hWnd == hWnd : true);
558  }

◆ IsNewMessage()

bool HiEasyX::IsNewMessage ( BYTE  filter,
HWND  hWnd 
)

在文件 HiWindow.cpp 第 699 行定义.

700  {
701  for (auto& element : GetMsgVector(hWnd))
702  if (filter & GetExMessageType(element))
703  return true;
704  return false;
705  }

◆ IsValidWindowIndex()

bool HiEasyX::IsValidWindowIndex ( int  index)

在文件 HiWindow.cpp 第 56 行定义.

57  {
58  return index >= 0 && index < (int)g_vecWindows.size();
59  }

◆ IsWindowSizeChanged()

bool HiEasyX::IsWindowSizeChanged ( HWND  hWnd = nullptr)

判断某窗口的大小是否改变

参数
[in]hWnd窗口句柄（为空表示当前活动窗口）
返回
窗口的大小是否改变

在文件 HiWindow.cpp 第 635 行定义.

636  {
637  int index = GetWindowIndex(hWnd);
638  if (IsValidWindowIndex(index))
639  {
640  bool b = g_vecWindows[index].isNewSize;
641  g_vecWindows[index].isNewSize = false;
642  return b;
643  }
644  else
645  {
646  return false;
647  }
648  }

◆ MixAlphaColor()

COLORREF HiEasyX::MixAlphaColor ( COLORREF  cDst,
COLORREF  cSrc,
bool  isCalculated,
BYTE  alpha = 255 
)

根据透明度混合颜色

参数
[in]cDst原位置像素
[in]cSrc待绘制像素（根据其透明度混合颜色）
[in]isCalculated
    待绘制像素点是否已经乘以它的透明度

备注： 此参数用于一些特殊情况，例如透明 png 图像中的像素就是已经乘过透明度的。 

参数

  

    
[in]alpha叠加在 src 上的透明度（默认为 255，即不叠加）


  

  




返回
混合后的颜色（不含 alpha 值）

在文件 HiCanvas.cpp 第 9 行定义.

10  {
11  float fSrc = GetAValue(cSrc) / 255.0f; // 待绘制像素的透明度
12  if (alpha != 255) // 叠加透明度
13  fSrc *= alpha / 255.0f;
14  if (fSrc == 0.0f) // 绘制透明度为 0 时不做任何处理
15  return cDst;
16  float fDst = 1 - fSrc; // 原位置像素应乘透明度
17 
18  if (isCalculated)
19  {
20  return RGB(
21  GetRValue(cSrc) + GetRValue(cDst) * fDst,
22  GetGValue(cSrc) + GetGValue(cDst) * fDst,
23  GetBValue(cSrc) + GetBValue(cDst) * fDst
24  );
25  }
26  else
27  {
28  return RGB(
29  GetRValue(cSrc) * fSrc + GetRValue(cDst) * fDst,
30  GetGValue(cSrc) * fSrc + GetGValue(cDst) * fDst,
31  GetBValue(cSrc) * fSrc + GetBValue(cDst) * fDst
32  );
33  }
34 
35  }

◆ MouseHit_win32()

bool HiEasyX::MouseHit_win32 ( HWND  hWnd = nullptr)

检查是否存在鼠标消息

参数
[in]hWnd窗口句柄（为空代表当前活动窗口）
返回
是否存在鼠标消息

在文件 HiWindow.cpp 第 758 行定义.

759  {
760  return IsNewMessage(EM_MOUSE, hWnd);
761  }

◆ MoveWindow()

void HiEasyX::MoveWindow ( int  x,
int  y,
HWND  hWnd = nullptr 
)

移动窗口

参数
[in]x位置
[in]y位置
[in]hWnd窗口句柄（为空代表当前活动窗口）

在文件 HiWindow.cpp 第 867 行定义.

868  {
869  if (!hWnd) hWnd = GetFocusWindow().hWnd;
870  SetWindowPos(hWnd, HWND_TOP, x, y, 0, 0, SWP_NOSIZE);
871  }

◆ MoveWindowRel()

void HiEasyX::MoveWindowRel ( int  dx,
int  dy,
HWND  hWnd = nullptr 
)

相对移动窗口

参数
[in]dx相对位移
[in]dy相对位移
[in]hWnd窗口句柄（为空代表当前活动窗口）

在文件 HiWindow.cpp 第 873 行定义.

874  {
875  if (!hWnd) hWnd = GetFocusWindow().hWnd;
876  POINT pos = GetWindowPos(hWnd);
877  SetWindowPos(hWnd, HWND_TOP, pos.x + dx, pos.y + dy, 0, 0, SWP_NOSIZE);
878  }

◆ OnCreate()

void HiEasyX::OnCreate ( int  indexWnd,
HWND  hWnd,
LPARAM  lParam 
)

在文件 HiWindow.cpp 第 1213 行定义.

1214  {
1215  }

◆ OnDestroy()

void HiEasyX::OnDestroy ( int  indexWnd,
WPARAM  wParam 
)

在文件 HiWindow.cpp 第 1124 行定义.

1125  {
1126  closegraph_win32(indexWnd);
1127 
1128  // 存在参数，意味着这是用户调用 closegraph_win32 销毁窗口
1129  // 故再调用 DestroyWindow
1130  if (wParam)
1131  {
1132  DestroyWindow(g_vecWindows[indexWnd].hWnd);
1133  }
1134  }

◆ OnMove()

void HiEasyX::OnMove ( HWND  hWnd)

在文件 HiWindow.cpp 第 1109 行定义.

1110  {
1111  //RECT rctWnd;
1112  //GetWindowRect(hWnd, &rctWnd);
1113 
1116  //if (rctWnd.left < g_screenSize.left || rctWnd.top < g_screenSize.top
1117  // || rctWnd.right > g_screenSize.left + g_screenSize.w
1118  // || rctWnd.bottom > g_screenSize.top + g_screenSize.h)
1119  //{
1120  // EnforceRedraw(hWnd);
1121  //}
1122  }

◆ OnPaint()

void HiEasyX::OnPaint ( int  indexWnd,
HDC  hdc 
)

在文件 HiWindow.cpp 第 1087 行定义.

1088  {
1089  // 在开启自动刷新双缓冲的情况下，处理双缓冲的刷新任务
1090  if (g_bAutoFlush && g_vecWindows[indexWnd].isNeedFlush)
1091  {
1092  WaitForProcessing(indexWnd);
1093  g_vecWindows[indexWnd].isBusyProcessing = true; // 不能再启动任务
1094  WaitForTask(g_vecWindows[indexWnd].hWnd); // 等待最后一个任务完成
1095 
1096  // 更新双缓冲
1097  FlushDrawing(indexWnd);
1098  g_vecWindows[indexWnd].isNeedFlush = false;
1099 
1100  g_vecWindows[indexWnd].isBusyProcessing = false;
1101  }
1102 
1103  // 将绘图内容输出到窗口 HDC
1104  RECT rctWnd;
1105  GetClientRect(g_vecWindows[indexWnd].hWnd, &rctWnd);
1106  CopyImageToHDC(g_vecWindows[indexWnd].pImg, hdc, rctWnd);
1107  }

◆ OnSize()

void HiEasyX::OnSize ( int  indexWnd)

在文件 HiWindow.cpp 第 906 行定义.

907  {
908  RECT rctWnd;
909  GetClientRect(g_vecWindows[indexWnd].hWnd, &rctWnd);
910 
911  WaitForProcessing(indexWnd);
912  g_vecWindows[indexWnd].isBusyProcessing = true; // 不能再启动任务
913  WaitForTask(g_vecWindows[indexWnd].hWnd); // 等待最后一个任务完成
914 
915  ResizeWindowImage(indexWnd, rctWnd);
916  if (g_vecWindows[indexWnd].pBufferImgCanvas)
917  {
918  g_vecWindows[indexWnd].pBufferImgCanvas->UpdateSizeInfo();
919  }
920 
921  g_vecWindows[indexWnd].isBusyProcessing = false;
922  }

◆ OnSysCtrlCreate()

HWND HiEasyX::OnSysCtrlCreate ( int  indexWnd,
WPARAM  wParam,
LPARAM  lParam 
)

在文件 HiWindow.cpp 第 1136 行定义.

1137  {
1138  CREATESTRUCT* c = (CREATESTRUCT*)lParam;
1139  HWND hWnd = CreateWindow(
1140  c->lpszClass,
1141  c->lpszName,
1142  c->style,
1143  c->x, c->y,
1144  c->cx, c->cy,
1145  c->hwndParent,
1146  c->hMenu,
1147  GetModuleHandle(0),
1148  c->lpCreateParams
1149  );
1150 
1151  // 璁板綍
1152  g_vecWindows[indexWnd].vecSysCtrl.push_back((SysControlBase*)wParam);
1153  return hWnd;
1154  }

◆ OnTaskBarCreated()

void HiEasyX::OnTaskBarCreated ( int  indexWnd)

在文件 HiWindow.cpp 第 962 行定义.

963  {
964  if (g_vecWindows[indexWnd].isUseTray)
965  {
966  ShowTray(&g_vecWindows[indexWnd].nid);
967  }
968  }

◆ OnTray()

void HiEasyX::OnTray ( int  indexWnd,
LPARAM  lParam 
)

在文件 HiWindow.cpp 第 924 行定义.

925  {
926  if (g_vecWindows[indexWnd].isUseTray)
927  {
928  HWND hWnd = g_vecWindows[indexWnd].hWnd;
929  POINT ptMouse;
930  GetCursorPos(&ptMouse);
931 
932  switch (lParam)
933  {
934  // 左键激活窗口
935  case WM_LBUTTONDOWN:
936  SetForegroundWindow(hWnd);
937  break;
938 
939  // 右键打开菜单
940  case WM_RBUTTONDOWN:
941  if (g_vecWindows[indexWnd].isUseTrayMenu)
942  {
943  SetForegroundWindow(hWnd); // 激活一下窗口，防止菜单不消失
944 
945  // 显示菜单并跟踪
946  int nMenuId = TrackPopupMenu(g_vecWindows[indexWnd].hTrayMenu, TPM_RETURNCMD, ptMouse.x, ptMouse.y, 0, hWnd, nullptr);
947  if (nMenuId == 0) PostMessage(hWnd, WM_LBUTTONDOWN, 0, 0);
948  if (g_vecWindows[indexWnd].funcTrayMenuProc)
949  {
950  g_vecWindows[indexWnd].funcTrayMenuProc(nMenuId);
951  }
952 
953  }
954  break;
955 
956  default:
957  break;
958  }
959  }
960  }

◆ peekmessage_win32()

bool HiEasyX::peekmessage_win32 ( ExMessage *  msg,
BYTE  filter = -1,
bool  removemsg = true,
HWND  hWnd = nullptr 
)

获取一个消息，立即返回是否获取成功

参数
[out]msg返回获取到的消息
[in]filter消息筛选方式
[in]removemsg获取消息后是否将其移除
[in]hWnd窗口句柄（为空代表当前活动窗口）
返回
是否获取到消息

在文件 HiWindow.cpp 第 742 行定义.

743  {
744  if (IsNewMessage(filter, hWnd))
745  {
746  if (msg) *msg = GetNextMessage(filter, hWnd);
747  if (removemsg) RemoveMessage(hWnd);
748  return true;
749  }
750  return false;
751  }

◆ PeekMouseMsg_win32()

bool HiEasyX::PeekMouseMsg_win32 ( MOUSEMSG *  pMsg,
bool  bRemoveMsg = true,
HWND  hWnd = nullptr 
)

获取一个新的鼠标消息，立即返回是否获取成功

参数
[out]pMsg返回获取到的消息
[in]bRemoveMsg获取消息后是否将其移除
[in]hWnd窗口句柄（为空代表当前活动窗口）
返回
是否获取到消息

在文件 HiWindow.cpp 第 769 行定义.

770  {
771  ExMessage msgEx;
772  bool r = peekmessage_win32(&msgEx, EM_MOUSE, bRemoveMsg, hWnd);
773  *pMsg = To_MouseMsg(msgEx);
774  return r;
775  }

◆ PreSetWindowPos()

void HiEasyX::PreSetWindowPos ( int  x,
int  y 
)

在创建窗口前设置窗口位置，仅对此操作后首个新窗口生效

参数
[in]x位置
[in]y位置

在文件 HiWindow.cpp 第 827 行定义.

828  {
829  g_isPrePos = true;
830  g_pPrePos = { x,y };
831  }

◆ PreSetWindowShowState()

void HiEasyX::PreSetWindowShowState ( int  nCmdShow)

在创建窗口前设置窗口显示状态，仅对此操作后首个新窗口生效

参数
[in]nCmdShow显示状态（和 ShowWindow 用法一致）

在文件 HiWindow.cpp 第 833 行定义.

834  {
835  g_isPreShowState = true;
836  g_nPreCmdShow = nCmdShow;
837  }

◆ PreSetWindowStyle()

void HiEasyX::PreSetWindowStyle ( long  lStyle) 
    在创建窗口前设置窗口样式，仅对此操作后首个新窗口生效
 注意：
    新窗口的所有普通样式都将被当前样式覆盖
参数
[in]lStyle新样式

在文件 HiWindow.cpp 第 815 行定义.

816  {
817  g_isPreStyle = true;
818  g_lPreStyle = lStyle;
819  }

◆ PreSetWindowStyleEx()

void HiEasyX::PreSetWindowStyleEx ( long  lStyleEx) 
    在创建窗口前设置窗口扩展样式，仅对此操作后首个新窗口生效
 注意：
    新窗口的所有扩展样式都将被当前样式覆盖
参数
[in]lStyleEx新样式

在文件 HiWindow.cpp 第 821 行定义.

822  {
823  g_isPreStyleEx = true;
824  g_lPreStyleEx = lStyleEx;
825  }

◆ QuickDraw()

void HiEasyX::QuickDraw ( UINT  nSkipPixels,
HWND  hWnd = nullptr 
)

设置加速绘制跳过多少像素点

警告
此加速效果是有损的，加速效果与跳过的像素点数正相关
参数
[in]nSkipPixels跳过的像素点数目
[in]hWnd窗口句柄（为空表示当前活动窗口）

在文件 HiWindow.cpp 第 369 行定义.

370  {
371  int index = GetWindowIndex(hWnd);
372  if (IsAliveWindow(index))
373  g_vecWindows[index].nSkipPixels = nSkipPixels;
374  }

◆ RedrawWindow()

void HiEasyX::RedrawWindow ( HWND  hWnd = nullptr)

通知重绘绘图窗口（在 WM_PAINT 消息内绘图不需要使用此函数）

参数
[in]hWnd要重绘的窗口

在文件 HiWindow.cpp 第 392 行定义.

393  {
394  if (!hWnd)
395  hWnd = GetFocusWindow().hWnd;
396 
397  switch (g_fDrawMode)
398  {
399  case DM_Real:
400  SendUserRedrawMsg(hWnd);
401  break;
402 
403  case DM_Normal:
404  // 这个太慢了
405  //InvalidateRect(hWnd, nullptr, false);
406  SendUserRedrawMsg(hWnd);
407  break;
408 
409  case DM_Fast:
410  if (!(clock() % 2))
411  SendUserRedrawMsg(hWnd);
412  break;
413 
414  case DM_VeryFast:
415  if (!(clock() % 5))
416  SendUserRedrawMsg(hWnd);
417  break;
418 
419  case DM_Fastest:
420  if (!(clock() % 9))
421  SendUserRedrawMsg(hWnd);
422  break;
423 
424  }
425  }

◆ RegisterExMessage()

void HiEasyX::RegisterExMessage ( int  indexWnd,
UINT  msg,
WPARAM  wParam,
LPARAM  lParam 
)

在文件 HiWindow.cpp 第 971 行定义.

972  {
973  // 记录消息事件
974  switch (msg)
975  {
976  // EM_MOUSE
977  case WM_MOUSEMOVE:
978  case WM_MOUSEWHEEL:
979  case WM_LBUTTONDOWN:
980  case WM_LBUTTONUP:
981  case WM_LBUTTONDBLCLK:
982  case WM_MBUTTONDOWN:
983  case WM_MBUTTONUP:
984  case WM_MBUTTONDBLCLK:
985  case WM_RBUTTONDOWN:
986  case WM_RBUTTONUP:
987  case WM_RBUTTONDBLCLK:
988  {
989  ExMessage msgMouse = {};
990  msgMouse.message = msg;
991  msgMouse.x = GET_X_LPARAM(lParam);
992  msgMouse.y = GET_Y_LPARAM(lParam);
993  msgMouse.wheel = GET_WHEEL_DELTA_WPARAM(wParam);
994  msgMouse.shift = LOWORD(wParam) & 0x04 ? true : false;
995  msgMouse.ctrl = LOWORD(wParam) & 0x08 ? true : false;
996  msgMouse.lbutton = LOWORD(wParam) & 0x01 ? true : false;
997  msgMouse.mbutton = LOWORD(wParam) & 0x10 ? true : false;
998  msgMouse.rbutton = LOWORD(wParam) & 0x02 ? true : false;
999 
1000  // 有滚轮消息时，得到的坐标是屏幕坐标，需要转换
1001  if (msgMouse.wheel)
1002  {
1003  POINT p = { msgMouse.x ,msgMouse.y };
1004  ScreenToClient(g_vecWindows[indexWnd].hWnd, &p);
1005  msgMouse.x = (short)p.x;
1006  msgMouse.y = (short)p.y;
1007  }
1008 
1009  g_vecWindows[indexWnd].vecMessage.push_back(msgMouse);
1010  }
1011  break;
1012 
1013  // EM_KEY
1014  case WM_KEYDOWN:
1015  case WM_KEYUP:
1016  case WM_SYSKEYDOWN:
1017  case WM_SYSKEYUP:
1018  {
1019  // code from MSDN
1020  WORD vkCode = LOWORD(wParam); // virtual-key code
1021  WORD keyFlags = HIWORD(lParam);
1022  WORD scanCode = LOBYTE(keyFlags); // scan code
1023  BOOL isExtendedKey = (keyFlags & KF_EXTENDED) == KF_EXTENDED; // extended-key flag, 1 if scancode has 0xE0 prefix
1024 
1025  if (isExtendedKey)
1026  scanCode = MAKEWORD(scanCode, 0xE0);
1027 
1028  BOOL repeatFlag = (keyFlags & KF_REPEAT) == KF_REPEAT; // previous key-state flag, 1 on autorepeat
1029  WORD repeatCount = LOWORD(lParam); // repeat count, > 0 if several keydown messages was combined into one message
1030  BOOL upFlag = (keyFlags & KF_UP) == KF_UP; // transition-state flag, 1 on keyup
1031 
1032  // 功能键：不区分左右
1033  // if we want to distinguish these keys:
1034  //switch (vkCode)
1035  //{
1036  //case VK_SHIFT: // converts to VK_LSHIFT or VK_RSHIFT
1037  //case VK_CONTROL: // converts to VK_LCONTROL or VK_RCONTROL
1038  //case VK_MENU: // converts to VK_LMENU or VK_RMENU
1039  // vkCode = LOWORD(MapVirtualKeyW(scanCode, MAPVK_VSC_TO_VK_EX));
1040  // break;
1041  //}
1042 
1043  ExMessage msgKey = {};
1044  msgKey.message = msg;
1045  msgKey.vkcode = (BYTE)vkCode;
1046  msgKey.scancode = (BYTE)scanCode;
1047  msgKey.extended = isExtendedKey;
1048  msgKey.prevdown = repeatFlag;
1049 
1050  g_vecWindows[indexWnd].vecMessage.push_back(msgKey);
1051 
1052  // 给控制台发一份，支持 _getch() 系列函数
1053  PostMessage(g_hConsole, msg, wParam, lParam);
1054  }
1055  break;
1056 
1057  // EM_CHAR
1058  case WM_CHAR:
1059  {
1060  ExMessage msgChar = {};
1061  msgChar.message = msg;
1062  msgChar.ch = (TCHAR)wParam;
1063  g_vecWindows[indexWnd].vecMessage.push_back(msgChar);
1064 
1065  // 通知控制台
1066  PostMessage(g_hConsole, msg, wParam, lParam);
1067  }
1068  break;
1069 
1070  // EM_WINDOW
1071  case WM_ACTIVATE:
1072  case WM_MOVE:
1073  case WM_SIZE:
1074  {
1075  ExMessage msgWindow = {};
1076  msgWindow.message = msg;
1077  msgWindow.wParam = wParam;
1078  msgWindow.lParam = lParam;
1079  g_vecWindows[indexWnd].vecMessage.push_back(msgWindow);
1080  }
1081  break;
1082 
1083  }
1084  }

◆ RegisterWndClass()

void HiEasyX::RegisterWndClass ( )

在文件 HiWindow.cpp 第 1370 行定义.

1371  {
1372  HICON hIcon = g_hIconDefault;
1373  HICON hIconSm = g_hIconDefault;
1374  if (g_lpszCustomIcon)
1375  hIcon = g_hCustomIcon;
1376  if (g_lpszCustomIconSm)
1377  hIconSm = g_hCustomIconSm;
1378 
1379  g_WndClassEx.cbSize = sizeof WNDCLASSEX;
1380  g_WndClassEx.style = CS_VREDRAW | CS_HREDRAW;
1381  g_WndClassEx.lpfnWndProc = WndProc;
1382  g_WndClassEx.cbClsExtra = 0;
1383  g_WndClassEx.cbWndExtra = 0;
1384  g_WndClassEx.hInstance = g_hInstance;
1385  g_WndClassEx.hIcon = hIcon;
1386  g_WndClassEx.hIconSm = hIconSm;
1387  g_WndClassEx.hCursor = LoadCursor(nullptr, IDC_ARROW);
1388  g_WndClassEx.hbrBackground = (HBRUSH)GetStockObject(WHITE_BRUSH);
1389  g_WndClassEx.lpszMenuName = nullptr;
1390  g_WndClassEx.lpszClassName = g_lpszClassName;
1391 
1392  // 注册窗口类
1393  if (!RegisterClassEx(&g_WndClassEx))
1394  {
1395  std::wstring str = std::to_wstring(GetLastError());
1396  MessageBox(nullptr, (L"Error registing window class: " + str).c_str(), L"[Error]", MB_OK | MB_ICONERROR);
1397  exit(-1);
1398  }
1399  }

◆ RemoveMessage()

void HiEasyX::RemoveMessage ( HWND  hWnd)

在文件 HiWindow.cpp 第 680 行定义.

681  {
682  if (GetMsgVector(hWnd).size())
683  {
684  GetMsgVector(hWnd).erase(GetMsgVector(hWnd).begin());
685  }
686  }

◆ RenderStartScene()

void HiEasyX::RenderStartScene ( )

渲染开场动画

在文件 HiStart.cpp 第 106 行定义.

107 {
108  initgraph(640, 480); // 创建绘图窗口
109  setbkcolor(RGB(80, 80, 80));
110  cleardevice();
111  setbkmode(TRANSPARENT);
112 
113  DWORD* pBuf = GetImageBuffer();
114 
115  GetDstPoints(); // 获取目标点集
116  GetSrcPoints(); // 获取源点集
117 
118  // 运算
119  int x, y;
120  for (int i = 2; i <= 256; i += 2)
121  {
122  //int gray = i - 1 - 50; // 暗
123  //int gray = i - 1 + 10; // 亮
124  int gray = i - 1 + 100; // 正常
125  if (gray < 0) gray = 0;
126  if (gray > 255) gray = 255;
127  COLORREF c = RGB(gray, gray, gray);
128  Blur(pBuf); // 全屏模糊处理
129 
130  for (int d = 0; d < g_nCount; d++)
131  {
132  x = g_pSrc[d].x + (g_pDst[d].x - g_pSrc[d].x) * i / 256;
133  y = g_pSrc[d].y + (g_pDst[d].y - g_pSrc[d].y) * i / 256;
134  pBuf[y * 640 + x] = c; // 直接操作显示缓冲区画点
135  //putpixel(g_pDst[d].x, g_pDst[d].y, WHITE);
136  }
137 
138  LPCTSTR lpszText = L"Animation Author : 慢羊羊";
139  outtextxy(getwidth() - textwidth(lpszText), getheight() - textheight(lpszText), lpszText);
140 
141  Sleep(10); // 延时
142  }
143 
144  // 清理内存
145  delete g_pDst;
146  delete g_pSrc;
147 
148  Sleep(2000);
149  ShowWindow(GetHWnd(), SW_HIDE);
150 }

◆ ResizeWindow()

void HiEasyX::ResizeWindow ( int  w,
int  h,
HWND  hWnd = nullptr 
)

重设窗口大小

参数
[in]w窗口宽
[in]h窗口高
[in]hWnd窗口句柄（为空代表当前活动窗口）

在文件 HiWindow.cpp 第 880 行定义.

881  {
882  if (!hWnd) hWnd = GetFocusWindow().hWnd;
883  SetWindowPos(hWnd, HWND_TOP, 0, 0, w, h, SWP_NOMOVE);
884  }

◆ ResizeWindowImage()

void HiEasyX::ResizeWindowImage ( int  index,
RECT  rct 
)

在文件 HiWindow.cpp 第 561 行定义.

562  {
563  if (IsAliveWindow(index))
564  {
565  g_vecWindows[index].pImg->Resize(rct.right, rct.bottom);
566  g_vecWindows[index].pBufferImg->Resize(rct.right, rct.bottom);
567  g_vecWindows[index].isNewSize = true;
568  }
569  }

◆ RotateImage_Alpha()

IMAGE HiEasyX::RotateImage_Alpha ( IMAGE *  pImg,
double  radian,
COLORREF  bkcolor = BLACK 
)

旋转图像（保留透明信息，自适应大小）

参数
[in]pImg原图像
[in]radian旋转弧度
[in]bkcolor背景填充颜色
返回
旋转后的图像

在文件 HiCanvas.cpp 第 84 行定义.

85  {
86  radian = -radian; // 由于 y 轴翻转，旋转角度需要变负
87  float fSin = (float)sin(radian), fCos = (float)cos(radian); // 存储三角函数值
88  float fNSin = (float)sin(-radian), fNCos = (float)cos(-radian);
89  int left = 0, top = 0, right = 0, bottom = 0; // 旋转后图像顶点
90  int w, h;
91  GetImageSize(pImg, &w, &h);
92  DWORD* pBuf = GetImageBuffer(pImg);
93  POINT points[4] = { { 0, 0 },{ w, 0 },{ 0, h },{ w, h } }; // 存储图像顶点
94  for (int j = 0; j < 4; j++) // 旋转图像顶点，搜索旋转后的图像边界
95  {
96  points[j] = {
97  (int)(points[j].x * fCos - points[j].y * fSin),
98  (int)(points[j].x * fSin + points[j].y * fCos)
99  };
100  if (points[j].x < points[left].x) left = j;
101  if (points[j].y > points[top].y) top = j;
102  if (points[j].x > points[right].x) right = j;
103  if (points[j].y < points[bottom].y) bottom = j;
104  }
105 
106  int nw = points[right].x - points[left].x; // 旋转后的图像尺寸
107  int nh = points[top].y - points[bottom].y;
108  int nSize = nw * nh;
109  int offset_x = points[left].x < 0 ? points[left].x : 0; // 旋转后图像超出第一象限的位移（据此调整图像位置）
110  int offset_y = points[bottom].y < 0 ? points[bottom].y : 0;
111 
112  IMAGE img(nw, nh);
113  DWORD* pNewBuf = GetImageBuffer(&img);
114  if (bkcolor != BLACK) // 设置图像背景色
115  for (int i = 0; i < nSize; i++)
116  pNewBuf[i] = BGR(bkcolor);
117 
118  for (int i = offset_x, ni = 0; ni < nw; i++, ni++) // i 用于映射原图像坐标，ni 用于定位旋转后图像坐标
119  {
120  for (int j = offset_y, nj = 0; nj < nh; j++, nj++)
121  {
122  int nx = (int)(i * fNCos - j * fNSin); // 从旋转后的图像坐标向原图像坐标映射
123  int ny = (int)(i * fNSin + j * fNCos);
124  if (nx >= 0 && nx < w && ny >= 0 && ny < h) // 若目标映射在原图像范围内，则拷贝色值
125  pNewBuf[nj * nw + ni] = pBuf[ny * w + nx];
126  }
127  }
128 
129  return img;
130  }

◆ SendUserRedrawMsg()

void HiEasyX::SendUserRedrawMsg ( HWND  hWnd)

在文件 HiWindow.cpp 第 387 行定义.

388  {
389  SendMessage(hWnd, WM_USER_REDRAW, 0, 0);
390  }

◆ SetCustomIcon()

void HiEasyX::SetCustomIcon ( LPCTSTR  lpszIcon,
LPCTSTR  lpszIconSm 
) 
    使用自定义图标资源作为程序图标
 备注：
    必须在第一次创建窗口前就调用该函数才能生效。
    使用 MAKEINTRESOURCE 宏可以将资源 ID 转为字符串。
参数
[in]lpszIcon大图标资源
[in]lpszIconSm小图标资源

在文件 HiWindow.cpp 第 655 行定义.

656  {
657  g_lpszCustomIcon = lpszIcon;
658  g_lpszCustomIconSm = lpszIconSm;
659  g_hCustomIcon = LoadIcon(g_hInstance, lpszIcon);
660  g_hCustomIconSm = LoadIcon(g_hInstance, lpszIconSm);
661  }

◆ SetDrawMode()

void HiEasyX::SetDrawMode ( DrawMode  mode)

设置全局绘制模式

参数
[in]mode全局绘制模式

在文件 HiWindow.cpp 第 381 行定义.

382  {
383  g_fDrawMode = mode;
384  }

◆ SetTrayMenu()

void HiEasyX::SetTrayMenu ( HMENU  hMenu,
HWND  hWnd = nullptr 
)

设置托盘菜单（允许在任何时候设置）

参数
[in]hMenu菜单
[in]hWnd窗口句柄（为空表示当前活动窗口）

在文件 HiWindow.cpp 第 616 行定义.

617  {
618  int index = GetWindowIndex(hWnd);
619  if (IsAliveWindow(index))
620  {
621  g_vecWindows[index].isUseTrayMenu = true;
622  g_vecWindows[index].hTrayMenu = hMenu;
623  }
624  }

◆ SetTrayMenuProcFunc()

void HiEasyX::SetTrayMenuProcFunc ( void(*)(UINT)  pFunc,
HWND  hWnd = nullptr 
)

设置托盘菜单消息处理函数

参数
[in]pFunc消息处理函数
[in]hWnd窗口句柄（为空表示当前活动窗口）

在文件 HiWindow.cpp 第 626 行定义.

627  {
628  int index = GetWindowIndex(hWnd);
629  if (IsAliveWindow(index))
630  {
631  g_vecWindows[index].funcTrayMenuProc = pFunc;
632  }
633  }

◆ SetWindowExStyle()

int HiEasyX::SetWindowExStyle ( long  lNewExStyle,
HWND  hWnd = nullptr 
)

设置某窗口扩展样式

参数
[in]lNewExStyle新样式
[in]hWnd窗口句柄（为空代表当前活动窗口）
返回
返回上一次设置的窗口样式，失败返回 0

在文件 HiWindow.cpp 第 845 行定义.

846  {
847  if (hWnd == nullptr) hWnd = GetFocusWindow().hWnd;
848  return SetWindowLong(hWnd, GWL_EXSTYLE, lNewExStyle);
849  }

◆ SetWindowStyle()

int HiEasyX::SetWindowStyle ( long  lNewStyle,
HWND  hWnd = nullptr 
)

设置某窗口样式

参数
[in]lNewStyle新样式
[in]hWnd窗口句柄（为空代表当前活动窗口）
返回
返回上一次设置的窗口样式，失败返回 0

在文件 HiWindow.cpp 第 839 行定义.

840  {
841  if (hWnd == nullptr) hWnd = GetFocusWindow().hWnd;
842  return SetWindowLong(hWnd, GWL_STYLE, lNewStyle);
843  }

◆ SetWindowTitle()

void HiEasyX::SetWindowTitle ( LPCTSTR  lpszTitle,
HWND  hWnd = nullptr 
)

设置窗口标题文本

参数
[in]lpszTitle新的窗口标题
[in]hWnd窗口句柄（为空代表当前活动窗口）

在文件 HiWindow.cpp 第 886 行定义.

887  {
888  if (!hWnd) hWnd = GetFocusWindow().hWnd;
889  SetWindowText(hWnd, lpszTitle);
890  }

◆ SetWndProcFunc()

void HiEasyX::SetWndProcFunc ( HWND  hWnd,
WNDPROC  WindowProcess 
)

设置某窗口的过程函数

参数
[in]hWnd窗口句柄（为空标识当前活动窗口）
[in]WindowProcess新的过程函数

在文件 HiWindow.cpp 第 266 行定义.

267  {
268  int index = GetWindowIndex(hWnd);
269  if (IsAliveWindow(index))
270  {
271  g_vecWindows[index].funcWndProc = WindowProcess;
272  }
273  }

◆ SetWorkingWindow()

bool HiEasyX::SetWorkingWindow ( HWND  hWnd)

等待当前任务完成并设置活动窗口

参数
[in]hWnd新的活动窗口句柄
返回
是否设置成功

在文件 HiWindow.cpp 第 342 行定义.

343  {
344  if (!hWnd || GetFocusWindow().hWnd == hWnd)
345  {
346  if (GetWorkingImage() != GetFocusWindow().pBufferImg)
347  {
348  SetWorkingImage(GetFocusWindow().pBufferImg);
349  }
350  return true;
351  }
352 
353  int index = GetWindowIndex(hWnd);
354  if (IsAliveWindow(index))
355  {
356  WaitForTask();
357  WaitForProcessing(index);
358  g_nFocusWindowIndex = index;
359 
360  SetWorkingImage(GetFocusWindow().pBufferImg);
361  return true;
362  }
363  else
364  {
365  return false;
366  }
367  }

◆ ShowTray()

void HiEasyX::ShowTray ( NOTIFYICONDATA *  nid)

在文件 HiWindow.cpp 第 571 行定义.

572  {
573  Shell_NotifyIcon(NIM_ADD, nid);
574  }

◆ SysCtrlProc()

LRESULT HiEasyX::SysCtrlProc ( int  indexWnd,
UINT  msg,
WPARAM  wParam,
LPARAM  lParam,
bool &  bRet 
)

在文件 HiWindow.cpp 第 1158 行定义.

1159  {
1160  switch (msg)
1161  {
1162  // 创建系统控件
1163  case WM_SYSCTRL_CREATE:
1164  {
1165  g_vecWindows[indexWnd].bHasCtrl = true;
1166  bRet = true;
1167  return (LRESULT)OnSysCtrlCreate(indexWnd, wParam, lParam);
1168  break;
1169  }
1170 
1171  // 析构系统控件
1172  case WM_SYSCTRL_DELETE:
1173  {
1174  // 被析构的控件指针标记为空
1175  for (size_t i = 0; i < g_vecWindows[indexWnd].vecSysCtrl.size(); i++)
1176  {
1177  if (g_vecWindows[indexWnd].vecSysCtrl[i] == (SysControlBase*)wParam)
1178  {
1179  g_vecWindows[indexWnd].vecSysCtrl[i] = nullptr;
1180  }
1181  }
1182 
1183  bRet = true;
1184  return 0;
1185  break;
1186  }
1187 
1188  }
1189 
1190  // 存在控件时，派发消息
1191  if (g_vecWindows[indexWnd].bHasCtrl)
1192  {
1193  bool bCtrlRet = false;
1194  LRESULT lr = 0;
1195  for (auto& pCtrl : g_vecWindows[indexWnd].vecSysCtrl)
1196  {
1197  if (pCtrl)
1198  {
1199  LRESULT lr = pCtrl->UpdateMessage(msg, wParam, lParam, bCtrlRet);
1200  if (bCtrlRet)
1201  {
1202  bRet = true;
1203  return lr;
1204  }
1205  }
1206  }
1207  }
1208 
1209  bRet = false;
1210  return 0;
1211  }

◆ To_ExMessage()

ExMessage HiEasyX::To_ExMessage ( MOUSEMSG  msg)

MOUSEMSG 转 ExMessage

参数
[in]msgMOUSEMSG 消息
返回
ExMessage 消息

在文件 HiWindow.cpp 第 782 行定义.

783  {
784  ExMessage msgEx = {};
785  msgEx.message = msg.uMsg;
786  msgEx.ctrl = msg.mkCtrl;
787  msgEx.shift = msg.mkShift;
788  msgEx.lbutton = msg.mkLButton;
789  msgEx.mbutton = msg.mkMButton;
790  msgEx.rbutton = msg.mkRButton;
791  msgEx.x = msg.x;
792  msgEx.y = msg.y;
793  msgEx.wheel = msg.wheel;
794  return msgEx;
795  }

◆ To_MouseMsg()

MOUSEMSG HiEasyX::To_MouseMsg ( ExMessage  msgEx) 
    ExMessage 转 MOUSEMSG
 备注：
    ExMessage 消息类型若不是 EM_MOUSE，则返回空
参数
[in]msgExExMessage 消息
返回
MOUSEMSG 消息

在文件 HiWindow.cpp 第 797 行定义.

798  {
799  MOUSEMSG msg = {};
800  if (GetExMessageType(msgEx) == EM_MOUSE)
801  {
802  msg.uMsg = msgEx.message;
803  msg.mkCtrl = msgEx.ctrl;
804  msg.mkShift = msgEx.shift;
805  msg.mkLButton = msgEx.lbutton;
806  msg.mkMButton = msgEx.mbutton;
807  msg.mkRButton = msgEx.rbutton;
808  msg.x = msgEx.x;
809  msg.y = msgEx.y;
810  msg.wheel = msgEx.wheel;
811  }
812  return msg;
813  }

◆ WaitForProcessing()

void HiEasyX::WaitForProcessing ( int  index)

在文件 HiWindow.cpp 第 137 行定义.

138  {
139  // 死窗口可能正在销毁，故不用 isAliveWindow
140  if (IsValidWindowIndex(index))
141  {
142  while (g_vecWindows[index].isBusyProcessing)
143  {
144  HpSleep(1);
145  }
146  }
147  }

◆ WaitForTask()

void HiEasyX::WaitForTask ( HWND  hWnd = nullptr)

阻塞等待某窗口任务完成

参数
[in]hWnd窗口句柄（为空表示当前活动窗口）

在文件 HiWindow.cpp 第 161 行定义.

162  {
163  // 未设置句柄时只需要等待，若设置了则需要判断该句柄是否对应活动窗口
164  if (!hWnd || (IsFocusWindowExisted() && GetFocusWindow().hWnd == hWnd))
165  {
166  while (g_isInTask)
167  {
168  HpSleep(1);
169  }
170  }
171  }

◆ WndProc()

LRESULT CALLBACK HiEasyX::WndProc ( HWND  hWnd,
UINT  msg,
WPARAM  wParam,
LPARAM  lParam 
)

在文件 HiWindow.cpp 第 1218 行定义.

1219  {
1220  // 窗口矩形信息
1221  LRESULT resultUserProc = HIWINDOW_DEFAULT_PROC; // 记录用户窗口过程函数返回值
1222  int indexWnd = GetWindowIndex(hWnd); // 该窗口在已记录列表中的索引
1223 
1224  // 调用窗口不在窗口列表内，则使用默认方法进行处理（无需检查窗口死活）
1225  if (!IsValidWindowIndex(indexWnd))
1226  {
1227  // 也有可能正在接收 WM_CREATE 消息，此时窗口还未加入列表，则调用用户过程函数
1228  if (msg == WM_CREATE)
1229  {
1230  // 此时需要修正 index
1231  int indexReal = (int)g_vecWindows.size() - 1;
1232  OnCreate(indexReal, hWnd, lParam);
1233  WNDPROC proc = g_vecWindows[indexReal].funcWndProc;
1234  if (proc)
1235  {
1236  proc(hWnd, msg, wParam, lParam);
1237  }
1238  }
1239 
1240  return DefWindowProc(hWnd, msg, wParam, lParam);
1241  }
1242 
1243  //** 开始处理窗口消息 **//
1244 
1245  // 预先处理部分消息
1246  switch (msg)
1247  {
1248  case WM_SIZE:
1249  OnSize(indexWnd);
1250  break;
1251 
1252  // 托盘消息
1253  case WM_TRAY:
1254  OnTray(indexWnd, lParam);
1255  break;
1256 
1257  default:
1258  // 系统任务栏重新创建，此时可能需要重新创建托盘
1259  if (msg == g_uWM_TASKBARCREATED)
1260  {
1261  OnTaskBarCreated(indexWnd);
1262  }
1263  break;
1264  }
1265 
1266  // 活窗口的一般事件处理
1267  if (IsAliveWindow(indexWnd))
1268  {
1269  // 登记消息
1270  RegisterExMessage(indexWnd, msg, wParam, lParam);
1271 
1272  // 处理系统控件消息
1273  bool bRetSysCtrl = false;
1274  LRESULT lrSysCtrl = SysCtrlProc(indexWnd, msg, wParam, lParam, bRetSysCtrl);
1275  if (bRetSysCtrl)
1276  return lrSysCtrl;
1277  }
1278 
1279  // 调用用户消息处理函数
1280  if (g_vecWindows[indexWnd].funcWndProc)
1281  {
1282  resultUserProc = g_vecWindows[indexWnd].funcWndProc(hWnd, msg, wParam, lParam);
1283  }
1284 
1285  // 善后工作
1286  switch (msg)
1287  {
1288  // 用户重绘消息，处理完直接返回
1289  // 也无需调用系统重绘方法
1290  // 放着是为了让用户也能处理到这个消息
1291  case WM_USER_REDRAW:
1292  {
1293  HDC hdc = GetDC(hWnd);
1294  OnPaint(indexWnd, hdc);
1295  ReleaseDC(hWnd, hdc);
1296  return 0;
1297  break;
1298  }
1299 
1300  // 因为用户可能在过程函数中绘图，要在他之后输出缓存
1301  case WM_PAINT:
1302  {
1303  HDC hdc;
1304  PAINTSTRUCT ps;
1305  hdc = BeginPaint(hWnd, &ps);
1306  OnPaint(indexWnd, hdc);
1307  EndPaint(hWnd, &ps);
1308 
1309  // WM_PAINT 消息中需要调用系统绘制方法
1310  DefWindowProc(hWnd, WM_PAINT, 0, 0);
1311  break;
1312  }
1313 
1314  case WM_MOVE:
1315  OnMove(hWnd);
1316  break;
1317 
1318  // 关闭窗口，释放内存
1319  case WM_DESTROY:
1320  OnDestroy(indexWnd, wParam);
1321  break;
1322  }
1323 
1324  // 返回值
1325  LRESULT lResult = 0;
1326 
1327  // 此处统一在函数末尾返回
1328 
1329  // 用户未处理此消息
1330  if (!g_vecWindows[indexWnd].funcWndProc || resultUserProc == HIWINDOW_DEFAULT_PROC)
1331  {
1332  switch (msg)
1333  {
1334  case WM_CLOSE:
1335  DestroyWindow(g_vecWindows[indexWnd].hWnd);
1336  break;
1337 
1338  case WM_DESTROY:
1339  PostQuitMessage(0);
1340  break;
1341 
1342  // WM_PAINT 消息无需重复调用默认方法
1343  case WM_PAINT:
1344  break;
1345 
1346  default:
1347  lResult = DefWindowProc(hWnd, msg, wParam, lParam);
1348  break;
1349  }
1350  }
1351 
1352  // 用户已处理此消息
1353  else
1354  {
1355  switch (msg)
1356  {
1357  case WM_CLOSE:
1358  break;
1359 
1360  case WM_DESTROY:
1361  break;
1362  }
1363 
1364  lResult = resultUserProc;
1365  }
1366 
1367  return lResult;
1368  }

◆ ZoomImage_Alpha()

IMAGE HiEasyX::ZoomImage_Alpha ( IMAGE *  srcimg,
int  width,
int  height = 0 
)

缩放图像（双线性插值，保留透明度信息）

参数
[in]srcimg原图像
[in]width目标宽度
[in]height目标高度（为 0 则根据宽度按比例缩放）
返回
缩放后的图像

在文件 HiCanvas.cpp 第 166 行定义.

167  {
168  int old_w, old_h;
169  GetImageSize(srcimg, &old_w, &old_h);
170 
171  // 自动缩放
172  if (height == 0)
173  {
174  height = width * old_h / old_w;
175  }
176 
177  IMAGE output(width, height);
178  DWORD* src = GetImageBuffer(srcimg);
179  DWORD* dst = GetImageBuffer(&output);
180 
181  // 双线性插值（因为向下取样，所以 w, h 都要减一避免越界）
182  for (int i = 0; i < height - 1; i++)
183  {
184  for (int j = 0; j < width - 1; j++)
185  {
186  int xt = j * old_w / width; // 新图坐标映射到原图上的位置
187  int yt = i * old_h / height;
188 
189  // 实现逐行加载图片
190  byte r = (
191  GetRValue(src[xt + yt * old_w]) +
192  GetRValue(src[xt + yt * old_w + 1]) +
193  GetRValue(src[xt + (yt + 1) * old_w]) +
194  GetRValue(src[xt + (yt + 1) * old_w + 1])) / 4;
195  byte g = (
196  GetGValue(src[xt + yt * old_w]) +
197  GetGValue(src[xt + yt * old_w] + 1) +
198  GetGValue(src[xt + (yt + 1) * old_w]) +
199  GetGValue(src[xt + (yt + 1) * old_w]) + 1) / 4;
200  byte b = (
201  GetBValue(src[xt + yt * old_w]) +
202  GetBValue(src[xt + yt * old_w] + 1) +
203  GetBValue(src[xt + (yt + 1) * old_w]) +
204  GetBValue(src[xt + (yt + 1) * old_w + 1])) / 4;
205 
206  // 赋值，保留 alpha
207  dst[i * width + j] = RGBA(r, g, b, GetAValue(src[xt + yt * old_w]));
208  }
209  }
210 
211  return output;
212  }

◆ ZoomImage_Rough_Alpha()

IMAGE HiEasyX::ZoomImage_Rough_Alpha ( IMAGE *  srcimg,
int  width,
int  height = 0 
)

缩放图像（粗糙的、即不插值的缩放，保留透明度信息）

参数
[in]srcimg原图像
[in]width目标宽度
[in]height目标高度（为 0 则根据宽度按比例缩放）
返回
缩放后的图像

在文件 HiCanvas.cpp 第 132 行定义.

133  {
134  int src_width, src_height;
135  GetImageSize(srcimg, &src_width, &src_height);
136 
137  // 自动缩放
138  if (height == 0)
139  {
140  height = width * src_height / src_width;
141  }
142 
143  IMAGE dstImage(width, height);
144  IMAGE* dstimg = &dstImage;
145 
146  DWORD* dst = GetImageBuffer(dstimg);
147  DWORD* src = GetImageBuffer(srcimg);
148 
149  float w_scale_rate = (float)src_width / width;
150  float h_scale_rate = (float)src_height / height;
151 
152  for (int iy = 0; iy < height; iy++)
153  {
154  for (int ix = 0; ix < width; ix++)
155  {
156  // 计算原图相应坐标
157  int x_scale = (int)(w_scale_rate * ix);
158  int y_scale = (int)(h_scale_rate * iy);
159  dst[ix + iy * width] = src[(int)(x_scale + y_scale * src_width)];
160  }
161  }
162 
163  return dstImage;
164  }

◆ ZoomImage_Win32_Alpha()

IMAGE HiEasyX::ZoomImage_Win32_Alpha ( IMAGE *  srcimg,
int  width,
int  height = 0 
)

图像缩放（基于 Win32 API，比较快，保留透明度信息）

参数
[in]srcimg原图像
[in]width目标宽度
[in]height目标高度（为 0 则根据宽度按比例缩放）
返回
缩放后的图像

在文件 HiCanvas.cpp 第 214 行定义.

215  {
216  int w, h;
217  GetImageSize(srcimg, &w, &h);
218 
219  // 自动缩放
220  if (height == 0)
221  {
222  height = width * h / w;
223  }
224 
225  IMAGE img(width, height);
226  StretchBlt(
227  GetImageHDC(&img), 0, 0, width, height,
228  GetImageHDC(srcimg), 0, 0,
229  w, h, SRCCOPY
230  );
231  return img;
232  }

变量说明

◆ g_bAutoFlush

bool HiEasyX::g_bAutoFlush = true

是否自动刷新双缓冲

在文件 HiWindow.cpp 第 49 行定义.

◆ g_fDrawMode

DrawMode HiEasyX::g_fDrawMode = DM_Normal

全局绘制模式

在文件 HiWindow.cpp 第 48 行定义.

◆ g_hConsole

HWND HiEasyX::g_hConsole

控制台句柄

在文件 HiWindow.cpp 第 25 行定义.

◆ g_hCustomIcon

HICON HiEasyX::g_hCustomIcon

自定义程序图标

在文件 HiWindow.cpp 第 36 行定义.

◆ g_hCustomIconSm

HICON HiEasyX::g_hCustomIconSm

在文件 HiWindow.cpp 第 37 行定义.

◆ g_hIconDefault

HICON HiEasyX::g_hIconDefault

默认程序图标

在文件 HiWindow.cpp 第 33 行定义.

◆ g_hInstance

HINSTANCE HiEasyX::g_hInstance = GetModuleHandle(0)

程序实例

在文件 HiWindow.cpp 第 26 行定义.

◆ g_isInTask

bool HiEasyX::g_isInTask = false

标记处于任务中

在文件 HiWindow.cpp 第 31 行定义.

◆ g_isPrePos

bool HiEasyX::g_isPrePos = false

是否预设窗口位置

在文件 HiWindow.cpp 第 41 行定义.

◆ g_isPreShowState

bool HiEasyX::g_isPreShowState = false

是否预设窗口显示状态

在文件 HiWindow.cpp 第 42 行定义.

◆ g_isPreStyle

bool HiEasyX::g_isPreStyle = false

是否预设窗口样式

在文件 HiWindow.cpp 第 39 行定义.

◆ g_isPreStyleEx

bool HiEasyX::g_isPreStyleEx = false

是否预设窗口扩展样式

在文件 HiWindow.cpp 第 40 行定义.

◆ g_lPreStyle

long HiEasyX::g_lPreStyle

创建窗口前的预设样式

在文件 HiWindow.cpp 第 43 行定义.

◆ g_lPreStyleEx

long HiEasyX::g_lPreStyleEx

创建窗口前的预设扩展样式

在文件 HiWindow.cpp 第 44 行定义.

◆ g_lpszClassName

wchar_t HiEasyX::g_lpszClassName[] = L"HiEasyX"

窗口类名

在文件 HiWindow.cpp 第 23 行定义.

◆ g_lpszCustomIcon

LPCTSTR HiEasyX::g_lpszCustomIcon = nullptr

自定义程序图标资源，为空表示不使用

在文件 HiWindow.cpp 第 34 行定义.

◆ g_lpszCustomIconSm

LPCTSTR HiEasyX::g_lpszCustomIconSm = nullptr

在文件 HiWindow.cpp 第 35 行定义.

◆ g_nFocusWindowIndex

int HiEasyX::g_nFocusWindowIndex = NO_WINDOW_INDEX

当前操作焦点窗口索引

在文件 HiWindow.cpp 第 29 行定义.

◆ g_nPreCmdShow

int HiEasyX::g_nPreCmdShow

创建窗口前的预设显示状态

在文件 HiWindow.cpp 第 46 行定义.

◆ g_pPrePos

POINT HiEasyX::g_pPrePos

创建窗口前的预设窗口位置

在文件 HiWindow.cpp 第 45 行定义.

◆ g_screenSize

ScreenSize HiEasyX::g_screenSize

显示器信息

在文件 HiWindow.cpp 第 24 行定义.

◆ g_uWM_TASKBARCREATED

UINT HiEasyX::g_uWM_TASKBARCREATED

系统任务栏消息代码

在文件 HiWindow.cpp 第 51 行定义.

◆ g_vecWindows

std::vector<EasyWindow> HiEasyX::g_vecWindows

窗口表（管理多窗口）

在文件 HiWindow.cpp 第 28 行定义.

◆ g_WndClassEx

WNDCLASSEX HiEasyX::g_WndClassEx

窗口类

在文件 HiWindow.cpp 第 22 行定义.

◆ tRecord

clock_t HiEasyX::tRecord = 0

在文件 HiFPS.cpp 第 9 行定义.

HiEasyX::Gdiplus_Line
void Gdiplus_Line(HDC hdc, float x1, float y1, float x2, float y2, Gdiplus::Color linecolor, float linewidth, Gdiplus::SmoothingMode smoothing_mode)
画线
Definition: HiGdiplus.cpp:40
HiEasyX::To_MouseMsg
MOUSEMSG To_MouseMsg(ExMessage msgEx)
Definition: HiWindow.cpp:797
HIICON_WIDTH
#define HIICON_WIDTH
Definition: HiIcon.h:13
HiEasyX::SCT_RadioButton
Definition: SysControlBase.h:27
HiEasyX::SCT_Unknown
Definition: SysControlBase.h:21
BEGIN_TASK_WND
#define BEGIN_TASK_WND(hWnd)
Definition: HiWindow.h:784
HiEasyX::InitWindow
void InitWindow(int w, int h, int flag, LPCTSTR lpszWndTitle, WNDPROC WindowProcess, HWND hParent, int *nDoneFlag, HWND *hWnd)
Definition: HiWindow.cpp:1426
HiEasyX::ConvertToGdiplusColor
Gdiplus::Color ConvertToGdiplusColor(COLORREF color, bool reserve_alpha)
转换 COLORREF 到 Gdiplus::Color
Definition: HiGdiplus.cpp:30
HiEasyX::IsInTask
bool IsInTask(HWND hWnd)
Definition: HiWindow.cpp:555
HiEasyX::g_nFocusWindowIndex
int g_nFocusWindowIndex
当前操作焦点窗口索引
Definition: HiWindow.cpp:29
HiEasyX::SCT_Static
Definition: SysControlBase.h:24
HIWINDOW_DEFAULT_PROC
#define HIWINDOW_DEFAULT_PROC
Definition: HiWindow.h:27
HiEasyX::SCT_Edit
Definition: SysControlBase.h:28
HiEasyX::g_isInTask
bool g_isInTask
标记处于任务中
Definition: HiWindow.cpp:31
HIICON_HEIGHT
#define HIICON_HEIGHT
Definition: HiIcon.h:14
HiEasyX::SCT_CheckBox
Definition: SysControlBase.h:26
HiEasyX::g_bAutoFlush
bool g_bAutoFlush
是否自动刷新双缓冲
Definition: HiWindow.cpp:49
HiEasyX::WaitForProcessing
void WaitForProcessing(int index)
Definition: HiWindow.cpp:137
SET_ALPHA
#define SET_ALPHA(rgb, a)
Definition: HiMacro.h:25
HiEasyX::CM_HOVER_OVER
悬停结束
Definition: ControlBase.h:24
Image2Bitmap
HBITMAP Image2Bitmap(IMAGE *img, bool enable_alpha)
得到 IMAGE 对象的 HBITMAP
Definition: HiFunc.cpp:47
pBuf
DWORD pBuf[HIICON_WIDTH *HIICON_HEIGHT]
Definition: HiIcon.cpp:3
WM_USER_REDRAW
#define WM_USER_REDRAW
Definition: HiWindow.h:43
HiEasyX::LAYERORDER_BOTTOM_MOST
Definition: HiCanvas.h:861
HiEasyX::IsFocusWindowExisted
bool IsFocusWindowExisted()
Definition: HiWindow.cpp:62
HiEasyX::EasyX_Gdiplus_SolidRectangle
void EasyX_Gdiplus_SolidRectangle(float x, float y, float w, float h, COLORREF fillcolor, bool enable_alpha, bool enable_aa, IMAGE *pImg)
画无边框填充矩形
Definition: HiGdiplus.cpp:353
HiEasyX::g_nPreCmdShow
int g_nPreCmdShow
创建窗口前的预设显示状态
Definition: HiWindow.cpp:46
HiEasyX::EndTask
void EndTask(bool flush)
终止当前窗口任务
Definition: HiWindow.cpp:541
HiEasyX::RedrawWindow
void RedrawWindow(HWND hWnd)
通知重绘绘图窗口（在 WM_PAINT 消息内绘图不需要使用此函数）
Definition: HiWindow.cpp:392
HiEasyX::g_pPrePos
POINT g_pPrePos
创建窗口前的预设窗口位置
Definition: HiWindow.cpp:45
HiEasyX::OnCreate
void OnCreate(int indexWnd, HWND hWnd, LPARAM lParam)
Definition: HiWindow.cpp:1213
HiEasyX::IsValidWindowIndex
bool IsValidWindowIndex(int index)
Definition: HiWindow.cpp:56
HiEasyX::CM_DOUBLE_CLICK
双击
Definition: ControlBase.h:28
HiEasyX::Gdiplus_Ellipse
void Gdiplus_Ellipse(HDC hdc, float x, float y, float w, float h, Gdiplus::Color linecolor, float linewidth, Gdiplus::SmoothingMode smoothing_mode)
画椭圆
Definition: HiGdiplus.cpp:134
HiEasyX::SysCtrlProc
LRESULT SysCtrlProc(int indexWnd, UINT msg, WPARAM wParam, LPARAM lParam, bool &bRet)
Definition: HiWindow.cpp:1158
HiEasyX::g_hCustomIconSm
HICON g_hCustomIconSm
Definition: HiWindow.cpp:37
HiEasyX::LAYERORDER_BOTTOM
Definition: HiCanvas.h:862
HiEasyX::g_isPreStyleEx
bool g_isPreStyleEx
是否预设窗口扩展样式
Definition: HiWindow.cpp:40
HiEasyX::g_hIconDefault
HICON g_hIconDefault
默认程序图标
Definition: HiWindow.cpp:33
HiEasyX::g_isPrePos
bool g_isPrePos
是否预设窗口位置
Definition: HiWindow.cpp:41
HiEasyX::MixAlphaColor
COLORREF MixAlphaColor(COLORREF cDst, COLORREF cSrc, bool isCalculated, BYTE alpha)
根据透明度混合颜色
Definition: HiCanvas.cpp:9
HiEasyX::Gdiplus_SolidRectangle
void Gdiplus_SolidRectangle(HDC hdc, float x, float y, float w, float h, Gdiplus::Color fillcolor, Gdiplus::SmoothingMode smoothing_mode)
画无边框填充矩形
Definition: HiGdiplus.cpp:115
HiEasyX::FreeWindow
void FreeWindow(int index)
Definition: HiWindow.cpp:174
HiEasyX::SCT_Group
Definition: SysControlBase.h:22
END_TASK
#define END_TASK(...)
Definition: HiWindow.h:792
HiEasyX::g_fDrawMode
DrawMode g_fDrawMode
全局绘制模式
Definition: HiWindow.cpp:48
HiEasyX::EasyX_Gdiplus_Rectangle
void EasyX_Gdiplus_Rectangle(float x, float y, float w, float h, COLORREF linecolor, float linewidth, bool enable_alpha, bool enable_aa, IMAGE *pImg)
画矩形
Definition: HiGdiplus.cpp:332
HiEasyX::OnDestroy
void OnDestroy(int indexWnd, WPARAM wParam)
Definition: HiWindow.cpp:1124
HiEasyX::g_hConsole
HWND g_hConsole
控制台句柄
Definition: HiWindow.cpp:25
HiEasyX::WndProc
LRESULT CALLBACK WndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
Definition: HiWindow.cpp:1218
WM_SYSCTRL_DELETE
#define WM_SYSCTRL_DELETE
Definition: HiWindow.h:39
HiEasyX::g_lpszCustomIconSm
LPCTSTR g_lpszCustomIconSm
Definition: HiWindow.cpp:35
HiEasyX::g_lPreStyleEx
long g_lPreStyleEx
创建窗口前的预设扩展样式
Definition: HiWindow.cpp:44
HiEasyX::SCT_GroupBox
Definition: SysControlBase.h:23
HiEasyX::IsNewMessage
bool IsNewMessage(BYTE filter, HWND hWnd)
Definition: HiWindow.cpp:699
HiEasyX::SCT_ComboBox
Definition: SysControlBase.h:29
HiEasyX::tRecord
clock_t tRecord
Definition: HiFPS.cpp:9
HiEasyX::CM_PRESS
按下
Definition: ControlBase.h:25
HiEasyX::g_lpszClassName
wchar_t g_lpszClassName[]
窗口类名
Definition: HiWindow.cpp:23
HiEasyX::DM_Normal
正常绘制（现在和 DM_Real 是等价了）
Definition: HiWindow.h:109
HiEasyX::FlushDrawing
void FlushDrawing(int index, RECT rct={ 0 })
Definition: HiWindow.cpp:429
HiEasyX::OnSize
void OnSize(int indexWnd)
Definition: HiWindow.cpp:906
HiEasyX::OnPaint
void OnPaint(int indexWnd, HDC hdc)
Definition: HiWindow.cpp:1087
HiEasyX::Gdiplus_Shutdown
void Gdiplus_Shutdown()
关闭 GDI+
Definition: HiGdiplus.cpp:21
BEGIN_TASK
#define BEGIN_TASK()
Definition: HiWindow.h:777
HiEasyX::g_hCustomIcon
HICON g_hCustomIcon
自定义程序图标
Definition: HiWindow.cpp:36
REDRAW_WINDOW
#define REDRAW_WINDOW(...)
Definition: HiWindow.h:798
RGBA
#define RGBA(r, g, b, a)
Definition: HiMacro.h:16
HiEasyX::IsAliveWindow
bool IsAliveWindow(int index)
Definition: HiWindow.cpp:131
HiEasyX::EasyX_Gdiplus_SolidEllipse
void EasyX_Gdiplus_SolidEllipse(float x, float y, float w, float h, COLORREF fillcolor, bool enable_alpha, bool enable_aa, IMAGE *pImg)
画无边框填充椭圆
Definition: HiGdiplus.cpp:410
HiEasyX::g_uWM_TASKBARCREATED
UINT g_uWM_TASKBARCREATED
系统任务栏消息代码
Definition: HiWindow.cpp:51
_HIEASYX_VER_STR_
#define _HIEASYX_VER_STR_
Definition: HiDef.h:8
HiEasyX::GetWindowPos
POINT GetWindowPos(HWND hWnd)
获取窗口位置
Definition: HiWindow.cpp:851
HiEasyX::CM_FOCUS
获取焦点
Definition: ControlBase.h:29
HiEasyX::g_lPreStyle
long g_lPreStyle
创建窗口前的预设样式
Definition: HiWindow.cpp:43
GetAValue
#define GetAValue(rgba)
Definition: HiMacro.h:19
GetExMessageType
UINT GetExMessageType(ExMessage msg)
获取 ExMessage 的消息类型
Definition: HiFunc.cpp:100
HiEasyX::LAYERORDER_TOP_MOST
Definition: HiCanvas.h:865
HiEasyX::CopyImageToHDC
void CopyImageToHDC(IMAGE *pImg, HDC hdc, RECT rct)
Definition: HiWindow.cpp:153
HiEasyX::GetFocusWindow
EasyWindow & GetFocusWindow()
Definition: HiWindow.cpp:68
HiEasyX::Gdiplus_Pie
void Gdiplus_Pie(HDC hdc, float x, float y, float w, float h, float stangle, float endangle, Gdiplus::Color linecolor, float linewidth, Gdiplus::SmoothingMode smoothing_mode)
画饼状图（传入顺时针角度）
Definition: HiGdiplus.cpp:173
HiEasyX::OnTaskBarCreated
void OnTaskBarCreated(int indexWnd)
Definition: HiWindow.cpp:962
HiEasyX::WaitForTask
void WaitForTask(HWND hWnd)
阻塞等待某窗口任务完成
Definition: HiWindow.cpp:161
HiEasyX::EasyX_Gdiplus_Ellipse
void EasyX_Gdiplus_Ellipse(float x, float y, float w, float h, COLORREF linecolor, float linewidth, bool enable_alpha, bool enable_aa, IMAGE *pImg)
画椭圆
Definition: HiGdiplus.cpp:389
GetDstPoints
void GetDstPoints()
Definition: HiStart.cpp:36
g_Input
Gdiplus::GdiplusStartupInput g_Input
Definition: HiGdiplus.cpp:7
CLASSICGRAY
Windows 经典灰
Definition: HiMacro.h:103
HiEasyX::ShowTray
void ShowTray(NOTIFYICONDATA *nid)
Definition: HiWindow.cpp:571
HiEasyX::CM_HOVER
悬停
Definition: ControlBase.h:23
HiEasyX::g_screenSize
ScreenSize g_screenSize
显示器信息
Definition: HiWindow.cpp:24
HiEasyX::OnMove
void OnMove(HWND hWnd)
Definition: HiWindow.cpp:1109
HiEasyX::Gdiplus_Polygon
void Gdiplus_Polygon(HDC hdc, int points_num, Gdiplus::PointF *points, Gdiplus::Color linecolor, float linewidth, Gdiplus::SmoothingMode smoothing_mode)
画多边形
Definition: HiGdiplus.cpp:60
HiEasyX::DM_VeryFast
极速绘制（发送 WM_USER_REDRAW 消息，可能跳过很多绘制）
Definition: HiWindow.h:111
HiEasyX::RenderStartScene
void RenderStartScene()
渲染开场动画
Definition: HiStart.cpp:106
HiEasyX::LAYERORDER_NORMAL
Definition: HiCanvas.h:863
HiEasyX::EasyWindow::hWnd
HWND hWnd
窗口句柄
Definition: HiWindow.h:61
HiEasyX::BeginTask
bool BeginTask()
Definition: HiWindow.cpp:530
HiEasyX::closegraph_win32
void closegraph_win32(HWND hWnd)
关闭某一绘图窗口
Definition: HiWindow.cpp:245
GetHWnd
#define GetHWnd
Definition: HiWindow.h:867
HiEasyX::GetWindowIndex
int GetWindowIndex(HWND hWnd)
Definition: HiWindow.cpp:85
HiEasyX::Gdiplus_SolidPie
void Gdiplus_SolidPie(HDC hdc, float x, float y, float w, float h, float stangle, float endangle, Gdiplus::Color fillcolor, Gdiplus::SmoothingMode smoothing_mode)
画无边框填充饼状图（传入顺时针角度）
Definition: HiGdiplus.cpp:195
HiEasyX::GetNextMessage
ExMessage GetNextMessage(BYTE filter, HWND hWnd)
Definition: HiWindow.cpp:709
HiEasyX::Gdiplus_Try_Starup
void Gdiplus_Try_Starup()
注意，必须先启动 GDI+，才能使用下面的绘图函数
Definition: HiGdiplus.cpp:12
HiEasyX::init_end
void init_end(HWND hWnd)
初始化窗口结束后，可以用此函数阻塞等待目标窗口被关闭，然后函数返回
Definition: HiWindow.cpp:311
GetImageSize
void GetImageSize(IMAGE *pImg, int *width, int *height)
Definition: HiFunc.cpp:17
HiEasyX::g_hInstance
HINSTANCE g_hInstance
程序实例
Definition: HiWindow.cpp:26
HiEasyX::IsAnyWindow
bool IsAnyWindow()
是否还存在未销毁的绘图窗口
Definition: HiWindow.cpp:103
HiEasyX::g_WndClassEx
WNDCLASSEX g_WndClassEx
窗口类
Definition: HiWindow.cpp:22
HiEasyX::SetWorkingWindow
bool SetWorkingWindow(HWND hWnd)
等待当前任务完成并设置活动窗口
Definition: HiWindow.cpp:342
HiEasyX::OnTray
void OnTray(int indexWnd, LPARAM lParam)
Definition: HiWindow.cpp:924
HiEasyX::g_isPreStyle
bool g_isPreStyle
是否预设窗口样式
Definition: HiWindow.cpp:39
HiEasyX::LAYERORDER_TOP
Definition: HiCanvas.h:864
HiEasyX::DM_Fastest
最快的绘制方式（发送 WM_USER_REDRAW 消息，可能跳过大部分绘制）
Definition: HiWindow.h:112
HiEasyX::EasyX_Gdiplus_SolidPie
void EasyX_Gdiplus_SolidPie(float x, float y, float w, float h, float stangle, float endangle, COLORREF fillcolor, bool enable_alpha, bool enable_aa, IMAGE *pImg)
画无边框填充饼状图（传入逆时针角度）
Definition: HiGdiplus.cpp:469
HiEasyX::EasyX_Gdiplus_Polygon
void EasyX_Gdiplus_Polygon(int points_num, POINT *points, COLORREF linecolor, float linewidth, bool enable_alpha, bool enable_aa, IMAGE *pImg)
画多边形
Definition: HiGdiplus.cpp:259
HiEasyX::Gdiplus_SolidPolygon
void Gdiplus_SolidPolygon(HDC hdc, int points_num, Gdiplus::PointF *points, Gdiplus::Color fillcolor, Gdiplus::SmoothingMode smoothing_mode)
画无边框填充多边形
Definition: HiGdiplus.cpp:78
HiEasyX::CM_CLICK
单击
Definition: ControlBase.h:27
HiEasyX::SendUserRedrawMsg
void SendUserRedrawMsg(HWND hWnd)
Definition: HiWindow.cpp:387
HiEasyX::EasyX_Gdiplus_Pie
void EasyX_Gdiplus_Pie(float x, float y, float w, float h, float stangle, float endangle, COLORREF linecolor, float linewidth, bool enable_alpha, bool enable_aa, IMAGE *pImg)
画饼状图（传入逆时针角度）
Definition: HiGdiplus.cpp:446
HpSleep
void HpSleep(int ms)
精确延时函数（可以精确到 1ms，精度 ±1ms）
Definition: HiFunc.cpp:78
initgraph
#define initgraph(...)
Definition: HiWindow.h:857
NO_WINDOW_INDEX
#define NO_WINDOW_INDEX
Definition: HiWindow.h:24
Bitmap2Icon
HICON Bitmap2Icon(HBITMAP hBmp)
HBITMAP 转 HICON
Definition: HiFunc.cpp:60
HiEasyX::g_lpszCustomIcon
LPCTSTR g_lpszCustomIcon
自定义程序图标资源，为空表示不使用
Definition: HiWindow.cpp:34
HiEasyX::RegisterWndClass
void RegisterWndClass()
Definition: HiWindow.cpp:1370
g_Token
ULONG_PTR g_Token
Definition: HiGdiplus.cpp:8
HiEasyX::GetDefaultAppIcon
HICON GetDefaultAppIcon()
Definition: HiWindow.cpp:893
HiEasyX::peekmessage_win32
bool peekmessage_win32(ExMessage *msg, BYTE filter, bool removemsg, HWND hWnd)
获取一个消息，立即返回是否获取成功
Definition: HiWindow.cpp:742
HiEasyX::CM_FOCUS_OVER
丢失焦点
Definition: ControlBase.h:30
HiEasyX::Gdiplus_SolidEllipse
void Gdiplus_SolidEllipse(HDC hdc, float x, float y, float w, float h, Gdiplus::Color fillcolor, Gdiplus::SmoothingMode smoothing_mode)
画无边框填充椭圆
Definition: HiGdiplus.cpp:154
MSG_RESERVE_SIZE
#define MSG_RESERVE_SIZE
Definition: HiWindow.cpp:12
HiEasyX::g_isPreShowState
bool g_isPreShowState
是否预设窗口显示状态
Definition: HiWindow.cpp:42
HiEasyX::ClearMessage
void ClearMessage(BYTE filter, HWND hWnd)
Definition: HiWindow.cpp:690
GetScreenSize
ScreenSize GetScreenSize()
获取多显示器大小信息
Definition: HiFunc.cpp:6
HiEasyX::DeleteTray
void DeleteTray(HWND hWnd)
删除某窗口的托盘
Definition: HiWindow.cpp:601
SYSCTRL_RESERVE_SIZE
#define SYSCTRL_RESERVE_SIZE
Definition: HiWindow.cpp:15
HiEasyX::DM_Real
完全按实际绘制（每次要求重绘都立即执行，可能导致程序卡顿）
Definition: HiWindow.h:108
HiEasyX::Gdiplus_Arc
void Gdiplus_Arc(HDC hdc, float x, float y, float w, float h, float stangle, float endangle, Gdiplus::Color linecolor, float linewidth, Gdiplus::SmoothingMode smoothing_mode)
画圆弧（传入顺时针角度）
Definition: HiGdiplus.cpp:216
HiEasyX::CM_PRESS_OVER
按下结束
Definition: ControlBase.h:26
g_pSrc
POINT * g_pSrc
Definition: HiStart.cpp:8
HiEasyX::CM_OTHER
未特殊标识的其它消息
Definition: ControlBase.h:22
HiEasyX::EasyWindow::isNeedFlush
bool isNeedFlush
是否需要输出绘图缓冲
Definition: HiWindow.h:67
HiEasyX::RegisterExMessage
void RegisterExMessage(int indexWnd, UINT msg, WPARAM wParam, LPARAM lParam)
Definition: HiWindow.cpp:971
HiEasyX::SCT_Button
Definition: SysControlBase.h:25
WM_TRAY
#define WM_TRAY
Definition: HiWindow.h:30
HiEasyX::ResizeWindowImage
void ResizeWindowImage(int index, RECT rct)
Definition: HiWindow.cpp:561
WM_SYSCTRL_CREATE
#define WM_SYSCTRL_CREATE
Definition: HiWindow.h:35
HiEasyX::getmessage_win32
void getmessage_win32(ExMessage *msg, BYTE filter, HWND hWnd)
阻塞等待，直到获取到一个新消息
Definition: HiWindow.cpp:736
HiEasyX::RemoveMessage
void RemoveMessage(HWND hWnd)
Definition: HiWindow.cpp:680
HiEasyX::OnSysCtrlCreate
HWND OnSysCtrlCreate(int indexWnd, WPARAM wParam, LPARAM lParam)
Definition: HiWindow.cpp:1136
HiEasyX::FlushDrawing
void FlushDrawing(RECT rct)
Definition: HiWindow.cpp:516
HiEasyX::Gdiplus_Rectangle
void Gdiplus_Rectangle(HDC hdc, float x, float y, float w, float h, Gdiplus::Color linecolor, float linewidth, Gdiplus::SmoothingMode smoothing_mode)
画矩形
Definition: HiGdiplus.cpp:95
GetSrcPoints
void GetSrcPoints()
Definition: HiStart.cpp:80
HiEasyX::EasyX_Gdiplus_SolidPolygon
void EasyX_Gdiplus_SolidPolygon(int points_num, POINT *points, COLORREF fillcolor, bool enable_alpha, bool enable_aa, IMAGE *pImg)
画无边框填充多边形
Definition: HiGdiplus.cpp:289
HiEasyX::GetIconImage
IMAGE * GetIconImage()
获取图标对象（显存的拷贝）
Definition: HiIcon.cpp:75
Blur
void Blur(DWORD *pMem)
Definition: HiStart.cpp:95
HiEasyX::InitWindowStruct
EasyWindow & InitWindowStruct(EasyWindow &wnd, HWND hParent, int w, int h, WNDPROC WindowProcess)
Definition: HiWindow.cpp:1402
g_nCount
int g_nCount
Definition: HiStart.cpp:11
g_pDst
POINT * g_pDst
Definition: HiStart.cpp:7
HiEasyX::GetMsgVector
std::vector< ExMessage > & GetMsgVector(HWND hWnd)
Definition: HiWindow.cpp:664
HiEasyX::g_vecWindows
std::vector< EasyWindow > g_vecWindows
窗口表（管理多窗口）
Definition: HiWindow.cpp:28
HiEasyX::DM_Fast
快速绘制（发送 WM_USER_REDRAW 消息，可能跳过部分绘制）
Definition: HiWindow.h:110
g_bStarup
bool g_bStarup
Definition: HiGdiplus.cpp:6