文章目录
  1. 1. 需求
  2. 2. 问题
  3. 3. 解决方案
  4. 4. 限制条件
  5. 5. 接口
  6. 6. 实现
    1. 6.1. 数据结构
    2. 6.2. 创建透明主窗体
    3. 6.3. 销毁透明主窗体
    4. 6.4. 透明窗体更新
    5. 6.5. 非透明窗体更新
  7. 7. 使用范例
  8. 8. 2011.2.16:改动1——支持逐点 alpha(包括在缓冲dc中)
    1. 8.1. 问题
    2. 8.2. 解决办法
    3. 8.3. 本质问题分析
  9. 9. 2011.3.24:改动2——一些小修正
    1. 9.1. 问题
    2. 9.2. 解决办法
    3. 9.3. 代码路径
  10. 10. 2011.4.19:改动3——支持动态设置/去除窗口透明属性
    1. 10.1. 问题
    2. 10.2. 解决办法

需求

  • 底下窗体内容会变化。
  • 接口简单,使用方便。
  • 内存占用少,效率高。
  • 透明窗体弹出时,屏幕上所包含的窗体及个数不限定。
  • 支持透明主窗体、透明非模态对话框、透明模态对话框。
  • 能移动透明窗体和非透明窗体。
  • 在创建了透明窗体后能继续创建非透明窗体。
  • 能动态设置与撤销双缓冲。

问题

这里先要说明下现有 MiniGUI 框架实现透明窗体的问题。如果光光是要窗体能透明还是比较好办的。在双缓冲回调函数中设置下 memdc 的层 alpha ,然后 BitBlt 到屏幕就可以了。但是这里主要存在的问题是透明的窗体的更新的问题。就是透明窗体下面的窗体更新、或是透明窗体本身更新时怎样才能得到正确的图像。这里分2点:

  • 透明自身窗体更新:由于是透明窗体的,所以透明窗体的图像需要与屏幕做 alpha 混合。非透明窗体直接将自己的图像更新到屏幕就行了。但是如果透明窗体直接这么做的话,会导致与上一次的图像重叠,结果是图像越来越不透明。因此就需要将背景刷新掉。这就需要处在透明窗体下的非透明窗体更新图像。但是现有 MiniGUI 的框架是不会更新下面的窗体的,因为下面的窗体处于透明窗体之下,被挡住了,是会被剪切掉的。

  • 非透明窗体更新:如果处于透明窗体下的非透明窗体更新的话,由于是透明窗体,所以应该能看得到底下的非透明窗体的更新。这就需要透明窗体更新。和上面一点一样, MiniGUI 的现有框架是不会更新透明窗体的。因为透明窗体位于非透明窗体的之上,MiniGUI 认为底下的窗体不会引起上面的窗体的更新。

解决方案

根据上面提到的问题,我们可以在应用层使用 MiniGUI 双缓冲机制来实现。双缓冲提供了一个更新回调函数,窗体有更新时就会调用这个函数。因此我们可以自己设置这个更新函数,然在里面手动更新透明窗体。总结起来分为下面几点:

  • 透明窗体和桌面上所有的非透明窗体必须使用双缓冲,透明窗体设置 WS_EX_TRANSPARENT 风格标志。
  • 收集桌面中所有的非透明窗体,按照 zorder 保存在链表中,存放在透明窗体的 adddata2 中。
  • 在透明窗体的更新函数中,遍历该链表,看其中的非透明窗体是否与透明窗体相交,是则将该非透明窗体的相应区域的图像更新到透明区域(更新透明区域的背景)。
  • 在非透明窗体的更新函数,遍历桌面所有其他主窗体,找出具有 WS_EX_TRANSPARENT 风格的透明窗体。判断其更新区域是否与透明窗体相交,如果相交则要强制透明窗体更新。

限制条件

根据如上解决方案,本透明窗体的实现,具有一定的限制性,超出限制可能出现不可预料的问题。

  • 屏幕上同时只能创建1个透明主窗体。
  • 不要让透明窗体透出桌面(保证其在一个窗体内)。
  • 暂时不支持窗口滚动。

接口

