?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fixed some issues found by winapi_check.
[wine/dcerpc.git] / dlls / comctl32 / header.c
blob613938c23c107bcc387a00fb821cea99ca86a62e
1 /*
2 * Header control
3 *
4 * Copyright 1998 Eric Kohl
5 * Copyright 2000 Eric Kohl for CodeWeavers
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 * TODO:
22 * - Imagelist support (partially).
23 * - Callback items (under construction).
24 * - Hottrack support (partially).
25 * - Custom draw support (including Notifications).
26 * - Drag and Drop support (including Notifications).
27 * - New messages.
28 * - Use notification format
29 * - Correct the order maintenance code to preserve valid order
30 *
31 * FIXME:
32 * - Little flaw when drawing a bitmap on the right side of the text.
33 */
34
35 #include <string.h>
36
37 #include "winbase.h"
38 #include "wine/unicode.h"
39 #include "commctrl.h"
40 #include "comctl32.h"
41 #include "imagelist.h"
42 #include "wine/debug.h"
43
44 WINE_DEFAULT_DEBUG_CHANNEL(header);
45
46 typedef struct
47 {
48 INT cxy;
49 HBITMAP hbm;
50 LPWSTR pszText;
51 INT fmt;
52 LPARAM lParam;
53 INT iImage;
54 INT iOrder; /* see documentation of HD_ITEM */
55
56 BOOL bDown; /* is item pressed? (used for drawing) */
57 RECT rect; /* bounding rectangle of the item */
58 } HEADER_ITEM;
59
60
61 typedef struct
62 {
63 HWND hwndNotify; /* Owner window to send notifications to */
64 INT nNotifyFormat; /* format used for WM_NOTIFY messages */
65 UINT uNumItem; /* number of items (columns) */
66 INT nHeight; /* height of the header (pixels) */
67 HFONT hFont; /* handle to the current font */
68 HCURSOR hcurArrow; /* handle to the arrow cursor */
69 HCURSOR hcurDivider; /* handle to a cursor (used over dividers) <-|-> */
70 HCURSOR hcurDivopen; /* handle to a cursor (used over dividers) <-||-> */
71 BOOL bCaptured; /* Is the mouse captured? */
72 BOOL bPressed; /* Is a header item pressed (down)? */
73 BOOL bTracking; /* Is in tracking mode? */
74 BOOL bUnicode; /* Unicode flag */
75 INT iMoveItem; /* index of tracked item. (Tracking mode) */
76 INT xTrackOffset; /* distance between the right side of the tracked item and the cursor */
77 INT xOldTrack; /* track offset (see above) after the last WM_MOUSEMOVE */
78 INT nOldWidth; /* width of a sizing item after the last WM_MOUSEMOVE */
79 INT iHotItem; /* index of hot item (cursor is over this item) */
80
81 HIMAGELIST himl; /* handle to a image list (may be 0) */
82 HEADER_ITEM *items; /* pointer to array of HEADER_ITEM's */
83 BOOL bRectsValid; /* validity flag for bounding rectangles */
84 } HEADER_INFO;
85
86
87 #define VERT_BORDER 4
88 #define DIVIDER_WIDTH 10
89
90 #define HEADER_GetInfoPtr(hwnd) ((HEADER_INFO *)GetWindowLongA(hwnd,0))
91
92
93 inline static LRESULT
94 HEADER_IndexToOrder (HWND hwnd, INT iItem)
95 {
96 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
97 HEADER_ITEM *lpItem = &infoPtr->items[iItem];
98 return lpItem->iOrder;
99 }
100
101
102 static INT
103 HEADER_OrderToIndex(HWND hwnd, WPARAM wParam)
104 {
105 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
106 INT i,iorder = (INT)wParam;
107
108
109 if ((iorder <0) || iorder >infoPtr->uNumItem)
110 return iorder;
111 for (i=0; i<infoPtr->uNumItem; i++)
112 if (HEADER_IndexToOrder(hwnd,i) == iorder)
113 return i;
114 return iorder;
115 }
116
117 static void
118 HEADER_SetItemBounds (HWND hwnd)
119 {
120 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
121 HEADER_ITEM *phdi;
122 RECT rect;
123 int i, x;
124
125 infoPtr->bRectsValid = TRUE;
126
127 if (infoPtr->uNumItem == 0)
128 return;
129
130 GetClientRect (hwnd, &rect);
131
132 x = rect.left;
133 for (i = 0; i < infoPtr->uNumItem; i++) {
134 phdi = &infoPtr->items[HEADER_OrderToIndex(hwnd,i)];
135 phdi->rect.top = rect.top;
136 phdi->rect.bottom = rect.bottom;
137 phdi->rect.left = x;
138 phdi->rect.right = phdi->rect.left + ((phdi->cxy>0)?phdi->cxy:0);
139 x = phdi->rect.right;
140 }
141 }
142
143 static LRESULT
144 HEADER_Size (HWND hwnd, WPARAM wParam)
145 {
146 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
147
148 infoPtr->bRectsValid = FALSE;
149
150 return 0;
151 }
152
153
154 static INT
155 HEADER_DrawItem (HWND hwnd, HDC hdc, INT iItem, BOOL bHotTrack)
156 {
157 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
158 HEADER_ITEM *phdi = &infoPtr->items[iItem];
159 RECT r;
160 INT oldBkMode;
161
162 TRACE("DrawItem(iItem %d bHotTrack %d unicode flag %d)\n", iItem, bHotTrack, infoPtr->bUnicode);
163
164 if (!infoPtr->bRectsValid)
165 HEADER_SetItemBounds(hwnd);
166
167 r = phdi->rect;
168 if (r.right - r.left == 0)
169 return phdi->rect.right;
170
171 if (GetWindowLongA (hwnd, GWL_STYLE) & HDS_BUTTONS) {
172 if (phdi->bDown) {
173 DrawEdge (hdc, &r, BDR_RAISEDOUTER,
174 BF_RECT | BF_FLAT | BF_MIDDLE | BF_ADJUST);
175 r.left += 2;
176 r.top += 2;
177 }
178 else
179 DrawEdge (hdc, &r, EDGE_RAISED,
180 BF_RECT | BF_SOFT | BF_MIDDLE | BF_ADJUST);
181 }
182 else
183 DrawEdge (hdc, &r, EDGE_ETCHED, BF_BOTTOM | BF_RIGHT | BF_ADJUST);
184
185 if (phdi->fmt & HDF_OWNERDRAW) {
186 DRAWITEMSTRUCT dis;
187 dis.CtlType = ODT_HEADER;
188 dis.CtlID = GetWindowLongA (hwnd, GWL_ID);
189 dis.itemID = iItem;
190 dis.itemAction = ODA_DRAWENTIRE;
191 dis.itemState = phdi->bDown ? ODS_SELECTED : 0;
192 dis.hwndItem = hwnd;
193 dis.hDC = hdc;
194 dis.rcItem = r;
195 dis.itemData = phdi->lParam;
196 oldBkMode = SetBkMode(hdc, TRANSPARENT);
197 SendMessageA (GetParent (hwnd), WM_DRAWITEM,
198 (WPARAM)dis.CtlID, (LPARAM)&dis);
199 if (oldBkMode != TRANSPARENT)
200 SetBkMode(hdc, oldBkMode);
201 }
202 else {
203 UINT uTextJustify = DT_LEFT;
204
205 if ((phdi->fmt & HDF_JUSTIFYMASK) == HDF_CENTER)
206 uTextJustify = DT_CENTER;
207 else if ((phdi->fmt & HDF_JUSTIFYMASK) == HDF_RIGHT)
208 uTextJustify = DT_RIGHT;
209
210 if ((phdi->fmt & HDF_BITMAP) && (phdi->hbm)) {
211 BITMAP bmp;
212 HDC hdcBitmap;
213 INT yD, yS, cx, cy, rx, ry;
214
215 GetObjectA (phdi->hbm, sizeof(BITMAP), (LPVOID)&bmp);
216
217 ry = r.bottom - r.top;
218 rx = r.right - r.left;
219
220 if (ry >= bmp.bmHeight) {
221 cy = bmp.bmHeight;
222 yD = r.top + (ry - bmp.bmHeight) / 2;
223 yS = 0;
224 }
225 else {
226 cy = ry;
227 yD = r.top;
228 yS = (bmp.bmHeight - ry) / 2;
229
230 }
231
232 if (rx >= bmp.bmWidth + 6) {
233 cx = bmp.bmWidth;
234 }
235 else {
236 cx = rx - 6;
237 }
238
239 hdcBitmap = CreateCompatibleDC (hdc);
240 SelectObject (hdcBitmap, phdi->hbm);
241 BitBlt (hdc, r.left + 3, yD, cx, cy, hdcBitmap, 0, yS, SRCCOPY);
242 DeleteDC (hdcBitmap);
243
244 r.left += (bmp.bmWidth + 3);
245 }
246
247
248 if ((phdi->fmt & HDF_BITMAP_ON_RIGHT) && (phdi->hbm)) {
249 BITMAP bmp;
250 HDC hdcBitmap;
251 INT xD, yD, yS, cx, cy, rx, ry, tx;
252 RECT textRect;
253
254 GetObjectA (phdi->hbm, sizeof(BITMAP), (LPVOID)&bmp);
255
256 textRect = r;
257 if (infoPtr->bUnicode)
258 DrawTextW (hdc, phdi->pszText, -1,
259 &textRect, DT_LEFT|DT_VCENTER|DT_SINGLELINE|DT_CALCRECT);
260 else
261 DrawTextA (hdc, (LPCSTR)phdi->pszText, -1,
262 &textRect, DT_LEFT|DT_VCENTER|DT_SINGLELINE|DT_CALCRECT);
263 tx = textRect.right - textRect.left;
264 ry = r.bottom - r.top;
265 rx = r.right - r.left;
266
267 if (ry >= bmp.bmHeight) {
268 cy = bmp.bmHeight;
269 yD = r.top + (ry - bmp.bmHeight) / 2;
270 yS = 0;
271 }
272 else {
273 cy = ry;
274 yD = r.top;
275 yS = (bmp.bmHeight - ry) / 2;
276
277 }
278
279 if (r.left + tx + bmp.bmWidth + 9 <= r.right) {
280 cx = bmp.bmWidth;
281 xD = r.left + tx + 6;
282 }
283 else {
284 if (rx >= bmp.bmWidth + 6) {
285 cx = bmp.bmWidth;
286 xD = r.right - bmp.bmWidth - 3;
287 r.right = xD - 3;
288 }
289 else {
290 cx = rx - 3;
291 xD = r.left;
292 r.right = r.left;
293 }
294 }
295
296 hdcBitmap = CreateCompatibleDC (hdc);
297 SelectObject (hdcBitmap, phdi->hbm);
298 BitBlt (hdc, xD, yD, cx, cy, hdcBitmap, 0, yS, SRCCOPY);
299 DeleteDC (hdcBitmap);
300 }
301
302 if ((phdi->fmt & HDF_IMAGE) && (infoPtr->himl)) {
303 r.left +=3;
304 /* FIXME: (r.bottom- (infoPtr->himl->cy))/2 should horicontal center the image
305 It looks like it doesn't work as expected*/
306 ImageList_Draw (infoPtr->himl, phdi->iImage,hdc,r.left, (r.bottom- (infoPtr->himl->cy))/2,0);
307 r.left += infoPtr->himl->cx;
308 }
309
310 if (((phdi->fmt & HDF_STRING)
311 || (!(phdi->fmt & (HDF_OWNERDRAW|HDF_STRING|HDF_BITMAP|
312 HDF_BITMAP_ON_RIGHT|HDF_IMAGE)))) /* no explicit format specified? */
313 && (phdi->pszText)) {
314 oldBkMode = SetBkMode(hdc, TRANSPARENT);
315 r.left += 3 ;
316 r.right -= 3;
317 SetTextColor (hdc, (bHotTrack) ? COLOR_HIGHLIGHT : COLOR_BTNTEXT);
318 if (infoPtr->bUnicode)
319 DrawTextW (hdc, phdi->pszText, -1,
320 &r, uTextJustify|DT_END_ELLIPSIS|DT_VCENTER|DT_SINGLELINE);
321 else
322 DrawTextA (hdc, (LPCSTR)phdi->pszText, -1,
323 &r, uTextJustify|DT_END_ELLIPSIS|DT_VCENTER|DT_SINGLELINE);
324 if (oldBkMode != TRANSPARENT)
325 SetBkMode(hdc, oldBkMode);
326 }
327 }/*Ownerdrawn*/
328
329 return phdi->rect.right;
330 }
331
332
333 static void
334 HEADER_Refresh (HWND hwnd, HDC hdc)
335 {
336 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
337 HFONT hFont, hOldFont;
338 RECT rect;
339 HBRUSH hbrBk;
340 INT i, x;
341
342 /* get rect for the bar, adjusted for the border */
343 GetClientRect (hwnd, &rect);
344
345 hFont = infoPtr->hFont ? infoPtr->hFont : GetStockObject (SYSTEM_FONT);
346 hOldFont = SelectObject (hdc, hFont);
347
348 /* draw Background */
349 hbrBk = GetSysColorBrush(COLOR_3DFACE);
350 FillRect(hdc, &rect, hbrBk);
351
352 x = rect.left;
353 for (i = 0; i < infoPtr->uNumItem; i++) {
354 x = HEADER_DrawItem (hwnd, hdc, HEADER_OrderToIndex(hwnd,i), FALSE);
355 }
356
357 if ((x <= rect.right) && (infoPtr->uNumItem > 0)) {
358 rect.left = x;
359 if (GetWindowLongA (hwnd, GWL_STYLE) & HDS_BUTTONS)
360 DrawEdge (hdc, &rect, EDGE_RAISED, BF_TOP|BF_LEFT|BF_BOTTOM|BF_SOFT);
361 else
362 DrawEdge (hdc, &rect, EDGE_ETCHED, BF_BOTTOM);
363 }
364
365 SelectObject (hdc, hOldFont);
366 }
367
368
369 static void
370 HEADER_RefreshItem (HWND hwnd, HDC hdc, INT iItem)
371 {
372 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
373 HFONT hFont, hOldFont;
374
375 hFont = infoPtr->hFont ? infoPtr->hFont : GetStockObject (SYSTEM_FONT);
376 hOldFont = SelectObject (hdc, hFont);
377 HEADER_DrawItem (hwnd, hdc, iItem, FALSE);
378 SelectObject (hdc, hOldFont);
379 }
380
381
382 static void
383 HEADER_InternalHitTest (HWND hwnd, LPPOINT lpPt, UINT *pFlags, INT *pItem)
384 {
385 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
386 RECT rect, rcTest;
387 INT iCount, width;
388 BOOL bNoWidth;
389
390 GetClientRect (hwnd, &rect);
391
392 *pFlags = 0;
393 bNoWidth = FALSE;
394 if (PtInRect (&rect, *lpPt))
395 {
396 if (infoPtr->uNumItem == 0) {
397 *pFlags |= HHT_NOWHERE;
398 *pItem = 1;
399 TRACE("NOWHERE\n");
400 return;
401 }
402 else {
403 /* somewhere inside */
404 for (iCount = 0; iCount < infoPtr->uNumItem; iCount++) {
405 rect = infoPtr->items[iCount].rect;
406 width = rect.right - rect.left;
407 if (width == 0) {
408 bNoWidth = TRUE;
409 continue;
410 }
411 if (PtInRect (&rect, *lpPt)) {
412 if (width <= 2 * DIVIDER_WIDTH) {
413 *pFlags |= HHT_ONHEADER;
414 *pItem = iCount;
415 TRACE("ON HEADER %d\n", iCount);
416 return;
417 }
418 if (iCount > 0) {
419 rcTest = rect;
420 rcTest.right = rcTest.left + DIVIDER_WIDTH;
421 if (PtInRect (&rcTest, *lpPt)) {
422 if (bNoWidth) {
423 *pFlags |= HHT_ONDIVOPEN;
424 *pItem = iCount - 1;
425 TRACE("ON DIVOPEN %d\n", *pItem);
426 return;
427 }
428 else {
429 *pFlags |= HHT_ONDIVIDER;
430 *pItem = iCount - 1;
431 TRACE("ON DIVIDER %d\n", *pItem);
432 return;
433 }
434 }
435 }
436 rcTest = rect;
437 rcTest.left = rcTest.right - DIVIDER_WIDTH;
438 if (PtInRect (&rcTest, *lpPt)) {
439 *pFlags |= HHT_ONDIVIDER;
440 *pItem = iCount;
441 TRACE("ON DIVIDER %d\n", *pItem);
442 return;
443 }
444
445 *pFlags |= HHT_ONHEADER;
446 *pItem = iCount;
447 TRACE("ON HEADER %d\n", iCount);
448 return;
449 }
450 }
451
452 /* check for last divider part (on nowhere) */
453 rect = infoPtr->items[infoPtr->uNumItem-1].rect;
454 rect.left = rect.right;
455 rect.right += DIVIDER_WIDTH;
456 if (PtInRect (&rect, *lpPt)) {
457 if (bNoWidth) {
458 *pFlags |= HHT_ONDIVOPEN;
459 *pItem = infoPtr->uNumItem - 1;
460 TRACE("ON DIVOPEN %d\n", *pItem);
461 return;
462 }
463 else {
464 *pFlags |= HHT_ONDIVIDER;
465 *pItem = infoPtr->uNumItem-1;
466 TRACE("ON DIVIDER %d\n", *pItem);
467 return;
468 }
469 }
470
471 *pFlags |= HHT_NOWHERE;
472 *pItem = 1;
473 TRACE("NOWHERE\n");
474 return;
475 }
476 }
477 else {
478 if (lpPt->x < rect.left) {
479 TRACE("TO LEFT\n");
480 *pFlags |= HHT_TOLEFT;
481 }
482 else if (lpPt->x > rect.right) {
483 TRACE("TO RIGHT\n");
484 *pFlags |= HHT_TORIGHT;
485 }
486
487 if (lpPt->y < rect.top) {
488 TRACE("ABOVE\n");
489 *pFlags |= HHT_ABOVE;
490 }
491 else if (lpPt->y > rect.bottom) {
492 TRACE("BELOW\n");
493 *pFlags |= HHT_BELOW;
494 }
495 }
496
497 *pItem = 1;
498 TRACE("flags=0x%X\n", *pFlags);
499 return;
500 }
501
502
503 static void
504 HEADER_DrawTrackLine (HWND hwnd, HDC hdc, INT x)
505 {
506 RECT rect;
507 HPEN hOldPen;
508 INT oldRop;
509
510 GetClientRect (hwnd, &rect);
511
512 hOldPen = SelectObject (hdc, GetStockObject (BLACK_PEN));
513 oldRop = SetROP2 (hdc, R2_XORPEN);
514 MoveToEx (hdc, x, rect.top, NULL);
515 LineTo (hdc, x, rect.bottom);
516 SetROP2 (hdc, oldRop);
517 SelectObject (hdc, hOldPen);
518 }
519
520
521 static BOOL
522 HEADER_SendSimpleNotify (HWND hwnd, UINT code)
523 {
524 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
525 NMHDR nmhdr;
526
527 nmhdr.hwndFrom = hwnd;
528 nmhdr.idFrom = GetWindowLongA (hwnd, GWL_ID);
529 nmhdr.code = code;
530
531 return (BOOL)SendMessageA (infoPtr->hwndNotify, WM_NOTIFY,
532 (WPARAM)nmhdr.idFrom, (LPARAM)&nmhdr);
533 }
534
535 static BOOL
536 HEADER_SendHeaderNotify (HWND hwnd, UINT code, INT iItem, INT mask)
537 {
538 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
539 NMHEADERA nmhdr;
540 HDITEMA nmitem;
541
542 nmhdr.hdr.hwndFrom = hwnd;
543 nmhdr.hdr.idFrom = GetWindowLongA (hwnd, GWL_ID);
544 nmhdr.hdr.code = code;
545 nmhdr.iItem = iItem;
546 nmhdr.iButton = 0;
547 nmhdr.pitem = &nmitem;
548 nmitem.mask = mask;
549 nmitem.cxy = infoPtr->items[iItem].cxy;
550 nmitem.hbm = infoPtr->items[iItem].hbm;
551 nmitem.pszText = NULL;
552 nmitem.cchTextMax = 0;
553 /* nmitem.pszText = infoPtr->items[iItem].pszText; */
554 /* nmitem.cchTextMax = infoPtr->items[iItem].cchTextMax; */
555 nmitem.fmt = infoPtr->items[iItem].fmt;
556 nmitem.lParam = infoPtr->items[iItem].lParam;
557 nmitem.iOrder = infoPtr->items[iItem].iOrder;
558 nmitem.iImage = infoPtr->items[iItem].iImage;
559
560 return (BOOL)SendMessageA (infoPtr->hwndNotify, WM_NOTIFY,
561 (WPARAM)nmhdr.hdr.idFrom, (LPARAM)&nmhdr);
562 }
563
564
565 static BOOL
566 HEADER_SendClickNotify (HWND hwnd, UINT code, INT iItem)
567 {
568 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
569 NMHEADERA nmhdr;
570
571 nmhdr.hdr.hwndFrom = hwnd;
572 nmhdr.hdr.idFrom = GetWindowLongA (hwnd, GWL_ID);
573 nmhdr.hdr.code = code;
574 nmhdr.iItem = iItem;
575 nmhdr.iButton = 0;
576 nmhdr.pitem = NULL;
577
578 return (BOOL)SendMessageA (infoPtr->hwndNotify, WM_NOTIFY,
579 (WPARAM)nmhdr.hdr.idFrom, (LPARAM)&nmhdr);
580 }
581
582
583 static LRESULT
584 HEADER_CreateDragImage (HWND hwnd, WPARAM wParam)
585 {
586 FIXME("empty stub!\n");
587 return 0;
588 }
589
590
591 static LRESULT
592 HEADER_DeleteItem (HWND hwnd, WPARAM wParam)
593 {
594 HEADER_INFO *infoPtr = HEADER_GetInfoPtr(hwnd);
595 INT iItem = (INT)wParam;
596
597 TRACE("[iItem=%d]\n", iItem);
598
599 if ((iItem < 0) || (iItem >= (INT)infoPtr->uNumItem))
600 return FALSE;
601
602 if (infoPtr->uNumItem == 1) {
603 TRACE("Simple delete!\n");
604 if (infoPtr->items[0].pszText)
605 COMCTL32_Free (infoPtr->items[0].pszText);
606 COMCTL32_Free (infoPtr->items);
607 infoPtr->items = 0;
608 infoPtr->uNumItem = 0;
609 }
610 else {
611 HEADER_ITEM *oldItems = infoPtr->items;
612 HEADER_ITEM *pItem;
613 INT i;
614 INT iOrder;
615 TRACE("Complex delete! [iItem=%d]\n", iItem);
616
617 if (infoPtr->items[iItem].pszText)
618 COMCTL32_Free (infoPtr->items[iItem].pszText);
619 iOrder = infoPtr->items[iItem].iOrder;
620
621 infoPtr->uNumItem--;
622 infoPtr->items = COMCTL32_Alloc (sizeof (HEADER_ITEM) * infoPtr->uNumItem);
623 /* pre delete copy */
624 if (iItem > 0) {
625 memcpy (&infoPtr->items[0], &oldItems[0],
626 iItem * sizeof(HEADER_ITEM));
627 }
628
629 /* post delete copy */
630 if (iItem < infoPtr->uNumItem) {
631 memcpy (&infoPtr->items[iItem], &oldItems[iItem+1],
632 (infoPtr->uNumItem - iItem) * sizeof(HEADER_ITEM));
633 }
634
635 /* Correct the orders */
636 for (i=infoPtr->uNumItem, pItem = infoPtr->items; i; i--, pItem++)
637 {
638 if (pItem->iOrder > iOrder)
639 pItem->iOrder--;
640 }
641 COMCTL32_Free (oldItems);
642 }
643
644 HEADER_SetItemBounds (hwnd);
645
646 InvalidateRect(hwnd, NULL, FALSE);
647
648 return TRUE;
649 }
650
651
652 static LRESULT
653 HEADER_GetImageList (HWND hwnd)
654 {
655 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
656
657 return (LRESULT)infoPtr->himl;
658 }
659
660
661 static LRESULT
662 HEADER_GetItemA (HWND hwnd, WPARAM wParam, LPARAM lParam)
663 {
664 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
665 HDITEMA *phdi = (HDITEMA*)lParam;
666 INT nItem = (INT)wParam;
667 HEADER_ITEM *lpItem;
668
669 if (!phdi)
670 return FALSE;
671 if ((nItem < 0) || (nItem >= (INT)infoPtr->uNumItem))
672 return FALSE;
673
674 TRACE("[nItem=%d]\n", nItem);
675
676 if (phdi->mask == 0)
677 return TRUE;
678
679 lpItem = &infoPtr->items[nItem];
680 if (phdi->mask & HDI_BITMAP)
681 phdi->hbm = lpItem->hbm;
682
683 if (phdi->mask & HDI_FORMAT)
684 phdi->fmt = lpItem->fmt;
685
686 if (phdi->mask & HDI_WIDTH)
687 phdi->cxy = lpItem->cxy;
688
689 if (phdi->mask & HDI_LPARAM)
690 phdi->lParam = lpItem->lParam;
691
692 if (phdi->mask & HDI_TEXT) {
693 if (lpItem->pszText != LPSTR_TEXTCALLBACKW) {
694 if (lpItem->pszText)
695 WideCharToMultiByte (CP_ACP, 0, lpItem->pszText, -1,
696 phdi->pszText, phdi->cchTextMax, NULL, NULL);
697 else
698 *phdi->pszText = 0;
699 }
700 else
701 phdi->pszText = LPSTR_TEXTCALLBACKA;
702 }
703
704 if (phdi->mask & HDI_IMAGE)
705 phdi->iImage = lpItem->iImage;
706
707 if (phdi->mask & HDI_ORDER)
708 phdi->iOrder = lpItem->iOrder;
709
710 return TRUE;
711 }
712
713
714 static LRESULT
715 HEADER_GetItemW (HWND hwnd, WPARAM wParam, LPARAM lParam)
716 {
717 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
718 HDITEMW *phdi = (HDITEMW*)lParam;
719 INT nItem = (INT)wParam;
720 HEADER_ITEM *lpItem;
721
722 if (!phdi)
723 return FALSE;
724 if ((nItem < 0) || (nItem >= (INT)infoPtr->uNumItem))
725 return FALSE;
726
727 TRACE("[nItem=%d]\n", nItem);
728
729 if (phdi->mask == 0)
730 return TRUE;
731
732 lpItem = &infoPtr->items[nItem];
733 if (phdi->mask & HDI_BITMAP)
734 phdi->hbm = lpItem->hbm;
735
736 if (phdi->mask & HDI_FORMAT)
737 phdi->fmt = lpItem->fmt;
738
739 if (phdi->mask & HDI_WIDTH)
740 phdi->cxy = lpItem->cxy;
741
742 if (phdi->mask & HDI_LPARAM)
743 phdi->lParam = lpItem->lParam;
744
745 if (phdi->mask & HDI_TEXT) {
746 if (lpItem->pszText != LPSTR_TEXTCALLBACKW) {
747 if (lpItem->pszText)
748 lstrcpynW (phdi->pszText, lpItem->pszText, phdi->cchTextMax);
749 else
750 *phdi->pszText = 0;
751 }
752 else
753 phdi->pszText = LPSTR_TEXTCALLBACKW;
754 }
755
756 if (phdi->mask & HDI_IMAGE)
757 phdi->iImage = lpItem->iImage;
758
759 if (phdi->mask & HDI_ORDER)
760 phdi->iOrder = lpItem->iOrder;
761
762 return TRUE;
763 }
764
765
766 inline static LRESULT
767 HEADER_GetItemCount (HWND hwnd)
768 {
769 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
770 return infoPtr->uNumItem;
771 }
772
773
774 static LRESULT
775 HEADER_GetItemRect (HWND hwnd, WPARAM wParam, LPARAM lParam)
776 {
777 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
778 INT iItem = (INT)wParam;
779 LPRECT lpRect = (LPRECT)lParam;
780
781 if ((iItem < 0) || (iItem >= (INT)infoPtr->uNumItem))
782 return FALSE;
783
784 lpRect->left = infoPtr->items[iItem].rect.left;
785 lpRect->right = infoPtr->items[iItem].rect.right;
786 lpRect->top = infoPtr->items[iItem].rect.top;
787 lpRect->bottom = infoPtr->items[iItem].rect.bottom;
788
789 return TRUE;
790 }
791
792
793 static LRESULT
794 HEADER_GetOrderArray(HWND hwnd, WPARAM wParam, LPARAM lParam)
795 {
796 int i;
797 LPINT order = (LPINT) lParam;
798 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
799
800 if ((int)wParam <infoPtr->uNumItem)
801 return FALSE;
802 for (i=0; i<(int)wParam; i++)
803 *order++=HEADER_OrderToIndex(hwnd,i);
804 return TRUE;
805 }
806
807 static LRESULT
808 HEADER_SetOrderArray(HWND hwnd, WPARAM wParam, LPARAM lParam)
809 {
810 int i;
811 LPINT order = (LPINT) lParam;
812 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
813 HEADER_ITEM *lpItem;
814
815 if ((int)wParam <infoPtr->uNumItem)
816 return FALSE;
817 for (i=0; i<(int)wParam; i++)
818 {
819 lpItem = &infoPtr->items[*order++];
820 lpItem->iOrder=i;
821 }
822 infoPtr->bRectsValid=0;
823 InvalidateRect(hwnd, NULL, FALSE);
824 return TRUE;
825 }
826
827 inline static LRESULT
828 HEADER_GetUnicodeFormat (HWND hwnd)
829 {
830 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
831 return infoPtr->bUnicode;
832 }
833
834
835 static LRESULT
836 HEADER_HitTest (HWND hwnd, WPARAM wParam, LPARAM lParam)
837 {
838 LPHDHITTESTINFO phti = (LPHDHITTESTINFO)lParam;
839
840 HEADER_InternalHitTest (hwnd, &phti->pt, &phti->flags, &phti->iItem);
841
842 if (phti->flags == HHT_ONHEADER)
843 return phti->iItem;
844 else
845 return -1;
846 }
847
848
849 static LRESULT
850 HEADER_InsertItemA (HWND hwnd, WPARAM wParam, LPARAM lParam)
851 {
852 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
853 HDITEMA *phdi = (HDITEMA*)lParam;
854 INT nItem = (INT)wParam;
855 HEADER_ITEM *lpItem;
856 INT len;
857
858 if ((phdi == NULL) || (nItem < 0))
859 return -1;
860
861 if (nItem > infoPtr->uNumItem)
862 nItem = infoPtr->uNumItem;
863
864 if (infoPtr->uNumItem == 0) {
865 infoPtr->items = COMCTL32_Alloc (sizeof (HEADER_ITEM));
866 infoPtr->uNumItem++;
867 }
868 else {
869 HEADER_ITEM *oldItems = infoPtr->items;
870
871 infoPtr->uNumItem++;
872 infoPtr->items = COMCTL32_Alloc (sizeof (HEADER_ITEM) * infoPtr->uNumItem);
873 if (nItem == 0) {
874 memcpy (&infoPtr->items[1], &oldItems[0],
875 (infoPtr->uNumItem-1) * sizeof(HEADER_ITEM));
876 }
877 else
878 {
879 /* pre insert copy */
880 if (nItem > 0) {
881 memcpy (&infoPtr->items[0], &oldItems[0],
882 nItem * sizeof(HEADER_ITEM));
883 }
884
885 /* post insert copy */
886 if (nItem < infoPtr->uNumItem - 1) {
887 memcpy (&infoPtr->items[nItem+1], &oldItems[nItem],
888 (infoPtr->uNumItem - nItem - 1) * sizeof(HEADER_ITEM));
889 }
890 }
891
892 COMCTL32_Free (oldItems);
893 }
894
895 lpItem = &infoPtr->items[nItem];
896 lpItem->bDown = FALSE;
897
898 if (phdi->mask & HDI_WIDTH)
899 lpItem->cxy = phdi->cxy;
900
901 if (phdi->mask & HDI_TEXT) {
902 if (!phdi->pszText) /* null pointer check */
903 phdi->pszText = "";
904 if (phdi->pszText != LPSTR_TEXTCALLBACKA) {
905 len = MultiByteToWideChar(CP_ACP, 0, phdi->pszText, -1, NULL, 0);
906 lpItem->pszText = COMCTL32_Alloc( len*sizeof(WCHAR) );
907 MultiByteToWideChar(CP_ACP, 0, phdi->pszText, -1, lpItem->pszText, len);
908 }
909 else
910 lpItem->pszText = LPSTR_TEXTCALLBACKW;
911 }
912
913 if (phdi->mask & HDI_FORMAT)
914 lpItem->fmt = phdi->fmt;
915
916 if (lpItem->fmt == 0)
917 lpItem->fmt = HDF_LEFT;
918
919 if (!(lpItem->fmt & HDF_STRING) && (phdi->mask & HDI_TEXT))
920 {
921 lpItem->fmt |= HDF_STRING;
922 }
923 if (phdi->mask & HDI_BITMAP)
924 lpItem->hbm = phdi->hbm;
925
926 if (phdi->mask & HDI_LPARAM)
927 lpItem->lParam = phdi->lParam;
928
929 if (phdi->mask & HDI_IMAGE)
930 lpItem->iImage = phdi->iImage;
931
932 if (phdi->mask & HDI_ORDER)
933 {
934 lpItem->iOrder = phdi->iOrder;
935 }
936 else
937 lpItem->iOrder=nItem;
938
939
940 HEADER_SetItemBounds (hwnd);
941
942 InvalidateRect(hwnd, NULL, FALSE);
943
944 return nItem;
945 }
946
947
948 static LRESULT
949 HEADER_InsertItemW (HWND hwnd, WPARAM wParam, LPARAM lParam)
950 {
951 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
952 HDITEMW *phdi = (HDITEMW*)lParam;
953 INT nItem = (INT)wParam;
954 HEADER_ITEM *lpItem;
955 INT len;
956
957 if ((phdi == NULL) || (nItem < 0))
958 return -1;
959
960 if (nItem > infoPtr->uNumItem)
961 nItem = infoPtr->uNumItem;
962
963 if (infoPtr->uNumItem == 0) {
964 infoPtr->items = COMCTL32_Alloc (sizeof (HEADER_ITEM));
965 infoPtr->uNumItem++;
966 }
967 else {
968 HEADER_ITEM *oldItems = infoPtr->items;
969
970 infoPtr->uNumItem++;
971 infoPtr->items = COMCTL32_Alloc (sizeof (HEADER_ITEM) * infoPtr->uNumItem);
972 if (nItem == 0) {
973 memcpy (&infoPtr->items[1], &oldItems[0],
974 (infoPtr->uNumItem-1) * sizeof(HEADER_ITEM));
975 }
976 else
977 {
978 /* pre insert copy */
979 if (nItem > 0) {
980 memcpy (&infoPtr->items[0], &oldItems[0],
981 nItem * sizeof(HEADER_ITEM));
982 }
983
984 /* post insert copy */
985 if (nItem < infoPtr->uNumItem - 1) {
986 memcpy (&infoPtr->items[nItem+1], &oldItems[nItem],
987 (infoPtr->uNumItem - nItem - 1) * sizeof(HEADER_ITEM));
988 }
989 }
990
991 COMCTL32_Free (oldItems);
992 }
993
994 lpItem = &infoPtr->items[nItem];
995 lpItem->bDown = FALSE;
996
997 if (phdi->mask & HDI_WIDTH)
998 lpItem->cxy = phdi->cxy;
999
1000 if (phdi->mask & HDI_TEXT) {
1001 WCHAR wide_null_char = 0;
1002 if (!phdi->pszText) /* null pointer check */
1003 phdi->pszText = &wide_null_char;
1004 if (phdi->pszText != LPSTR_TEXTCALLBACKW) {
1005 len = strlenW (phdi->pszText);
1006 lpItem->pszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
1007 strcpyW (lpItem->pszText, phdi->pszText);
1008 }
1009 else
1010 lpItem->pszText = LPSTR_TEXTCALLBACKW;
1011 }
1012
1013 if (phdi->mask & HDI_FORMAT)
1014 lpItem->fmt = phdi->fmt;
1015
1016 if (lpItem->fmt == 0)
1017 lpItem->fmt = HDF_LEFT;
1018
1019 if (!(lpItem->fmt &HDF_STRING) && (phdi->mask & HDI_TEXT))
1020 {
1021 lpItem->fmt |= HDF_STRING;
1022 }
1023 if (phdi->mask & HDI_BITMAP)
1024 lpItem->hbm = phdi->hbm;
1025
1026 if (phdi->mask & HDI_LPARAM)
1027 lpItem->lParam = phdi->lParam;
1028
1029 if (phdi->mask & HDI_IMAGE)
1030 lpItem->iImage = phdi->iImage;
1031
1032 if (phdi->mask & HDI_ORDER)
1033 {
1034 lpItem->iOrder = phdi->iOrder;
1035 }
1036 else
1037 lpItem->iOrder = nItem;
1038
1039 HEADER_SetItemBounds (hwnd);
1040
1041 InvalidateRect(hwnd, NULL, FALSE);
1042
1043 return nItem;
1044 }
1045
1046
1047 static LRESULT
1048 HEADER_Layout (HWND hwnd, WPARAM wParam, LPARAM lParam)
1049 {
1050 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
1051 LPHDLAYOUT lpLayout = (LPHDLAYOUT)lParam;
1052
1053 lpLayout->pwpos->hwnd = hwnd;
1054 lpLayout->pwpos->hwndInsertAfter = 0;
1055 lpLayout->pwpos->x = lpLayout->prc->left;
1056 lpLayout->pwpos->y = lpLayout->prc->top;
1057 lpLayout->pwpos->cx = lpLayout->prc->right - lpLayout->prc->left;
1058 if (GetWindowLongA (hwnd, GWL_STYLE) & HDS_HIDDEN)
1059 lpLayout->pwpos->cy = 0;
1060 else {
1061 lpLayout->pwpos->cy = infoPtr->nHeight;
1062 lpLayout->prc->top += infoPtr->nHeight;
1063 }
1064 lpLayout->pwpos->flags = SWP_NOZORDER;
1065
1066 TRACE("Layout x=%d y=%d cx=%d cy=%d\n",
1067 lpLayout->pwpos->x, lpLayout->pwpos->y,
1068 lpLayout->pwpos->cx, lpLayout->pwpos->cy);
1069
1070 infoPtr->bRectsValid = FALSE;
1071
1072 return TRUE;
1073 }
1074
1075
1076 static LRESULT
1077 HEADER_SetImageList (HWND hwnd, HIMAGELIST himl)
1078 {
1079 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
1080 HIMAGELIST himlOld;
1081
1082 TRACE("(himl 0x%x)\n", (int)himl);
1083 himlOld = infoPtr->himl;
1084 infoPtr->himl = himl;
1085
1086 /* FIXME: Refresh needed??? */
1087
1088 return (LRESULT)himlOld;
1089 }
1090
1091
1092 static LRESULT
1093 HEADER_SetItemA (HWND hwnd, WPARAM wParam, LPARAM lParam)
1094 {
1095 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
1096 HDITEMA *phdi = (HDITEMA*)lParam;
1097 INT nItem = (INT)wParam;
1098 HEADER_ITEM *lpItem;
1099
1100 if (phdi == NULL)
1101 return FALSE;
1102 if ((nItem < 0) || (nItem >= (INT)infoPtr->uNumItem))
1103 return FALSE;
1104
1105 TRACE("[nItem=%d]\n", nItem);
1106
1107 if (HEADER_SendHeaderNotify (hwnd, HDN_ITEMCHANGINGA, nItem, phdi->mask))
1108 return FALSE;
1109
1110 lpItem = &infoPtr->items[nItem];
1111 if (phdi->mask & HDI_BITMAP)
1112 lpItem->hbm = phdi->hbm;
1113
1114 if (phdi->mask & HDI_FORMAT)
1115 lpItem->fmt = phdi->fmt;
1116
1117 if (phdi->mask & HDI_LPARAM)
1118 lpItem->lParam = phdi->lParam;
1119
1120 if (phdi->mask & HDI_TEXT) {
1121 if (phdi->pszText != LPSTR_TEXTCALLBACKA) {
1122 if (lpItem->pszText) {
1123 COMCTL32_Free (lpItem->pszText);
1124 lpItem->pszText = NULL;
1125 }
1126 if (phdi->pszText) {
1127 INT len = MultiByteToWideChar (CP_ACP,0,phdi->pszText,-1,NULL,0);
1128 lpItem->pszText = COMCTL32_Alloc( len*sizeof(WCHAR) );
1129 MultiByteToWideChar (CP_ACP,0,phdi->pszText,-1,lpItem->pszText,len);
1130 }
1131 }
1132 else
1133 lpItem->pszText = LPSTR_TEXTCALLBACKW;
1134 }
1135
1136 if (phdi->mask & HDI_WIDTH)
1137 lpItem->cxy = phdi->cxy;
1138
1139 if (phdi->mask & HDI_IMAGE)
1140 lpItem->iImage = phdi->iImage;
1141
1142 if (phdi->mask & HDI_ORDER)
1143 {
1144 lpItem->iOrder = phdi->iOrder;
1145 }
1146 else
1147 lpItem->iOrder = nItem;
1148
1149 HEADER_SendHeaderNotify (hwnd, HDN_ITEMCHANGEDA, nItem, phdi->mask);
1150
1151 HEADER_SetItemBounds (hwnd);
1152
1153 InvalidateRect(hwnd, NULL, FALSE);
1154
1155 return TRUE;
1156 }
1157
1158
1159 static LRESULT
1160 HEADER_SetItemW (HWND hwnd, WPARAM wParam, LPARAM lParam)
1161 {
1162 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
1163 HDITEMW *phdi = (HDITEMW*)lParam;
1164 INT nItem = (INT)wParam;
1165 HEADER_ITEM *lpItem;
1166
1167 if (phdi == NULL)
1168 return FALSE;
1169 if ((nItem < 0) || (nItem >= (INT)infoPtr->uNumItem))
1170 return FALSE;
1171
1172 TRACE("[nItem=%d]\n", nItem);
1173
1174 if (HEADER_SendHeaderNotify (hwnd, HDN_ITEMCHANGINGW, nItem, phdi->mask))
1175 return FALSE;
1176
1177 lpItem = &infoPtr->items[nItem];
1178 if (phdi->mask & HDI_BITMAP)
1179 lpItem->hbm = phdi->hbm;
1180
1181 if (phdi->mask & HDI_FORMAT)
1182 lpItem->fmt = phdi->fmt;
1183
1184 if (phdi->mask & HDI_LPARAM)
1185 lpItem->lParam = phdi->lParam;
1186
1187 if (phdi->mask & HDI_TEXT) {
1188 if (phdi->pszText != LPSTR_TEXTCALLBACKW) {
1189 if (lpItem->pszText) {
1190 COMCTL32_Free (lpItem->pszText);
1191 lpItem->pszText = NULL;
1192 }
1193 if (phdi->pszText) {
1194 INT len = strlenW (phdi->pszText);
1195 lpItem->pszText = COMCTL32_Alloc ((len+1)*sizeof(WCHAR));
1196 strcpyW (lpItem->pszText, phdi->pszText);
1197 }
1198 }
1199 else
1200 lpItem->pszText = LPSTR_TEXTCALLBACKW;
1201 }
1202
1203 if (phdi->mask & HDI_WIDTH)
1204 lpItem->cxy = phdi->cxy;
1205
1206 if (phdi->mask & HDI_IMAGE)
1207 lpItem->iImage = phdi->iImage;
1208
1209 if (phdi->mask & HDI_ORDER)
1210 {
1211 lpItem->iOrder = phdi->iOrder;
1212 }
1213 else
1214 lpItem->iOrder = nItem;
1215
1216 HEADER_SendHeaderNotify(hwnd, HDN_ITEMCHANGINGW, nItem, phdi->mask);
1217
1218 HEADER_SetItemBounds (hwnd);
1219
1220 InvalidateRect(hwnd, NULL, FALSE);
1221
1222 return TRUE;
1223 }
1224
1225 inline static LRESULT
1226 HEADER_SetUnicodeFormat (HWND hwnd, WPARAM wParam)
1227 {
1228 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
1229 BOOL bTemp = infoPtr->bUnicode;
1230
1231 infoPtr->bUnicode = (BOOL)wParam;
1232
1233 return bTemp;
1234 }
1235
1236
1237 static LRESULT
1238 HEADER_Create (HWND hwnd, WPARAM wParam, LPARAM lParam)
1239 {
1240 HEADER_INFO *infoPtr;
1241 TEXTMETRICA tm;
1242 HFONT hOldFont;
1243 HDC hdc;
1244
1245 infoPtr = (HEADER_INFO *)COMCTL32_Alloc (sizeof(HEADER_INFO));
1246 SetWindowLongA (hwnd, 0, (DWORD)infoPtr);
1247
1248 infoPtr->hwndNotify = GetParent(hwnd);
1249 infoPtr->uNumItem = 0;
1250 infoPtr->nHeight = 20;
1251 infoPtr->hFont = 0;
1252 infoPtr->items = 0;
1253 infoPtr->bRectsValid = FALSE;
1254 infoPtr->hcurArrow = LoadCursorA (0, IDC_ARROWA);
1255 infoPtr->hcurDivider = LoadCursorA (COMCTL32_hModule, MAKEINTRESOURCEA(IDC_DIVIDER));
1256 infoPtr->hcurDivopen = LoadCursorA (COMCTL32_hModule, MAKEINTRESOURCEA(IDC_DIVIDEROPEN));
1257 infoPtr->bPressed = FALSE;
1258 infoPtr->bTracking = FALSE;
1259 infoPtr->iMoveItem = 0;
1260 infoPtr->himl = 0;
1261 infoPtr->iHotItem = -1;
1262 infoPtr->bUnicode = IsWindowUnicode (hwnd);
1263 infoPtr->nNotifyFormat =
1264 SendMessageA (infoPtr->hwndNotify, WM_NOTIFYFORMAT, (WPARAM)hwnd, NF_QUERY);
1265
1266 hdc = GetDC (0);
1267 hOldFont = SelectObject (hdc, GetStockObject (SYSTEM_FONT));
1268 GetTextMetricsA (hdc, &tm);
1269 infoPtr->nHeight = tm.tmHeight + VERT_BORDER;
1270 SelectObject (hdc, hOldFont);
1271 ReleaseDC (0, hdc);
1272
1273 return 0;
1274 }
1275
1276
1277 static LRESULT
1278 HEADER_Destroy (HWND hwnd, WPARAM wParam, LPARAM lParam)
1279 {
1280 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
1281 HEADER_ITEM *lpItem;
1282 INT nItem;
1283
1284 if (infoPtr->items) {
1285 lpItem = infoPtr->items;
1286 for (nItem = 0; nItem < infoPtr->uNumItem; nItem++, lpItem++) {
1287 if ((lpItem->pszText) && (lpItem->pszText != LPSTR_TEXTCALLBACKW))
1288 COMCTL32_Free (lpItem->pszText);
1289 }
1290 COMCTL32_Free (infoPtr->items);
1291 }
1292
1293 if (infoPtr->himl)
1294 ImageList_Destroy (infoPtr->himl);
1295
1296 COMCTL32_Free (infoPtr);
1297 SetWindowLongA (hwnd, 0, 0);
1298 return 0;
1299 }
1300
1301
1302 static inline LRESULT
1303 HEADER_GetFont (HWND hwnd)
1304 {
1305 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
1306
1307 return (LRESULT)infoPtr->hFont;
1308 }
1309
1310
1311 static LRESULT
1312 HEADER_LButtonDblClk (HWND hwnd, WPARAM wParam, LPARAM lParam)
1313 {
1314 POINT pt;
1315 UINT flags;
1316 INT nItem;
1317
1318 pt.x = (INT)LOWORD(lParam);
1319 pt.y = (INT)HIWORD(lParam);
1320 HEADER_InternalHitTest (hwnd, &pt, &flags, &nItem);
1321
1322 if ((GetWindowLongA (hwnd, GWL_STYLE) & HDS_BUTTONS) && (flags == HHT_ONHEADER))
1323 HEADER_SendHeaderNotify (hwnd, HDN_ITEMDBLCLICKA, nItem,0);
1324 else if ((flags == HHT_ONDIVIDER) || (flags == HHT_ONDIVOPEN))
1325 HEADER_SendHeaderNotify (hwnd, HDN_DIVIDERDBLCLICKA, nItem,0);
1326
1327 return 0;
1328 }
1329
1330
1331 static LRESULT
1332 HEADER_LButtonDown (HWND hwnd, WPARAM wParam, LPARAM lParam)
1333 {
1334 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
1335 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
1336 POINT pt;
1337 UINT flags;
1338 INT nItem;
1339 HDC hdc;
1340
1341 pt.x = (INT)LOWORD(lParam);
1342 pt.y = (INT)HIWORD(lParam);
1343 HEADER_InternalHitTest (hwnd, &pt, &flags, &nItem);
1344
1345 if ((dwStyle & HDS_BUTTONS) && (flags == HHT_ONHEADER)) {
1346 SetCapture (hwnd);
1347 infoPtr->bCaptured = TRUE;
1348 infoPtr->bPressed = TRUE;
1349 infoPtr->iMoveItem = nItem;
1350
1351 infoPtr->items[nItem].bDown = TRUE;
1352
1353 /* Send WM_CUSTOMDRAW */
1354 hdc = GetDC (hwnd);
1355 HEADER_RefreshItem (hwnd, hdc, nItem);
1356 ReleaseDC (hwnd, hdc);
1357
1358 TRACE("Pressed item %d!\n", nItem);
1359 }
1360 else if ((flags == HHT_ONDIVIDER) || (flags == HHT_ONDIVOPEN)) {
1361 if (!(HEADER_SendHeaderNotify (hwnd, HDN_BEGINTRACKA, nItem,0))) {
1362 SetCapture (hwnd);
1363 infoPtr->bCaptured = TRUE;
1364 infoPtr->bTracking = TRUE;
1365 infoPtr->iMoveItem = nItem;
1366 infoPtr->nOldWidth = infoPtr->items[nItem].cxy;
1367 infoPtr->xTrackOffset = infoPtr->items[nItem].rect.right - pt.x;
1368
1369 if (!(dwStyle & HDS_FULLDRAG)) {
1370 infoPtr->xOldTrack = infoPtr->items[nItem].rect.right;
1371 hdc = GetDC (hwnd);
1372 HEADER_DrawTrackLine (hwnd, hdc, infoPtr->xOldTrack);
1373 ReleaseDC (hwnd, hdc);
1374 }
1375
1376 TRACE("Begin tracking item %d!\n", nItem);
1377 }
1378 }
1379
1380 return 0;
1381 }
1382
1383
1384 static LRESULT
1385 HEADER_LButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
1386 {
1387 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
1388 /*
1389 *DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
1390 */
1391 POINT pt;
1392 UINT flags;
1393 INT nItem, nWidth;
1394 HDC hdc;
1395
1396 pt.x = (INT)SLOWORD(lParam);
1397 pt.y = (INT)SHIWORD(lParam);
1398 HEADER_InternalHitTest (hwnd, &pt, &flags, &nItem);
1399
1400 if (infoPtr->bPressed) {
1401 if ((nItem == infoPtr->iMoveItem) && (flags == HHT_ONHEADER)) {
1402 infoPtr->items[infoPtr->iMoveItem].bDown = FALSE;
1403 hdc = GetDC (hwnd);
1404 HEADER_RefreshItem (hwnd, hdc, infoPtr->iMoveItem);
1405 ReleaseDC (hwnd, hdc);
1406
1407 HEADER_SendClickNotify (hwnd, HDN_ITEMCLICKA, infoPtr->iMoveItem);
1408 }
1409 else if (flags == HHT_ONHEADER)
1410 {
1411 HEADER_ITEM *lpItem;
1412 INT newindex = HEADER_IndexToOrder(hwnd,nItem);
1413 INT oldindex = HEADER_IndexToOrder(hwnd,infoPtr->iMoveItem);
1414
1415 TRACE("Exchanging [index:order] [%d:%d] [%d:%d]\n",
1416 infoPtr->iMoveItem,oldindex,nItem,newindex);
1417 lpItem= &infoPtr->items[nItem];
1418 lpItem->iOrder=oldindex;
1419
1420 lpItem= &infoPtr->items[infoPtr->iMoveItem];
1421 lpItem->iOrder = newindex;
1422
1423 infoPtr->bRectsValid = FALSE;
1424 InvalidateRect(hwnd, NULL, FALSE);
1425 /* FIXME: Should some WM_NOTIFY be sent */
1426 }
1427
1428 TRACE("Released item %d!\n", infoPtr->iMoveItem);
1429 infoPtr->bPressed = FALSE;
1430 }
1431 else if (infoPtr->bTracking) {
1432 TRACE("End tracking item %d!\n", infoPtr->iMoveItem);
1433 infoPtr->bTracking = FALSE;
1434
1435 HEADER_SendHeaderNotify (hwnd, HDN_ENDTRACKA, infoPtr->iMoveItem,HDI_WIDTH);
1436
1437 /*
1438 * we want to do this even for HDS_FULLDRAG because this is where
1439 * we send the HDN_ITEMCHANGING and HDN_ITEMCHANGED notifications
1440 *
1441 * if (!(dwStyle & HDS_FULLDRAG)) {
1442 */
1443
1444 hdc = GetDC (hwnd);
1445 HEADER_DrawTrackLine (hwnd, hdc, infoPtr->xOldTrack);
1446 ReleaseDC (hwnd, hdc);
1447 if (HEADER_SendHeaderNotify(hwnd, HDN_ITEMCHANGINGA, infoPtr->iMoveItem, HDI_WIDTH))
1448 {
1449 infoPtr->items[infoPtr->iMoveItem].cxy = infoPtr->nOldWidth;
1450 }
1451 else {
1452 nWidth = pt.x - infoPtr->items[infoPtr->iMoveItem].rect.left + infoPtr->xTrackOffset;
1453 if (nWidth < 0)
1454 nWidth = 0;
1455 infoPtr->items[infoPtr->iMoveItem].cxy = nWidth;
1456 }
1457
1458 HEADER_SendHeaderNotify(hwnd, HDN_ITEMCHANGINGA, infoPtr->iMoveItem, HDI_WIDTH);
1459 HEADER_SetItemBounds (hwnd);
1460 InvalidateRect(hwnd, NULL, FALSE);
1461 /*
1462 * }
1463 */
1464 }
1465
1466 if (infoPtr->bCaptured) {
1467 infoPtr->bCaptured = FALSE;
1468 ReleaseCapture ();
1469 HEADER_SendSimpleNotify (hwnd, NM_RELEASEDCAPTURE);
1470 }
1471
1472 return 0;
1473 }
1474
1475
1476 static LRESULT
1477 HEADER_NotifyFormat (HWND hwnd, WPARAM wParam, LPARAM lParam)
1478 {
1479 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
1480
1481 switch (lParam)
1482 {
1483 case NF_QUERY:
1484 return infoPtr->nNotifyFormat;
1485
1486 case NF_REQUERY:
1487 infoPtr->nNotifyFormat =
1488 SendMessageA ((HWND)wParam, WM_NOTIFYFORMAT,
1489 (WPARAM)hwnd, (LPARAM)NF_QUERY);
1490 return infoPtr->nNotifyFormat;
1491 }
1492
1493 return 0;
1494 }
1495
1496
1497 static LRESULT
1498 HEADER_MouseMove (HWND hwnd, WPARAM wParam, LPARAM lParam)
1499 {
1500 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
1501 DWORD dwStyle = GetWindowLongA (hwnd, GWL_STYLE);
1502 POINT pt;
1503 UINT flags;
1504 INT nItem, nWidth;
1505 HDC hdc;
1506
1507 pt.x = (INT)SLOWORD(lParam);
1508 pt.y = (INT)SHIWORD(lParam);
1509 HEADER_InternalHitTest (hwnd, &pt, &flags, &nItem);
1510
1511 if ((dwStyle & HDS_BUTTONS) && (dwStyle & HDS_HOTTRACK)) {
1512 if (flags & (HHT_ONHEADER | HHT_ONDIVIDER | HHT_ONDIVOPEN))
1513 infoPtr->iHotItem = nItem;
1514 else
1515 infoPtr->iHotItem = -1;
1516 InvalidateRect(hwnd, NULL, FALSE);
1517 }
1518
1519 if (infoPtr->bCaptured) {
1520 if (infoPtr->bPressed) {
1521 if ((nItem == infoPtr->iMoveItem) && (flags == HHT_ONHEADER))
1522 infoPtr->items[infoPtr->iMoveItem].bDown = TRUE;
1523 else
1524 infoPtr->items[infoPtr->iMoveItem].bDown = FALSE;
1525 hdc = GetDC (hwnd);
1526 HEADER_RefreshItem (hwnd, hdc, infoPtr->iMoveItem);
1527 ReleaseDC (hwnd, hdc);
1528
1529 TRACE("Moving pressed item %d!\n", infoPtr->iMoveItem);
1530 }
1531 else if (infoPtr->bTracking) {
1532 if (dwStyle & HDS_FULLDRAG) {
1533 if (HEADER_SendHeaderNotify (hwnd, HDN_ITEMCHANGINGA, infoPtr->iMoveItem, HDI_WIDTH))
1534 {
1535 nWidth = pt.x - infoPtr->items[infoPtr->iMoveItem].rect.left + infoPtr->xTrackOffset;
1536 if (nWidth < 0)
1537 nWidth = 0;
1538 infoPtr->items[infoPtr->iMoveItem].cxy = nWidth;
1539 HEADER_SendHeaderNotify(hwnd, HDN_ITEMCHANGEDA, infoPtr->iMoveItem, HDI_WIDTH);
1540 }
1541 HEADER_SetItemBounds (hwnd);
1542 InvalidateRect(hwnd, NULL, FALSE);
1543 }
1544 else {
1545 hdc = GetDC (hwnd);
1546 HEADER_DrawTrackLine (hwnd, hdc, infoPtr->xOldTrack);
1547 infoPtr->xOldTrack = pt.x + infoPtr->xTrackOffset;
1548 if (infoPtr->xOldTrack < infoPtr->items[infoPtr->iMoveItem].rect.left)
1549 infoPtr->xOldTrack = infoPtr->items[infoPtr->iMoveItem].rect.left;
1550 infoPtr->items[infoPtr->iMoveItem].cxy =
1551 infoPtr->xOldTrack - infoPtr->items[infoPtr->iMoveItem].rect.left;
1552 HEADER_DrawTrackLine (hwnd, hdc, infoPtr->xOldTrack);
1553 ReleaseDC (hwnd, hdc);
1554 HEADER_SendHeaderNotify (hwnd, HDN_TRACKA, infoPtr->iMoveItem, HDI_WIDTH);
1555 }
1556
1557 TRACE("Tracking item %d!\n", infoPtr->iMoveItem);
1558 }
1559 }
1560
1561 if ((dwStyle & HDS_BUTTONS) && (dwStyle & HDS_HOTTRACK)) {
1562 FIXME("hot track support!\n");
1563 }
1564
1565 return 0;
1566 }
1567
1568
1569 static LRESULT
1570 HEADER_Paint (HWND hwnd, WPARAM wParam)
1571 {
1572 HDC hdc;
1573 PAINTSTRUCT ps;
1574
1575 hdc = wParam==0 ? BeginPaint (hwnd, &ps) : (HDC)wParam;
1576 HEADER_Refresh (hwnd, hdc);
1577 if(!wParam)
1578 EndPaint (hwnd, &ps);
1579 return 0;
1580 }
1581
1582
1583 static LRESULT
1584 HEADER_RButtonUp (HWND hwnd, WPARAM wParam, LPARAM lParam)
1585 {
1586 BOOL bRet;
1587 POINT pt;
1588
1589 pt.x = LOWORD(lParam);
1590 pt.y = HIWORD(lParam);
1591
1592 /* Send a Notify message */
1593 bRet = HEADER_SendSimpleNotify (hwnd, NM_RCLICK);
1594
1595 /* Change to screen coordinate for WM_CONTEXTMENU */
1596 ClientToScreen(hwnd, &pt);
1597
1598 /* Send a WM_CONTEXTMENU message in response to the RBUTTONUP */
1599 SendMessageA( hwnd, WM_CONTEXTMENU, (WPARAM) hwnd, MAKELPARAM(pt.x, pt.y));
1600
1601 return bRet;
1602 }
1603
1604
1605 static LRESULT
1606 HEADER_SetCursor (HWND hwnd, WPARAM wParam, LPARAM lParam)
1607 {
1608 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
1609 POINT pt;
1610 UINT flags;
1611 INT nItem;
1612
1613 TRACE("code=0x%X id=0x%X\n", LOWORD(lParam), HIWORD(lParam));
1614
1615 GetCursorPos (&pt);
1616 ScreenToClient (hwnd, &pt);
1617
1618 HEADER_InternalHitTest (hwnd, &pt, &flags, &nItem);
1619
1620 if (flags == HHT_ONDIVIDER)
1621 SetCursor (infoPtr->hcurDivider);
1622 else if (flags == HHT_ONDIVOPEN)
1623 SetCursor (infoPtr->hcurDivopen);
1624 else
1625 SetCursor (infoPtr->hcurArrow);
1626
1627 return 0;
1628 }
1629
1630
1631 static LRESULT
1632 HEADER_SetFont (HWND hwnd, WPARAM wParam, LPARAM lParam)
1633 {
1634 HEADER_INFO *infoPtr = HEADER_GetInfoPtr (hwnd);
1635 TEXTMETRICA tm;
1636 HFONT hFont, hOldFont;
1637 HDC hdc;
1638
1639 infoPtr->hFont = (HFONT)wParam;
1640
1641 hFont = infoPtr->hFont ? infoPtr->hFont : GetStockObject (SYSTEM_FONT);
1642
1643 hdc = GetDC (0);
1644 hOldFont = SelectObject (hdc, hFont);
1645 GetTextMetricsA (hdc, &tm);
1646 infoPtr->nHeight = tm.tmHeight + VERT_BORDER;
1647 SelectObject (hdc, hOldFont);
1648 ReleaseDC (0, hdc);
1649
1650 infoPtr->bRectsValid = FALSE;
1651
1652 if (lParam) {
1653 InvalidateRect(hwnd, NULL, FALSE);
1654 }
1655
1656 return 0;
1657 }
1658
1659
1660 static LRESULT WINAPI
1661 HEADER_WindowProc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
1662 {
1663 TRACE("hwnd=%x msg=%x wparam=%x lParam=%lx\n", hwnd, msg, wParam, lParam);
1664 if (!HEADER_GetInfoPtr (hwnd) && (msg != WM_CREATE))
1665 return DefWindowProcA (hwnd, msg, wParam, lParam);
1666 switch (msg) {
1667 /* case HDM_CLEARFILTER: */
1668
1669 case HDM_CREATEDRAGIMAGE:
1670 return HEADER_CreateDragImage (hwnd, wParam);
1671
1672 case HDM_DELETEITEM:
1673 return HEADER_DeleteItem (hwnd, wParam);
1674
1675 /* case HDM_EDITFILTER: */
1676
1677 /* case HDM_GETBITMAPMARGIN: */
1678
1679 case HDM_GETIMAGELIST:
1680 return HEADER_GetImageList (hwnd);
1681
1682 case HDM_GETITEMA:
1683 return HEADER_GetItemA (hwnd, wParam, lParam);
1684
1685 case HDM_GETITEMW:
1686 return HEADER_GetItemW (hwnd, wParam, lParam);
1687
1688 case HDM_GETITEMCOUNT:
1689 return HEADER_GetItemCount (hwnd);
1690
1691 case HDM_GETITEMRECT:
1692 return HEADER_GetItemRect (hwnd, wParam, lParam);
1693
1694 case HDM_GETORDERARRAY:
1695 return HEADER_GetOrderArray(hwnd, wParam, lParam);
1696
1697 case HDM_GETUNICODEFORMAT:
1698 return HEADER_GetUnicodeFormat (hwnd);
1699
1700 case HDM_HITTEST:
1701 return HEADER_HitTest (hwnd, wParam, lParam);
1702
1703 case HDM_INSERTITEMA:
1704 return HEADER_InsertItemA (hwnd, wParam, lParam);
1705
1706 case HDM_INSERTITEMW:
1707 return HEADER_InsertItemW (hwnd, wParam, lParam);
1708
1709 case HDM_LAYOUT:
1710 return HEADER_Layout (hwnd, wParam, lParam);
1711
1712 case HDM_ORDERTOINDEX:
1713 return HEADER_OrderToIndex(hwnd, wParam);
1714
1715 /* case HDM_SETBITMAPMARGIN: */
1716
1717 /* case HDM_SETFILTERCHANGETIMEOUT: */
1718
1719 /* case HDM_SETHOTDIVIDER: */
1720
1721 case HDM_SETIMAGELIST:
1722 return HEADER_SetImageList (hwnd, (HIMAGELIST)lParam);
1723
1724 case HDM_SETITEMA:
1725 return HEADER_SetItemA (hwnd, wParam, lParam);
1726
1727 case HDM_SETITEMW:
1728 return HEADER_SetItemW (hwnd, wParam, lParam);
1729
1730 case HDM_SETORDERARRAY:
1731 return HEADER_SetOrderArray(hwnd, wParam, lParam);
1732
1733 case HDM_SETUNICODEFORMAT:
1734 return HEADER_SetUnicodeFormat (hwnd, wParam);
1735
1736 case WM_CREATE:
1737 return HEADER_Create (hwnd, wParam, lParam);
1738
1739 case WM_DESTROY:
1740 return HEADER_Destroy (hwnd, wParam, lParam);
1741
1742 case WM_ERASEBKGND:
1743 return 1;
1744
1745 case WM_GETDLGCODE:
1746 return DLGC_WANTTAB | DLGC_WANTARROWS;
1747
1748 case WM_GETFONT:
1749 return HEADER_GetFont (hwnd);
1750
1751 case WM_LBUTTONDBLCLK:
1752 return HEADER_LButtonDblClk (hwnd, wParam, lParam);
1753
1754 case WM_LBUTTONDOWN:
1755 return HEADER_LButtonDown (hwnd, wParam, lParam);
1756
1757 case WM_LBUTTONUP:
1758 return HEADER_LButtonUp (hwnd, wParam, lParam);
1759
1760 case WM_MOUSEMOVE:
1761 return HEADER_MouseMove (hwnd, wParam, lParam);
1762
1763 case WM_NOTIFYFORMAT:
1764 return HEADER_NotifyFormat (hwnd, wParam, lParam);
1765
1766 case WM_SIZE:
1767 return HEADER_Size (hwnd, wParam);
1768
1769 case WM_PAINT:
1770 return HEADER_Paint (hwnd, wParam);
1771
1772 case WM_RBUTTONUP:
1773 return HEADER_RButtonUp (hwnd, wParam, lParam);
1774
1775 case WM_SETCURSOR:
1776 return HEADER_SetCursor (hwnd, wParam, lParam);
1777
1778 case WM_SETFONT:
1779 return HEADER_SetFont (hwnd, wParam, lParam);
1780
1781 default:
1782 if ((msg >= WM_USER) && (msg < WM_APP))
1783 ERR("unknown msg %04x wp=%04x lp=%08lx\n",
1784 msg, wParam, lParam );
1785 return DefWindowProcA (hwnd, msg, wParam, lParam);
1786 }
1787 return 0;
1788 }
1789
1790
1791 VOID
1792 HEADER_Register (void)
1793 {
1794 WNDCLASSA wndClass;
1795
1796 ZeroMemory (&wndClass, sizeof(WNDCLASSA));
1797 wndClass.style = CS_GLOBALCLASS | CS_DBLCLKS;
1798 wndClass.lpfnWndProc = (WNDPROC)HEADER_WindowProc;
1799 wndClass.cbClsExtra = 0;
1800 wndClass.cbWndExtra = sizeof(HEADER_INFO *);
1801 wndClass.hCursor = LoadCursorA (0, IDC_ARROWA);
1802 wndClass.lpszClassName = WC_HEADERA;
1803
1804 RegisterClassA (&wndClass);
1805 }
1806
1807
1808 VOID
1809 HEADER_Unregister (void)
1810 {
1811 UnregisterClassA (WC_HEADERA, (HINSTANCE)NULL);
1812 }
widl and rpcrt4 development