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