提供如下接口:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/* 设置透明窗体附件数据2 */
DWORD SetTransparentWindowAddData2 (HWND hWnd, DWORD newData);
/* 设置透明窗体 alpha 值 */
void SetTransparentWindowAlpha (HWND hWnd, Uint8 alpha);
/* 获取透明窗体附件数据2 */
DWORD GetTransparentWindowAddData2 (HWND hWnd);
/* 获取透明窗体 alpha 值 */
Uint8 GetTransparentWindowAlpha (HWND hWnd);
/* 创建透明主窗体 */
HWND CreateTransparentMainWindow (PMAINWINCREATE pCreateInfo);
/* 创建透明非模态对话框 */
HWND CreateTransparentMainWindowIndirectParam (
PDLGTEMPLATE pDlgTemplate, HWND hOwner,
WNDPROC WndProc, LPARAM lParam);
/* 创建透明模态对话框 */
int TransparentDialogBoxIndirectParam (PDLGTEMPLATE pDlgTemplate,
HWND hOwner, WNDPROC DlgProc, LPARAM lParam, Uint8 alpha);
/* 销毁透明主窗体 */
BOOL DestroyTransparentMainWindow (HWND hWnd);
/* 销毁透明非模态对话框 */
BOOL DestroyTransparentMainWindowIndirect (HWND hWnd);
/* 销毁透明模态对话框 */
BOOL EndTransparentDialog (HWND hDlg, int endCode);

实现

数据结构

这里链表使用的是 linux 内核的链表实现。保存主窗体的链表数据结构:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/* dc flags */
#define TRANS_NORMAL 0
#define TRANS_HAVE_SECONDARYDC 1
/* main window list */
typedef struct _hwnd_list {
struct list_head list;
/* 主窗口句柄 */
HWND hwnd;
/* 主窗体 dc flags
* 如果原来主窗体有双缓冲风格则不需要手动设置,也不需要手动销毁 */
int dc_flags;
} hwnd_list_t;
/* transparent window private data */
typedef struct _trans_wnd_data {
struct list_head hwnd_head;
/* 透明窗体 alpha 值 */
Uint8 alpha;
/* 透明窗体附加数据2
* 原来的被用保存链表信息了,额外提供一个给应用程序使用 */
DWORD addData;
} trans_wnd_data_t;

创建透明主窗体

CreateTansparentMainWindow、CreateTransparentMainWindowIndirectParam 和 TransparentDialogBoxIndirectParam 其实流程都是差不多。都是先调用对应的 MiniGUI 原有的 API,然后初始化私有数据(就是保存桌面主窗体的链表)。这里主要是就是要实现初始化私有数据,主要流程是:

  • 初始化链表(申请内存)。
  • 使用 GetNextMainWindow 取得当前桌面的所有主窗体(注意要区分透明窗体自己)。使用 GetNextMainWindow(HWND_NULL) 做为遍历的开始就能保证 zorder。遍历结束的条件是 GetNextMainWindow 得到的句柄是 HWND_NULL
  • 将遍历得到的主窗体句柄保存到链表中。
  • 判断遍历到的主窗体是否有双缓冲风格,如果没有则手动帮其设置上。并设置链表中相应主窗体的 dc flags。
  • 遍历完成,将链表保存到透明窗体的 adddata2 中。

