![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to listhscr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / winat|
Return to listhscr.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / winat |
1.1 root 1: /*
2: * LISTHSCR.C
3: *
4: * Added functions to support horizontal listbox scrolling. This
5: * DLL is generalized to support any listbox. The FInitListboxExtents
6: * function allocates local memory (from the DLLs DATA segment) for
7: * the list of string extents to go in the listbox. The local handle
8: * is then assigned as a property of the window, so every other
9: * function first looks at this property.
10: *
11: * This means that any number of horizontal scrolling listboxes can
12: * be used in the system and make use of these functions, as long
13: * as the DLLs memory is not full.
14: *
15: */
16:
17:
18: #include <windows.h>
19: #include "listhscr.h"
20:
21:
22: /*
23: * This is just the label of the property given to each listbox
24: * that asks for an extent list.
25: */
26:
27: char szXTList[]="XTList";
28:
29:
30:
31:
32:
33: /*
34: * FInitListboxExtents
35: *
36: * Purpose:
37: * Simple helper function to initialize everything for maintaining
38: * horizontal extents in a listbox. This function allocates memory
39: * to hold the list of extents and assigns it to the window as a property.
40: *
41: * Parameters:
42: * hList HWND of the listbox concerned.
43: *
44: * Return Value:
45: * BOOL TRUE if the function was successful.
46: * FALSE if memory could not be allocated.
47: */
48:
49: BOOL FAR PASCAL FInitListboxExtents(HWND hList)
50: {
51: HANDLE hMem;
52: WORD *pw;
53:
54: /*
55: * Initially allocate 260 bytes, or 130 WORDs since the majority
56: * of listbox usage will not require a reallocation, and
57: * allocating 256 bytes is just as efficient as allocating 2
58: * bytes, if not more so because of reduces overhead.
59: *
60: * The extra two words store the current number of extent entries
61: * and the maximum number possible in this memory block.
62: *
63: */
64:
65: hMem=LocalAlloc(LMEM_MOVEABLE | LMEM_ZEROINIT, CBALLOCUNIT + sizeof(WORD)<<1);
66:
67: if (hMem==NULL)
68: return FALSE;
69:
70: /*
71: * Set the first two words in the memory to the appropriate values.
72: * If we can't lock it we can;'t use it!
73: */
74: pw=(WORD *)LocalLock(hMem);
75:
76: if (pw==NULL)
77: {
78: LocalFree(hMem);
79: return FALSE;
80: }
81:
82: *pw=0; //cExtentEntries
83: *(pw+1)=CALLOCUNITS; //cExtentEntriesMax
84:
85: LocalUnlock(hMem);
86:
87: /*
88: * Assign the memory handle as a property of the listbox. This allows
89: * this code to take any hList and get it's extent entry list,
90: * therefore having full support for multiple listboxes.
91: */
92: SetProp(hList, (LPSTR)szXTList, hMem);
93: return TRUE;
94: }
95:
96:
97:
98:
99:
100: /*
101: * FFreeListboxExtents
102: *
103: * Purpose:
104: * Release any memory used for storing the extents of the
105: * horizontal listbox. This MUST be called when the listbox
106: * is destroyed, like in the WM_DESTROY case of the parent window.
107: *
108: * Parameters:
109: * hList HWND of the listbox concerned.
110: *
111: * Return Value:
112: * BOOL TRUE if the function was successful.
113: * FALSE if there is an error.
114: */
115:
116: BOOL FAR PASCAL FFreeListboxExtents(HWND hList)
117: {
118: HANDLE hMem;
119: BOOL fSuccess;
120:
121: //Load the handle to free.
122: hMem=GetProp(hList, (LPSTR)szXTList);
123:
124: /*
125: * Return a BOOL on the result. An app could keep calling this
126: * function until it worked since hMem is still around.
127: */
128: fSuccess=(BOOL)LocalFree(hMem);
129:
130: if (fSuccess)
131: RemoveProp(hList, (LPSTR)szXTList); //Only if handle was freed!
132:
133: return fSuccess;
134: }
135:
136:
137:
138:
139: /*
140: * ResetListboxExtents
141: *
142: * Purpose:
143: * Deletes all extents in the extent list to be used AFTER an
144: * LB_RESETCONTENT is sent to the listbox.
145: *
146: * Parameters:
147: * hList HWND of the listbox.
148: *
149: * Return Value:
150: * none
151: *
152: */
153:
154: void FAR PASCAL ResetListboxExtents(HWND hList)
155: {
156: FFreeListboxExtents(hList);
157: FInitListboxExtents(hList);
158:
159: SendMessage(hList, LB_SETHORIZONTALEXTENT, 0, 0L);
160:
161: //This is required to remove the scrollbar.
162: SendMessage(hList, LB_DELETESTRING, 0, 0L);
163: return;
164: }
165:
166:
167:
168:
169:
170: /*
171: * WAddExtentEntry
172: *
173: * Purpose:
174: * Facilitates handling of the horizontal listbox by keeping
175: * track of the pixel width of the longest string in the listbox.
176: * The number of pixels that the listbox scrolls is the width
177: * of the longest string.
178: *
179: * Parameters:
180: * hList HWND of the listbox.
181: * psz Pointer to string that is added. This must be passed
182: * instead of an index into the listbox since this must
183: * be called before the string is added if the scrollbar
184: * is to be maintained properly.
185: *
186: * Return Value:
187: * WORD 0 if the string added was not the longest string in
188: * the listbox and therefore did not change the visibility
189: * of the horizontal scrollbar.
190: *
191: * wExtent if the added string was the longest, thus either
192: * making the scrollbar visible or changing the extent.
193: *
194: * -1 on an error.
195: *
196: */
197:
198: WORD FAR PASCAL WAddExtentEntry(HWND hList, LPSTR psz)
199: {
200: HANDLE hMem;
201: WORD cExtentEntries;
202: WORD cExtentEntriesMax;
203: WORD *pw; //Pointer to extent memory.
204: WORD wExtent;
205: WORD i=0;
206: WORD iRev;
207:
208:
209: hMem=GetProp(hList, (LPSTR)szXTList);
210:
211: if (hMem==NULL)
212: return ((WORD)-1);
213:
214:
215: pw=(WORD *)LocalLock(hMem);
216:
217: if (pw==NULL)
218: return ((WORD)-1);
219:
220: //Load the values and set pointer to start of list.
221: cExtentEntries=*pw++;
222: cExtentEntriesMax=*pw++;
223:
224: //Reallocate if necessary.
225: if (cExtentEntries==cExtentEntriesMax)
226: {
227: LocalUnlock(hMem);
228:
229: //This call takes care of cExtentEntriesMax
230: if (!FReAllocExtentList(hMem, TRUE))
231: return ((WORD)-1);
232:
233: cExtentEntriesMax += CALLOCUNITS;
234: pw=(WORD *)LocalLock(hMem);
235:
236: if (pw==NULL)
237: return ((WORD)-1);
238:
239: pw+=2; //Skip the two counters.
240: }
241:
242: wExtent=WGetListboxStringExtent(hList, psz);
243:
244:
245: /*
246: * Insert the new extent into the list. This list is just a sorted
247: * list (descending) of the largest to smallest extents in the
248: * listbox. When deleting a string, we just need to look in this
249: * list for it's extent and remove that entry.
250: *
251: * Yeah, this can be inefficient, but this is not a real case for
252: * optimization.
253: *
254: */
255:
256: if (cExtentEntries==0)
257: pw[0]=wExtent;
258: else
259: {
260: i=IFindExtentInList(pw, wExtent, cExtentEntries);
261:
262: for (iRev=cExtentEntries+1; iRev > i; iRev--)
263: pw[iRev]=pw[iRev-1];
264:
265: pw[i]=wExtent;
266: }
267:
268: cExtentEntries++;
269:
270: //Save these values back. pw must be decremented first.
271: *(--pw)=cExtentEntriesMax;
272: *(--pw)=cExtentEntries;
273:
274: LocalUnlock(hMem);
275:
276:
277: /*
278: * Check if the one we added is now the first. If so, then
279: * we need to reset the horizontal extent.
280: */
281:
282: if (i==0)
283: {
284: SendMessage(hList, LB_SETHORIZONTALEXTENT, wExtent, 0L);
285: return wExtent;
286: }
287:
288: return ((WORD)0);
289: }
290:
291:
292:
293:
294:
295:
296:
297:
298: /*
299: * WRemoveExtentEntry
300: *
301: * Purpose:
302: * Facilitates handling of the horizontal listbox by keeping
303: * track of the pixel width of the longest string in the listbox.
304: * The number of pixels that the listbox scrolls is the width
305: * of the longest string.
306: *
307: * Parameters:
308: * hList HWND of the listbox.
309: * iSel WORD index of the string to be removed.
310: *
311: * Return Value:
312: * WORD 0 if the string removed did not affect the visibilty
313: * of the horizontal scrollbar, i.e. if there still is
314: * a longer string or there is no scrollbar in the first
315: * place.
316: *
317: * wExtent of the new longest string if the one removed
318: * was the longest.
319: *
320: * -1 on an error.
321: */
322:
323: WORD FAR PASCAL WRemoveExtentEntry(HWND hList, WORD iSel)
324: {
325: WORD *pw; //Pointer to extent memory.
326: WORD cExtentEntries;
327: WORD cExtentEntriesMax;
328: WORD wExtent;
329: WORD i;
330: WORD iSave;
331: HANDLE hMem;
332: HANDLE hMemT;
333: char *pch;
334: WORD cb;
335:
336:
337: hMem=GetProp(hList, (LPSTR)szXTList);
338:
339: if (hMem==NULL)
340: return ((WORD)-1);
341:
342:
343: pw=(WORD *)LocalLock(hMem);
344:
345: if (pw==NULL)
346: return ((WORD)-1);
347:
348: //Load the values and set pointer to start of list.
349: cExtentEntries=*pw++;
350: cExtentEntriesMax=*pw++;
351:
352: if (cExtentEntries==0)
353: {
354: LocalUnlock(hMem);
355: return ((WORD)-1);
356: }
357:
358:
359: //Free up memory if necessary. No reallocating smaller is not fatal.
360: if ((cExtentEntriesMax-cExtentEntries)==CALLOCUNITS)
361: {
362: LocalUnlock(hMem);
363:
364: if (!FReAllocExtentList(hMem, FALSE))
365: return ((WORD)-1);
366:
367: cExtentEntriesMax += CALLOCUNITS;
368: pw=(WORD *)LocalLock(hMem);
369:
370: if (pw==NULL)
371: return ((WORD)-1);
372:
373: pw+=2; //Skip the two counters.
374: }
375:
376: cb=(WORD)SendMessage(hList, LB_GETTEXTLEN, iSel, 0L);
377:
378: //Temporary memory to copy the listbox string so we can get the extent.
379: hMemT=LocalAlloc(LMEM_MOVEABLE, cb+2); //One extra to be safe.
380: pch=LocalLock(hMemT);
381:
382: if (pch==NULL)
383: {
384: LocalUnlock(hMem);
385: LocalFree(hMemT);
386: return ((WORD)-1);
387: }
388:
389: cb=(WORD)SendMessage(hList, LB_GETTEXT, iSel, (LONG)(LPSTR)pch);
390:
391: wExtent=WGetListboxStringExtent(hList, (LPSTR)pch);
392:
393: LocalUnlock(hMemT);
394: LocalFree(hMemT);
395:
396:
397: /*
398: * Find the extent in the list and remove it. If it's the first,
399: * then reset the horizontal extent to the second.
400: */
401:
402: i=IFindExtentInList(pw, wExtent, cExtentEntries);
403: iSave=i;
404:
405: while (i < cExtentEntries)
406: pw[i++]=pw[i+1];
407:
408: cExtentEntries--;
409:
410: //Save these values back. pw must be decremented first.
411: *(--pw)=cExtentEntriesMax;
412: *(--pw)=cExtentEntries;
413:
414: LocalUnlock(hMem);
415:
416: if (iSave==0)
417: {
418: /*
419: * Before we change the horizontal extent, we must make sure that
420: * the origin of the listbox is visible through forcing a scroll.
421: * If this is not done, and the listbox is scrolled one or
422: * more pixels to the right, the scrollbar WILL NOT disappear
423: * even if all remaining strings fit inside the client area
424: * of the listbox.
425: *
426: * This is only done here since this the only case where this
427: * might happen is when we change the extent.
428: */
429: SendMessage(hList, WM_HSCROLL, SB_TOP, MAKELONG(0, hList));
430: SendMessage(hList, LB_SETHORIZONTALEXTENT, pw[2], 0L);
431:
432: return pw[2];
433: }
434:
435:
436: return ((WORD)0);
437: }
438:
439:
440:
441:
442:
443:
444: /*
445: * FReAllocExtentList
446: *
447: * Purpose:
448: * Handles reallocation of the list in blocks of +/- CBALLOCUNIT
449: *
450: * Parameters:
451: * fGrow BOOL if TRUE, instructs this function to allocate
452: * an additional ALLOCUNIT.
453: * If FALSE, shrinks the memory block by an ALLOCUNIT.
454: *
455: * Return Value:
456: * BOOL TRUE if successfully reallocated. FALSE otherwise.
457: *
458: */
459:
460: BOOL FReAllocExtentList(HANDLE hMem, BOOL fGrow)
461: {
462: WORD wSize;
463:
464: /*
465: * Allocate an additional 128 entries. A 256 byte block is a
466: * decent reallocation size.
467: */
468: wSize=LocalSize((HLOCAL)hMem);
469: wSize+=(fGrow) ? ((int)CBALLOCUNIT) : (-(int)CBALLOCUNIT);
470:
471: /*
472: * This returns FALSE if the realloc was unsuccessful. TRUE
473: * otherwise because the return handle is !=0
474: *
475: */
476: return (BOOL)LocalReAlloc(hMem, wSize, LMEM_MOVEABLE | LMEM_ZEROINIT);
477: }
478:
479:
480:
481:
482:
483:
484: /*
485: * WGetListboxStringExtent
486: *
487: * Purpose:
488: * Returns the extent, in pixels, of a string that will be or is
489: * in a listbox. The hDC of the listbox is used and an extra
490: * average character width is added to the extent to insure that
491: * a horizontal scrolling listbox that is based on this extent
492: * will scroll such that the end of the string is visible.
493: *
494: * Parameters:
495: * hList HWND handle to the listbox.
496: * psz LPSTR pointer to string in question.
497: *
498: * Return Value:
499: * WORD Extent of the string relative to listbox.
500: *
501: */
502:
503: WORD WGetListboxStringExtent(HWND hList, LPSTR psz)
504: {
505: TEXTMETRIC tm;
506: HDC hDC;
507: HFONT hFont;
508: WORD wExtent;
509:
510:
511: /*
512: * Make sure we are using the correct font.
513: */
514: hDC=GetDC(hList);
515: hFont=(HFONT)SendMessage(hList, WM_GETFONT, 0, 0L);
516:
517: if (hFont!=NULL)
518: SelectObject(hDC, hFont);
519:
520: GetTextMetrics(hDC, &tm);
521:
522: /*
523: * Add one average text width to insure that we see the end of the
524: * string when scrolled horizontally.
525: */
526:
527: //
528: // changed to GetTextExtentPoint - KoryG - 3/24/92
529: //
530: {
531: SIZE Size;
532:
533: GetTextExtentPoint(hDC, psz, lstrlen(psz), &Size);
534: // fudge for tabs!
535: wExtent=(WORD)Size.cx + (WORD)tm.tmAveCharWidth + 180;
536: }
537:
538: ReleaseDC(hList, hDC);
539:
540: return wExtent;
541: }
542:
543:
544:
545:
546:
547:
548: /*
549: * IFindExtentInList
550: *
551: * Purpose:
552: * Does an binary search on the sorted extent list and returns
553: * an index to the one that matches. If there is no match,
554: * the index gives the point where the extent entry should go.
555: *
556: * Note that an altered search algorithm is used since the list
557: * is descending instead of ascending.
558: *
559: * Parameters:
560: * pw WORD * pointer to extent list.
561: * wExtent WORD extent to find or find an index for.
562: * cExtentEntries WORD count of entries in list.
563: *
564: * Return Value:
565: * iExtent WORD index into lpw where wExtent exists or where
566: * it should be inserted.
567: *
568: */
569:
570: WORD IFindExtentInList(WORD *pw, WORD wExtent, WORD cExtentEntries)
571: {
572: int i = 0; //These MUST be signed!
573: int iPrev;
574: int iMin;
575: int iMax;
576:
577: //Set upper limits on search.
578: iMin=0;
579: iMax=cExtentEntries+1;
580:
581:
582: do
583: {
584: iPrev=i;
585: i=(iMin + iMax) >> 1;
586:
587: if (i==iPrev)
588: {
589: i++;
590: break;
591: }
592:
593: //Change the min and max depending on which way we need to look.
594: if (wExtent < pw[i]) // < since list is descending. > otherwise
595: iMin=i;
596: else
597: iMax=i;
598:
599: if (iMax==iMin)
600: break;
601: }
602: while (wExtent != pw[i]);
603:
604:
605: /*
606: * When we get here, i is either where wExtent is or where it should
607: * go--so return it.
608: */
609: return i;
610: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.