![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to bitmap.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / netwatch|
Return to bitmap.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / netwatch |
1.1 root 1: /*
2: * Bitmap.c
3: *
4: * Purpose:
5: * bitmap and listbox support functions for netwatch.exe
6: *
7: * Owner:
8: * MikeSart
9: */
10: #define UNICODE 1
11:
12: #include <windows.h>
13: #include <windowsx.h>
14: #include "netwatch.h"
15: #include "rcids.h"
16:
17: /*
18: * function prototypes
19: */
20: void DeleteBitmapLB(void);
21:
22: /*
23: * globals
24: */
25: DWORD rgbWindowColor = 0xFF000000; // variables for the current
26: DWORD rgbHiliteColor = 0xFF000000; // system color settings.
27: DWORD rgbWindowText = 0xFF000000; // on a WM_SYSCOLORCHANGE
28: DWORD rgbHiliteText = 0xFF000000; // we check to see if we need
29: DWORD rgbGrayText = 0xFF000000; // to reload our bitmap.
30: DWORD rgbDDWindow = 0xFF000000; //
31: DWORD rgbDDHilite = 0xFF000000; // 0xFF000000 is an invalid RGB
32:
33: // an array of integers containing the tab stops, in pixels. The tab
34: // stops must be sorted in ascending order; back tabs are not allowed.
35: int rgTabs[] = { 2, 20, 38, 56, 74 };
36:
37: // font style of font to use in listbox
38: typedef struct
39: {
40: int lfHeight;
41: int lfWeight;
42: BYTE lfItalic;
43: TCHAR lfFaceName[LF_FACESIZE];
44: } FONTSTYLE;
45:
46: FONTSTYLE fontStyle = { 8, FW_NORMAL, 0, TEXT("MS Sans Serif") };
47:
48: int dxbmpLB, dybmpLB; // dx and dy of listbox bmps
49:
50: HDC hdcMemory = NULL; // hdc to hold listbox bitmaps (for speed)
51:
52: HBITMAP hbmpOrigMemBmp = NULL; // original null bitmap in hdcMemory
53: HBITMAP hbmpLB = NULL; // cached listbox bitmaps
54:
55: HFONT hfontLB = NULL; // hfont of LB
56: HWND hwndLB = NULL; // hwnd of LB
57:
58: /*
59: * DeInitBmps
60: *
61: * Purpose:
62: * cleans up LB hfonts, hdc, and hbmps
63: *
64: * Arguments:
65: *
66: * Returns:
67: * hopefully
68: */
69: VOID
70: DeInitBmps(VOID)
71: {
72: DeleteBitmapLB();
73: if(hdcMemory)
74: {
75: DeleteDC(hdcMemory);
76: hdcMemory = NULL;
77: }
78:
79: if(hfontLB)
80: {
81: SetWindowFont(hwndLB, GetStockObject(SYSTEM_FONT), FALSE);
82: DeleteObject(hfontLB);
83: hfontLB = NULL;
84: }
85: }
86:
87: /*
88: * SetLBFont
89: *
90: * Purpose:
91: * creates a font from the global fontStyle
92: * sets global hfontLB to new font and WM_SETFONTs
93: * the hwndLB to the new font
94: *
95: * Arguments:
96: *
97: * Returns:
98: * yep
99: */
100: VOID
101: SetLBFont(VOID)
102: {
103: LOGFONT lf;
104:
105: lf.lfHeight = fontStyle.lfHeight;
106: lf.lfWidth = 0;
107: lf.lfEscapement = 0;
108: lf.lfOrientation = 0;
109: lf.lfWeight = fontStyle.lfWeight;
110: lf.lfItalic = fontStyle.lfItalic;
111: lf.lfUnderline = 0;
112: lf.lfStrikeOut = 0;
113: lf.lfCharSet = ANSI_CHARSET;
114: lf.lfOutPrecision = OUT_DEFAULT_PRECIS;
115: lf.lfClipPrecision = CLIP_DEFAULT_PRECIS;
116: lf.lfQuality = DEFAULT_QUALITY;
117: lf.lfPitchAndFamily = DEFAULT_PITCH | FF_SWISS;
118: lstrcpy(lf.lfFaceName, fontStyle.lfFaceName);
119:
120: hfontLB = CreateFontIndirect(&lf);
121: if(hfontLB)
122: SetWindowFont(hwndLB, hfontLB, FALSE);
123: }
124:
125: /*
126: * InitBmps
127: *
128: * Purpose:
129: * inits listbox globals, creates listbox
130: *
131: * Arguments:
132: * HWND main hwnd of app (parent of LB)
133: *
134: * Returns:
135: * TRUE - success; FALSE - failed
136: */
137: BOOL
138: InitBmps(HWND hwnd)
139: {
140: HDC hdcScreen;
141: HBITMAP hbmpTemp;
142:
143: hdcScreen = GetDC(NULL);
144: if(!hdcScreen)
145: goto CantInit;
146: hdcMemory = CreateCompatibleDC(hdcScreen);
147: if(!hdcMemory)
148: goto ReleaseScreenDC;
149:
150: hbmpTemp = CreateCompatibleBitmap(hdcMemory, 1, 1);
151: if(!hbmpTemp)
152: goto ReleaseMemDC;
153: hbmpOrigMemBmp = SelectObject(hdcMemory, hbmpTemp); // get hbmp of NULL
154: if(!hbmpOrigMemBmp) // bmp for hdcMemory
155: goto ReleaseMemDC; // for when we delete
156: SelectObject(hdcMemory, hbmpOrigMemBmp); // it later in life
157: DeleteObject(hbmpTemp);
158: ReleaseDC(NULL, hdcScreen);
159:
160: SetRGBValues(); // set the global RGB values
161: LoadBitmapLB(); // load the bmps into hdcMemory
162:
163: hwndLB = CreateWindow(TEXT("listbox"), NULL,
164: WS_CHILD | WS_VISIBLE | LBS_NOTIFY | LBS_NOINTEGRALHEIGHT |
165: WS_VSCROLL | LBS_WANTKEYBOARDINPUT | LBS_HASSTRINGS |
166: LBS_OWNERDRAWFIXED,
167: 0, 0, 0, 0, hwnd, (HMENU)IDD_lstSHARES, ghInst, NULL);
168:
169: SetLBFont(); // set the font of our listbox
170: return TRUE;
171:
172: /* Error recovery exits */
173: ReleaseMemDC:
174: DeleteDC(hdcMemory);
175: hdcMemory = NULL;
176:
177: ReleaseScreenDC:
178: ReleaseDC(NULL, hdcScreen);
179:
180: CantInit:
181: return FALSE;
182: }
183:
184: /*
185: * SetRGBValues
186: *
187: * Purpose:
188: * To set various system colors in static variables. Called at
189: * init time and when system colors change.
190: *
191: * Arguments:
192: *
193: * Returns:
194: * Yes
195: */
196: VOID
197: SetRGBValues(VOID)
198: {
199: rgbWindowColor = GetSysColor(COLOR_WINDOW);
200: rgbHiliteColor = GetSysColor(COLOR_HIGHLIGHT);
201: rgbWindowText = GetSysColor(COLOR_WINDOWTEXT);
202: rgbHiliteText = GetSysColor(COLOR_HIGHLIGHTTEXT);
203: rgbGrayText = GetSysColor(COLOR_GRAYTEXT);
204: }
205:
206: /*
207: * MeasureItem
208: *
209: * Purpose:
210: * called from msg WM_MEASUREITEM: returns max dy of listbox items
211: *
212: * Arguments:
213: * HWND hwnd of main window
214: * pmis measureitemstruct from WM_MEASUREITEM call
215: *
216: * Returns:
217: * uh huh
218: */
219: VOID
220: MeasureItem(HANDLE hwnd, LPMEASUREITEMSTRUCT pmis)
221: {
222: HDC hDC = GetDC(hwnd);
223: HANDLE hFont = hfontLB;
224: TEXTMETRIC TM;
225:
226: if(!hFont)
227: hFont = GetStockObject(SYSTEM_FONT);
228: hFont = SelectObject(hDC, hFont);
229: GetTextMetrics(hDC, &TM);
230: SelectObject(hDC, hFont);
231: ReleaseDC(hwnd, hDC);
232:
233: // set the height to be max of (dyfont or dybitmap)
234: pmis->itemHeight = max(dybmpLB, TM.tmHeight);
235: }
236:
237: /*
238: * OutTextFormat
239: *
240: * Purpose:
241: * to parse the string in the listbox and draw it accordingly:
242: * first char == chBOLD: line is bold
243: * first char == chUNDERLINE: line is underlined (can follow chBOLD)
244: * char == chTAB: go to next column in rgTabs
245: * '/001#': bitblt that numbered bitmap.
246: * otherwise, outtext the line
247: *
248: * Arguments:
249: * pDI from DrawItem from WM_DRAWITEM msg
250: *
251: * Returns:
252: * yessir
253: */
254: VOID
255: OutTextFormat(LPDRAWITEMSTRUCT pDI)
256: {
257: static TCHAR szItem[60];
258: TCHAR *pch;
259: INT nT;
260: INT nTab = 0; // current tab we is on
261: HFONT hfDef = NULL;
262: HFONT hfOld = NULL; // bold or underlined font
263: TCHAR *pchBuff = NULL;
264:
265: nT = (ListBox_GetTextLen(pDI->hwndItem, pDI->itemID) + 1) * sizeof(TCHAR);
266: if(nT == LB_ERR)
267: return;
268:
269: // if our quick buffer is big enough
270: if(nT > (sizeof(szItem) / sizeof(TCHAR)))
271: {
272: pchBuff = GlobalAllocPtr(GHND, nT);
273: if(!pchBuff)
274: return;
275: pch = pchBuff;
276: }
277: else
278: {
279: pch = szItem;
280: }
281:
282: //Get the text string for this item
283: ListBox_GetText(pDI->hwndItem, pDI->itemID, pch);
284:
285: // erase background
286: ExtTextOut(pDI->hDC, 0, 0, ETO_OPAQUE, &pDI->rcItem, NULL, 0, NULL);
287:
288: // underline or bold this line? Only check first & second char
289: if(*pch == chBOLD || *pch == chUNDERLINE)
290: {
291: LOGFONT lf;
292:
293: hfOld = GetWindowFont(pDI->hwndItem);
294: if(!hfOld)
295: hfOld = GetStockObject(SYSTEM_FONT);
296: GetObject(hfOld, sizeof(lf), &lf);
297:
298: if(*pch == chBOLD)
299: {
300: lf.lfWeight = FW_BOLD;
301: pch++;
302: }
303: if(*pch == chUNDERLINE)
304: {
305: lf.lfUnderline = TRUE;
306: pch++;
307: }
308:
309: hfDef = CreateFontIndirect(&lf);
310: if(hfDef)
311: SelectObject(pDI->hDC, hfDef);
312: }
313:
314: // selected or nonselected bmps?
315: nT = (ODS_SELECTED & pDI->itemState) ? (BMWIDTH * NUMBMPS) : 0;
316:
317: // parse the string
318: for(; *pch; pch++)
319: {
320: TCHAR *pchT;
321: RECT rc;
322:
323: if(*pch == chBITMAP) // do we have a bitmap?
324: {
325: ++pch;
326: // draw the bitmap
327: BitBlt(pDI->hDC, pDI->rcItem.left + rgTabs[nTab],
328: pDI->rcItem.top, BMWIDTH, BMHEIGHT, hdcMemory,
329: nT + (int)(*pch - TEXT('0')) * BMWIDTH, 0, SRCCOPY);
330: continue;
331: }
332:
333: if(*pch == chTAB) // move to next tabstop?
334: {
335: nTab++;
336: continue;
337: }
338:
339: pchT = pch; // find end of the column of text
340: while(*pchT && (*pchT != chTAB))
341: pchT++;
342:
343: // set rect to drawtext in
344: SetRect(&rc, pDI->rcItem.left + rgTabs[nTab], pDI->rcItem.top,
345: pDI->rcItem.right, pDI->rcItem.bottom);
346:
347: // draw the text
348: ExtTextOut(pDI->hDC, rc.left, rc.top + 1, ETO_OPAQUE | ETO_CLIPPED,
349: &rc, pch, pchT - pch, NULL);
350: pch = pchT - 1; // move to end of this column
351: }
352:
353: if(hfDef) // delete underline or bold font if we created it
354: {
355: SelectObject(pDI->hDC, hfOld);
356: DeleteObject(hfDef);
357: }
358:
359: GlobalFreeNullPtr(pchBuff);
360: }
361:
362: /*
363: * DrawItem
364: *
365: * Purpose:
366: * Handles WM_DRAWITEM for both drive and directory listboxes.
367: *
368: * Parameters:
369: * pDI LPDRAWITEMSTRUCT passed from the WM_DRAWITEM message.
370: *
371: * Return Value:
372: * ya
373: */
374: VOID
375: DrawItem(LPDRAWITEMSTRUCT pDI)
376: {
377: COLORREF crText, crBack;
378:
379: if((int)pDI->itemID < 0)
380: return;
381:
382: if((ODA_DRAWENTIRE | ODA_SELECT) & pDI->itemAction)
383: {
384: if(pDI->itemState & ODS_SELECTED)
385: {
386: // Select the appropriate text colors
387: crText = SetTextColor(pDI->hDC, rgbHiliteText);
388: crBack = SetBkColor(pDI->hDC, rgbHiliteColor);
389: }
390:
391: // parse and spit out bmps and text
392: OutTextFormat(pDI);
393:
394: // Restore original colors if we changed them above.
395: if(pDI->itemState & ODS_SELECTED)
396: {
397: SetTextColor(pDI->hDC, crText);
398: SetBkColor(pDI->hDC, crBack);
399: }
400: }
401:
402: if((ODA_FOCUS & pDI->itemAction) || (ODS_FOCUS & pDI->itemState))
403: DrawFocusRect(pDI->hDC, &pDI->rcItem);
404: }
405:
406: /*
407: * RgbInvertRgb
408: *
409: * Purpose:
410: * To reverse the byte order of the RGB value (for file format
411: *
412: * Arguments:
413: *
414: * Returns:
415: * New color value (RGB to BGR)
416: */
417: #define RgbInvertRgb(_rgbOld) \
418: (LONG)RGB(GetBValue(_rgbOld), GetGValue(_rgbOld), GetRValue(_rgbOld))
419:
420: /*
421: * LoadAlterBitmap (mostly stolen from commdlg)
422: *
423: * Purpose:
424: * Loads the IDB_LB bitmap and gives all the pixels that are
425: * RGBREPLACE a new color.
426: *
427: * Assumption:
428: * This function will work on one bitmap during it's lifetime.
429: * (Due to the fact that it finds RGBREPLACE once and then
430: * operates on that offset whenever called again because under NT,
431: * it appears that the bitmap is cached, so the second time you go
432: * looking for RGBREPLACE, it won't be found.) You could load the
433: * resource, copy it, then modify the copy as a workaround. But I
434: * chose the cheap way out as I will only ever modify one bmp.
435: *
436: * Arguments:
437: * rgbInstead rgb value to replace defined RGBREPLACE with
438: *
439: * Returns:
440: * NULL - failed or hbmp of new modified bitmap
441: */
442: HBITMAP
443: LoadAlterBitmap(DWORD rgbInstead)
444: {
445: static WORD qlng = 0; // offset into color table
446: HANDLE hbmp = NULL;
447: LPBITMAPINFOHEADER qbihInfo;
448: HDC hdcScreen;
449: HANDLE hresLoad;
450: HANDLE hres;
451: LPBYTE qbBits;
452: DWORD rgbReplace;
453:
454: // load our listbox bmps resource
455: hresLoad = FindResource(ghInst, MAKEINTRESOURCE(IDB_LB), RT_BITMAP);
456: if(hresLoad == NULL)
457: return NULL;
458: hres = LoadResource(ghInst, hresLoad);
459: if(hres == NULL)
460: return NULL;
461:
462: rgbReplace = RgbInvertRgb(RGBREPLACE);
463: rgbInstead = RgbInvertRgb(rgbInstead);
464: qbihInfo = (LPBITMAPINFOHEADER)LockResource(hres);
465:
466: // if we haven't found the color offset yet, find it
467: if(!qlng)
468: {
469: for(qlng = (WORD)qbihInfo->biSize; ; qlng += sizeof(DWORD))
470: {
471: if(*((LPBYTE)(qbihInfo) + qlng) == rgbReplace)
472: break;
473: }
474: }
475:
476: // replace that color value with our new one
477: *(DWORD *)((LPBYTE)(qbihInfo) + qlng) = (DWORD)rgbInstead;
478:
479: // Skip over the header structure
480: qbBits = (LPBYTE)(qbihInfo + 1);
481:
482: // Skip the color table entries, if any
483: qbBits += (1 << (qbihInfo->biBitCount)) * sizeof(RGBQUAD);
484:
485: // Create a color bitmap compatible with the display device
486: hdcScreen = GetDC(NULL);
487: if(hdcScreen != NULL)
488: {
489: hbmp = CreateDIBitmap(hdcScreen, qbihInfo, (LONG)CBM_INIT,
490: qbBits, (LPBITMAPINFO) qbihInfo, DIB_RGB_COLORS);
491: ReleaseDC(NULL, hdcScreen);
492: }
493:
494: UnlockResource(hres);
495: FreeResource(hres);
496:
497: return hbmp;
498: }
499:
500: /*
501: * DeleteBitmapLB
502: *
503: * Purpose:
504: * Get rid of hbmpLB, if it exists
505: *
506: * Arguments:
507: *
508: * Returns:
509: * Si senor
510: */
511: VOID
512: DeleteBitmapLB(VOID)
513: {
514: if(hbmpOrigMemBmp)
515: {
516: SelectObject(hdcMemory, hbmpOrigMemBmp);
517: if(hbmpLB != NULL)
518: {
519: DeleteObject(hbmpLB);
520: hbmpLB = NULL;
521: }
522: }
523: }
524:
525: /*
526: * LoadBitmapLB (mostly stolen from commdlg)
527: *
528: * Purpose:
529: * Creates the listbox bitmap. If an appropriate bitmap
530: * already exists, it just returns immediately. Otherwise, it
531: * loads the bitmap and creates a larger bitmap with both regular
532: * and highlight colors.
533: *
534: * Arguments:
535: *
536: * Returns:
537: * TRUE - success; FALSE - failure
538: */
539: BOOL
540: LoadBitmapLB(VOID)
541: {
542: BITMAP bmp;
543: HANDLE hbmp, hbmpOrig;
544: HDC hdcTemp;
545: BOOL bWorked = FALSE;
546:
547: // check for existing bitmap and validity
548: if( (hbmpLB != NULL) &&
549: (rgbWindowColor == rgbDDWindow) &&
550: (rgbHiliteColor == rgbDDHilite))
551: {
552: if(SelectObject(hdcMemory, hbmpLB))
553: return TRUE;
554: }
555:
556: DeleteBitmapLB();
557:
558: rgbDDWindow = rgbWindowColor;
559: rgbDDHilite = rgbHiliteColor;
560:
561: if(!(hdcTemp = CreateCompatibleDC(hdcMemory)))
562: goto LoadExit;
563:
564: if(!(hbmp = LoadAlterBitmap(rgbWindowColor)))
565: goto DeleteTempDC;
566:
567: GetObject(hbmp, sizeof(BITMAP), (LPBYTE) &bmp);
568: dybmpLB = bmp.bmHeight;
569: dxbmpLB = bmp.bmWidth;
570:
571: hbmpOrig = SelectObject(hdcTemp, hbmp);
572:
573: hbmpLB = CreateDiscardableBitmap(hdcTemp, dxbmpLB*2, dybmpLB);
574: if(!hbmpLB)
575: goto DeleteTempBmp;
576:
577: if(!SelectObject(hdcMemory, hbmpLB))
578: {
579: DeleteBitmapLB();
580: goto DeleteTempBmp;
581: }
582:
583: BitBlt(hdcMemory, 0, 0, dxbmpLB, dybmpLB, // copy unhighlited bmps
584: hdcTemp, 0, 0, SRCCOPY); // into hdcMemory
585: SelectObject(hdcTemp, hbmpOrig);
586:
587: DeleteObject(hbmp);
588:
589: if(!(hbmp = LoadAlterBitmap(rgbHiliteColor)))
590: goto DeleteTempDC;
591:
592: hbmpOrig = SelectObject(hdcTemp, hbmp);
593: BitBlt(hdcMemory, dxbmpLB, 0, dxbmpLB, dybmpLB, // copy highlited bmps
594: hdcTemp, 0, 0, SRCCOPY); // into hdcMemory
595: SelectObject(hdcTemp, hbmpOrig);
596:
597: bWorked = TRUE;
598:
599: DeleteTempBmp:
600: DeleteObject(hbmp);
601: DeleteTempDC:
602: DeleteDC(hdcTemp);
603: LoadExit:
604: return bWorked;
605: }
606:
607: void
608: BlitIcon(HDC hdc, LONG x, LONG y, int nBitmap)
609: {
610: if(hdcMemory)
611: {
612: BitBlt(hdc, x, y, BMWIDTH, BMHEIGHT, hdcMemory,
613: BMWIDTH * nBitmap, 0, SRCCOPY);
614: }
615: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.