这里要注意一点:应该是由于是联芯修改 MiniGUI 源代码的问题,刚开始没办法更新非客户区,所以要在后面手动发送 MSG_NCPAINT 强制更新非客户区。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
BOOL init_transparent_data (HWND hWnd)
{
HDC hdc_mainwnd;
HDC hdc_secondary;
HWND hwnd_main = 0;
trans_wnd_data_t* data = NULL;
hwnd_list_t* wnd_list = NULL;
/* init transparent data */
data = (trans_wnd_data_t*)calloc(1, sizeof(trans_wnd_data_t));
if ( NULL == data )
return FALSE;
INIT_LIST_HEAD(&data->hwnd_head);
data->alpha = 255;
/* find all other visable main windows */
hwnd_main = GetNextMainWindow(HWND_NULL);
while ( hwnd_main ) {
if ( hwnd_main == hWnd ) {
hwnd_main = GetNextMainWindow(hwnd_main);
continue;
}
wnd_list = (hwnd_list_t*)calloc(1, sizeof(hwnd_list_t));
wnd_list->hwnd = hwnd_main;
list_add(&wnd_list->list, &data->hwnd_head);
/* check if the main window whether has WS_EX_AUTOSECONDARYDC */
if ( !(GetWindowExStyle(hwnd_main) & WS_EX_AUTOSECONDARYDC) ) {
hdc_mainwnd = GetDC(hwnd_main);
hdc_secondary = CreateCompatibleDC(hdc_mainwnd);
SetSecondaryDC(hwnd_main, hdc_secondary, on_update_normal);
ReleaseDC(hdc_mainwnd);
wnd_list->dc_flags = TRANS_NORMAL;
IncludeWindowExStyle(hwnd_main, WS_EX_AUTOSECONDARYDC);
/* make main window draw on the secondary dc */
UpdateWindow(hwnd_main, TRUE);
}
else {
wnd_list->dc_flags = TRANS_HAVE_SECONDARYDC;
hdc_secondary = GetSecondaryDC(hwnd_main);
SetSecondaryDC(hwnd_main, hdc_secondary, on_update_normal);
}
hwnd_main = GetNextMainWindow(hwnd_main);
}
/* make window to draw */
ShowWindow(hWnd, SW_SHOWNORMAL);
/* set secondary dc update callback function */
hdc_secondary = GetSecondaryDC(hWnd);
SetSecondaryDC(hWnd, hdc_secondary, on_update_transparent);
/* store the tranparent data */
SetWindowAdditionalData2(hWnd, (DWORD)data);
/* update the no-client */
SendMessage(hWnd, MSG_NCPAINT, 0, 0);
return TRUE;
}

销毁透明主窗体

DestroyTransparentMainWindow、DestroyTransparentMainWindowIndirect 和 EndTransparentDialog 的流程也差不多的。都是先销毁私有数据(就是保存桌面主窗体的链表),然后再调用 MiniGUI 对应的 API 销毁。这里主要销毁私有数据,主要流程是:

  • 遍历链表,查看主窗体的 dc flags 标志,看主窗体原来是否有双缓冲。如果没有则手动删除双缓冲数据,并还原主窗体设置。
  • 逐一删除链表的节点,释放链表节点内存。
  • 最后删除链表本身内存。

代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
BOOL deinit_transparent_data (HWND hWnd)
{
if (HWND_INVALID == hWnd)
return FALSE;
HDC hdc_secondary;
trans_wnd_data_t* data = (trans_wnd_data_t*)GetWindowAdditionalData2(hWnd);
hwnd_list_t* wnd_list = NULL;
if ( NULL == data )
return FALSE;
/* free transparent data */
while ( !list_empty(&data->hwnd_head) ) {
wnd_list = (hwnd_list_t*)data->hwnd_head.prev;
/* if it's manual set secondary dc, delete it */
if (HWND_INVALID != wnd_list->hwnd && TRANS_NORMAL == wnd_list->dc_flags) {
hdc_secondary = GetSecondaryDC(wnd_list->hwnd);
SetSecondaryDC(wnd_list->hwnd, HDC_SCREEN, ON_UPDSECDC_DONOTHING);
}
list_del(data->hwnd_head.prev);
free(wnd_list);
}
free(data);
return TRUE;
}

透明窗体更新

由于能够支持在创建透明窗体后继续创建非透明主窗体,以及先销毁非透明主窗体。所以需要时时检测是否有新非透明窗体创建,或是有存在的非透明窗体销毁,然后更新保存非透明主窗体的链表。然后更新方式就和前面解决方案里说的是一样的了。更新一次的流程是:

  • 使用 GetNextMainWindow 遍历现有的主窗体,和链表中保存的窗体比较,以检查是否有新窗体创建或是有原有的窗体销毁。
  • 如果检测出有新窗体创建或是有原有窗体销毁,则按照 zorder 重新构建链表。
  • 遍历链表中的主窗体,判断这些窗体的区域是否与透明窗体的更新区域相交。如果相交则将对应区域的非透明窗体的图像 BitBlt 到透明窗体的区域(这里就解释了为什么需要桌面上所有的非透明窗体都是双缓冲,以及保存必须按照 zorder)。
  • 最后根据透明窗体的 alpha 值,设置透明窗体 memdc 的 src alpha,然后 BitBlt 透明窗体的 memdc 。

代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
void rebuild_trans_wnd_data (HWND hWnd)
{
HWND hwnd_main;
struct list_head* i;
struct list_head new_head;
hwnd_list_t* wnd_list;
trans_wnd_data_t* data = (trans_wnd_data_t*)GetWindowAdditionalData2(hWnd);
if ( NULL == data )
return;
/* rebuild the main window list according to zorder */
INIT_LIST_HEAD(&new_head);
hwnd_main = GetNextMainWindow(HWND_NULL);
while ( hwnd_main ) {
if ( hwnd_main == hWnd ) {
hwnd_main = GetNextMainWindow(hwnd_main);
continue;
}
/* keep the main window property */
list_for_each(i, &data->hwnd_head) {
wnd_list = (hwnd_list_t *)i;
/* destroy the prev list and build tmp list */
if ( hwnd_main == wnd_list->hwnd ) {
list_del(i);
list_add(i, &new_head);
break;
}
}
hwnd_main = GetNextMainWindow(hwnd_main);
}
/* build the new main window list */
INIT_LIST_HEAD(&data->hwnd_head);
while ( !list_empty(&new_head) ) {
i = new_head.prev;
list_del(new_head.prev);
list_add(i, &data->hwnd_head);
}
}
BOOL check_normal_mainwnd (HWND hWnd)
{
BOOL is_exist = FALSE;
HDC hdc_mainwnd;
HDC hdc_secondary;
HWND hwnd_main;
struct list_head* i;
hwnd_list_t* wnd_list;
trans_wnd_data_t* data = (trans_wnd_data_t*)GetWindowAdditionalData2(hWnd);
if ( NULL == data )
return FALSE;
/* check whehter there is an new main window created */
hwnd_main = GetNextMainWindow(HWND_NULL);
while ( hwnd_main ) {
if ( hwnd_main == hWnd ) {
hwnd_main = GetNextMainWindow(hwnd_main);
continue;
}
is_exist = FALSE;
list_for_each(i, &data->hwnd_head) {
wnd_list = (hwnd_list_t *)i;
if ( wnd_list->hwnd == hwnd_main ) {
is_exist = TRUE;
break;
}
}
/* this main window is new created */
if ( FALSE == is_exist ) {
wnd_list = (hwnd_list_t*)calloc(1, sizeof(hwnd_list_t));
wnd_list->hwnd = hwnd_main;
list_add(&wnd_list->list, &data->hwnd_head);
/* check if the main window whether has WS_EX_AUTOSECONDARYDC */
if ( !(GetWindowExStyle(hwnd_main) & WS_EX_AUTOSECONDARYDC) ) {
hdc_mainwnd = GetDC(hwnd_main);
hdc_secondary = CreateCompatibleDC(hdc_mainwnd);
SetSecondaryDC(hwnd_main, hdc_secondary, on_update_normal);
ReleaseDC(hdc_mainwnd);
wnd_list->dc_flags = TRANS_NORMAL;
IncludeWindowExStyle(hwnd_main, WS_EX_AUTOSECONDARYDC);
}
else {
wnd_list->dc_flags = TRANS_HAVE_SECONDARYDC;
hdc_secondary = GetSecondaryDC(hwnd_main);
SetSecondaryDC(hwnd_main, hdc_secondary, on_update_normal);
}
/* must rebuild the main window list */
rebuild_trans_wnd_data(hWnd);
/* this is only can create one main window once */
return TRUE;
}
hwnd_main = GetNextMainWindow(hwnd_main);
}
/* check whether there is an exist main window destroyed */
list_for_each(i, &data->hwnd_head) {
wnd_list = (hwnd_list_t *)i;
is_exist = FALSE;
hwnd_main = GetNextMainWindow(HWND_NULL);
while ( hwnd_main ) {
if ( hwnd_main == hWnd ) {
hwnd_main = GetNextMainWindow(hwnd_main);
continue;
}
if ( wnd_list->hwnd == hwnd_main ) {
is_exist = TRUE;
break;
}
hwnd_main = GetNextMainWindow(hwnd_main);
}
/* this main window destroyed */
if ( FALSE == is_exist ) {
list_del(i);
free(wnd_list);
/* this is only can destroy one main window once */
return TRUE;
}
}
/* no new create main window, no main window destroyed */
return FALSE;
}
static int on_update_transparent (HWND hWnd, HDC secondary_dc,HDC real_dc,
const RECT* secondary_rc, const RECT* real_rc, const RECT* main_update_rc)
{
RECT update_rc;
RECT normal_rc;
HDC hdc_normal = 0;
HDC hdc_trans = 0;
PCLIPRGN pRgn = NULL;
HWND hwnd_normal;
/* the param hWnd can be an control handle, so get the main window handle */
HWND hwnd_trans = GetMainWindowHandle(hWnd);
trans_wnd_data_t* data = (trans_wnd_data_t*)GetWindowAdditionalData2(hwnd_trans);
struct list_head* i;
hwnd_list_t* wnd_list;
if ( NULL == data )
return -1;
/* check whether has an new main window */
if ( TRUE == check_normal_mainwnd(hwnd_trans) ) {
InvalidateRect(hwnd_trans, NULL, TRUE);
SendNotifyMessage(hwnd_trans, MSG_NCPAINT, 0, 0);
return 0;
}
/* get the screen dc(limit in window rect) */
hdc_trans = GetDC(hwnd_trans);
/* update desktop to the transparent */
update_rc = *main_update_rc;
WindowToScreen(hwnd_trans, &update_rc.left, &update_rc.top);
WindowToScreen(hwnd_trans, &update_rc.right, &update_rc.bottom);
SendMessage(HWND_DESKTOP, MSG_ERASEDESKTOP, 0, (LPARAM)&update_rc);
/* make the update background dc has the same clip region with the transparent window dc.
* note: it's only update no-client to set the clip region.
* real_rc equal to main_update_rc means there is no-client,
* except transparent window don't contain caption and border.
* but if the transparent window don't contain caption and border there is no worry to about it. */
if ( EqualRect((const RECT*)real_rc, (const RECT*)main_update_rc) ) {
pRgn = CreateClipRgn();
if ( NULL == pRgn ) {
fprintf(stderr, "on_update_transparent: CreateClipRgn failed\n");
return -1;
}
if ( -1 != GetClipRegion(real_dc, pRgn) ) {
SelectClipRegion(hdc_trans, (const CLIPRGN*)pRgn);
}
}
/* update all visable main window to the transparent*/
list_for_each(i, &data->hwnd_head) {
wnd_list = (hwnd_list_t *)i;
hwnd_normal = wnd_list->hwnd;
if ( hwnd_normal != HWND_INVALID ) {
/* this API return screen coordinates */
GetWindowRect(hwnd_normal, &normal_rc);
update_rc = *main_update_rc;
WindowToScreen(hwnd_trans, &update_rc.left, &update_rc.top);
WindowToScreen(hwnd_trans, &update_rc.right, &update_rc.bottom);
/* if update rect intersect normal window, then update it */
if ( TRUE == DoesIntersect(&update_rc, &normal_rc) ) {
ScreenToWindow(hwnd_normal, &update_rc.left, &update_rc.top);
ScreenToWindow(hwnd_normal, &update_rc.right, &update_rc.bottom);
hdc_normal = GetSecondaryDC(hwnd_normal);
BitBlt(hdc_normal, update_rc.left, update_rc.top, RECTW(update_rc), RECTH(update_rc),
hdc_trans, main_update_rc->left, main_update_rc->top, 0);
}
}
}
ReleaseDC(hdc_trans);
/* blit the transparent window */
SetMemDCAlpha(secondary_dc, MEMDC_FLAG_SRCALPHA, data->alpha);
BitBlt(secondary_dc, secondary_rc->left, secondary_rc->top,
RECTWP(secondary_rc), RECTHP(secondary_rc),
real_dc, real_rc->left, real_rc->top, 0);
if ( NULL != pRgn )
DestroyClipRgn(pRgn);
return 0;
}

非透明窗体更新

非透明窗体的更新函数除了更新自己的图像以为,还需要通知透明窗体,让其也更新。主要流程是:

  • 使用 GetNextMainWindow 遍历现有的主窗体查找到有 WS_EX_TRANSPARENT 的透明窗体(注意区分自己)。
  • 判断非透明窗体的更新区域是否与透明窗体相交。如果相交则调用 InvalidateRect 和 SendNotifyMessage 让透明窗体的客户区和非客户区重绘。
  • BitBlt 将自己的 memdc 输出到屏幕上。

代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
static int on_update_normal (HWND hWnd, HDC secondary_dc,HDC real_dc,
const RECT* secondary_rc, const RECT* real_rc, const RECT* main_update_rc)
{
RECT trans_rc;
RECT trans_nc_rc = *main_update_rc;
RECT update_rc = *main_update_rc;
HWND hwnd_normal = GetMainWindowHandle(hWnd);
HWND hwnd_trans = 0;
/* find out transparent main window to update it */
hwnd_trans = GetNextMainWindow(HWND_NULL);
while ( hwnd_trans ) {
if (hwnd_trans == hWnd) {
hwnd_trans = GetNextMainWindow(hwnd_trans);
continue;
}
if ( GetWindowExStyle(hwnd_trans) & WS_EX_TRANSPARENT ) {
/* this API return screen coordinates */
GetWindowRect(hwnd_trans, &trans_rc);
WindowToScreen(hwnd_normal, &update_rc.left, &update_rc.top);
WindowToScreen(hwnd_normal, &update_rc.right, &update_rc.bottom);
/* if update rect intersect transparent window, then update it */
if ( TRUE == DoesIntersect(&update_rc, &trans_rc) ) {
ScreenToClient(hwnd_trans, &update_rc.left, &update_rc.top);
ScreenToClient(hwnd_trans, &update_rc.right, &update_rc.bottom);
WindowToScreen(hwnd_normal, &trans_nc_rc.left, &trans_nc_rc.top);
WindowToScreen(hwnd_normal, &trans_nc_rc.right, &trans_nc_rc.bottom);
ScreenToWindow(hwnd_trans, &trans_nc_rc.left, &trans_nc_rc.top);
ScreenToWindow(hwnd_trans, &trans_nc_rc.right, &trans_nc_rc.bottom);
//InvalidateRect(hwnd_trans, &update_rc, TRUE);
InvalidateRect(hwnd_trans, NULL, TRUE);
//SendNotifyMessage(hwnd_trans, MSG_NCPAINT, 0, (LPARAM)&trans_nc_rc);
SendNotifyMessage(hwnd_trans, MSG_NCPAINT, 0, 0);
}
break;
}
hwnd_trans = GetNextMainWindow(hwnd_trans);
}
/* blit the normal window */
BitBlt(secondary_dc, secondary_rc->left, secondary_rc->top,
RECTWP(secondary_rc), RECTHP(secondary_rc),
real_dc, real_rc->left, real_rc->top, 0);
return 0;
}

使用范例

使用起来非简单,但有如下约定:

  • 必须使用对应的透明主窗体创建接口创建透明主窗体。
  • 必须使用对应的透明主窗体销毁接口销毁透明主窗体。
  • 只能创建一个透明主窗体。要创建下一个透明窗体时,必须要先销毁之前创建的。

具体例子见 附件 的 main.c 。(哎呦,好像链接失效了,哪天有空去翻翻看代码还不在不)


2011.2.16:改动1——支持逐点 alpha(包括在缓冲dc中)

问题

  • 在之前的实现中是没办法支持逐点 alpha 的(典型的例子使用 png 图片进行贴图)。因为在目前 MiniGUI 的 BitBlt 实现中,如果有开启了层 alpha (透明窗体的透明实现就是应用层 alpha),就会忽略掉逐点 alpha。典型问题就是如果你用 png 图片进行贴图,然后使用 BitBlt 又开启了 MEMDC_FLAGS_SRCALPHA 的话,就会看到你 png 图片本来透明的部分变黑(一般是 memdc 的默认颜色)。

  • 关于应用逐点 alpha 还有一个问题。如果是在 memdc 中使用的话,那么还有一个默认 dc 背景颜色的问题。当把 memdc BitBlt 到屏幕 dc 上的时候,逐点 alpha 会透出 memdc 默认的背景颜色(一般是黑色)。如果是在屏幕 dc 上,可以通过不绘制 MiniGUI 的背景来解决(截获 MSG_ERASEBKGND ,然后直接返回)。

解决办法

从以上的问题直接得到的解决办法是:

  • 多建立一个 memdc ,然后先 BitBlt 进行逐点 alpha 混合,然后再 BitBlt 到屏幕 dc,进行层 alpha 混合。

  • 在 32bit 颜色格式下,可以使用完全透明的颜色,将 memdc 的背景填充一次,这样在 alpha 混合的时候就可以完全透过 memdc 的背景色了。不过这个要求是 32bit 颜色格式的。16bit 色深下十分麻烦,要在 32bit 的memdc 上进行绘制,然后再转到 16bit 的屏幕 dc 上。这个就要求所有的图像加载参考 dc 都要是 32bit 的,并且所有 gdi 相关的参考 dc 都要是 32 bit 的。这个对于联芯来说,改动肯定很大,估计他是不会接受的。

从上面的讨论我们可以看到其实现在透明最大的问题的就是透明的背景问题。为了解决上面的问题可以采用这样的解决办法:

  • 将透明窗体下窗体的图像复制到透明窗体的缓存 dc 中做为透明的背景(这步可以在透明窗体的 MSG_ERASEBKGND 的消息里进行)。然后在缓冲 dc 里进行带逐点 alpha 的绘制。最后再用带层 alpha BitBlt 到屏幕 dc 上。这样缓冲 dc 里已经有正确的背景了,而且也已经正确的透过了,所以就算没了逐点 alpha 也是正确的了。并且这样还能解决 16bit 色下 memdc 透过默认背景的问题。

  • 这样在方案实现中增加2个接口:DefaultTransparentMainWinProc 和 DefaultTransparentDialogProc 用来封装 MSG_ERASEBKGND 消息处理。使用透明窗体要使用这2个接口替代 MiniGUI 原来的 DefaultMainWinProc 和 DefaultDialogProc 。

本质问题分析

上面的实现方式算是比较偏的了(也包括最开始的通过双缓冲来更新透明窗体的背景的实现)。其实如果要从正常逻辑实现透明窗体的话,应该提供如下2个条件:

  • z 序支持,从底到上,逐步重绘透明窗体的背景。
  • 32 bit 颜色格式。

更新下实现代码和示例。最开始写的代码有些地方不正确的。附近里的才是最新的。顺带上个效果图,show 一下,现在的 MiniGUI 也能做到这样的效果哦。 :-D

2011.3.24:改动2——一些小修正

问题

  • 很多无需收集的窗体,例如 窗口区域为0,不可见的。(联芯他们的 goku 框架里后台一大堆这样的窗口 -_-||
  • 被隐藏的窗口绘制不正确。
  • 给普通窗体动态添加双缓冲,第一次更新双缓冲中的图片,导致闪烁。
  • 透明窗体刷新速度慢

解决办法

  • 这个可以在透明窗体的更新函数里判断下,如果是不可见的窗体着跳过这个窗体的更新:

代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
static int on_update_transparent (HWND hWnd, HDC secondary_dc, HDC real_dc,
const RECT* secondary_rc, const RECT* real_rc, const RECT* main_update_rc)
{
... ...
/* update all visable main window to the transparent */
list_for_each(i, &data->hwnd_head) {
wnd_list = (hwnd_list_t *)i;
hwnd_normal = wnd_list->hwnd;
if ( hwnd_normal != HWND_INVALID && IsWindowVisible(hwnd_normal) ) {
/* this API return screen coordinates */
GetWindowRect(hwnd_normal, &normal_rc);
... ...
}
}
... ...
}
  • 这个和上面一样的解决办法

  • 这个在第一次更新时图像到双缓冲上的时候,应该不让双缓冲更新到屏幕上,也就是把双缓冲更新函数设置成 DONOTHING :

代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
static BOOL init_transparent_data (HWND hWnd)
{
... ...
/* check if the main window whether has WS_EX_AUTOSECONDARYDC */
if ( !(GetWindowExStyle(hwnd_main) & WS_EX_AUTOSECONDARYDC) ) {
hdc_mainwnd = GetDC(hwnd_main);
hdc_secondary = CreateCompatibleDC(hdc_mainwnd);
/* just update the secondary dc, not update the real dc
* this cat avoid screen blink */
SetSecondaryDC(hwnd_main, hdc_secondary, ON_UPDSECDC_DONOTHING);
ReleaseDC(hdc_mainwnd);
wnd_list->dc_flags = TRANS_NORMAL;
IncludeWindowExStyle(hwnd_main, WS_EX_AUTOSECONDARYDC);
/* update the image in the secondary dc */
UpdateWindow(hwnd_main, TRUE);
SetSecondaryDC(hwnd_main, hdc_secondary, on_update_normal);
}
... ...
}
  • 这个在联芯的实际使用情况中还是有点明显的。根据他们提出改进建议,在他们的使用情况中,有很大几率的情况会遇到在刷新链表中,某个普通窗体的更新区域(普通窗体与透明窗体相交的区域)正好是透明窗体的更新区域,这样就不需在更新后面的普通窗体的背景到透明窗体中来了。不过这样需要将保存的链表反序遍历,并且比较找到是否存在这样的普通窗体,还要记下这个链表位置(或者说记下这个窗体的句柄??)。仔细分析下,这种思路,在某些情况下应该是能提高效率的。不过我暂时没有实现这个,据说联芯他们在自己改。

代码路径

最开始的代码已经有很多地方不对了。这里就不在上传代码在本文档里了。现在的代码已经在 svn 中(在 3rd-party/transparent 里,devsrv 就是 10.10.0.9):

URL: svn+ssh://devsrv/home/projects/svn/minigui/branches/rel-3-0-arena

2011.4.19:改动3——支持动态设置/去除窗口透明属性

问题

联芯需要新加一系列动态设置透明窗体属性与动态去掉透明窗体属性的接口。他们需要有个需求,是因为想绕过透明窗体实现方案中的同时只能存在一个透明窗体的限制。他们想在透明窗体存在的时候,弹出一个普通窗体,然后去掉原来透明窗体的属性,最后再给弹出来的普通窗体加上透明属性。

解决办法

这个就目前的实现方法来说,并不是很难实现,灵活的运用现有的代码就能很轻松的实现了。新增加一个接口就可以了:


BOOL EnableWindowTransparent(HWND hWnd, BOOL isEnable);

可以通过后一个 BOOL 参数来决定是将普通窗体变成透明窗体,还是把透明窗体变成普通窗体。而这个函数内部可以简单调用内部2个实现函数就可以了:

1
2
3
4
5
6
7
8
9
10
11
BOOL EnableWindowTransparent(HWND hWnd, BOOL isEnable)
{
if (HWND_INVALID == hWnd)
return FALSE;
if (TRUE == isEnable)
return enable_win_transparent(hWnd);
else
return disable_win_transparent(hWnd);
}

至于内部的这个函数实现的流程如下:

  • enable_win_transparent:

    1. 如果当前窗体已经具有透明窗体属性,者直接返回。
    2. 判断当前窗体是否有双缓冲,如果没有,这动态的设置上双缓冲属性。
    3. 调用 init_transparent_data() 申请并初始化透明窗体数据。
    4. 更新当前窗体,使其呈现出透明窗体特性。
  • disable_win_transparent:

    1. 如果当前窗体
    2. 去除当前窗口
文章目录
  1. 1. 需求
  2. 2. 问题
  3. 3. 解决方案
  4. 4. 限制条件
  5. 5. 接口
  6. 6. 实现
    1. 6.1. 数据结构
    2. 6.2. 创建透明主窗体
    3. 6.3. 销毁透明主窗体
    4. 6.4. 透明窗体更新
    5. 6.5. 非透明窗体更新
  7. 7. 使用范例
  8. 8. 2011.2.16:改动1——支持逐点 alpha(包括在缓冲dc中)
    1. 8.1. 问题
    2. 8.2. 解决办法
    3. 8.3. 本质问题分析
  9. 9. 2011.3.24:改动2——一些小修正
    1. 9.1. 问题
    2. 9.2. 解决办法
    3. 9.3. 代码路径
  10. 10. 2011.4.19:改动3——支持动态设置/去除窗口透明属性
    1. 10.1. 问题
    2. 10.2. 解决办法