![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to table.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / windiff|
Return to table.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / windiff |
1.1 root 1:
2: /******************************************************************************\
3: * This is a part of the Microsoft Source Code Samples.
4: * Copyright (C) 1993 Microsoft Corporation.
5: * All rights reserved.
6: * This source code is only intended as a supplement to
7: * Microsoft Development Tools and/or WinHelp documentation.
8: * See these sources for detailed information regarding the
9: * Microsoft samples programs.
10: \******************************************************************************/
11:
12: /****************************** Module Header *******************************
13: * Module Name: TABLE.C
14: *
15: * Standard table class and main interface functions.
16: *
17: * Functions:
18: *
19: * gtab_init()
20: * gtab_deltools()
21: * gtab_sendtq()
22: * gtab_freelinedata()
23: * gtab_wndproc()
24: * gtab_createtools()
25: * gtab_deltable()
26: * gtab_buildtable()
27: * gtab_setsize()
28: * gtab_newsize()
29: * gtab_calcwidths()
30: * gtab_alloclinedata()
31: * gtab_invallines()
32: * gtab_append()
33: *
34: * Comments:
35: *
36: * The table class communicates with its 'owner' window to
37: * get the layout info and the data to display. The owner window handle
38: * can be sent as the lParam in CreateWindow - if not, the parent window will
39: * be used.
40: *
41: * After creating the window, send it a TM_NEWID message, with a 'data id'
42: * as the lParam. This is any non-zero 32-bit value. The table will then call
43: * back to its owner window to find out how many rows/columns, then to fetch
44: * the name/properties of each column, and finally to get the data to display.
45: *
46: * Send TM_NEWID of 0 to close (or destroy the window) - wait for TQ_CLOSE
47: * (in either case) before discarding data. Send
48: * TM_REFRESH if data or row-count changes; send TM_NEWLAYOUT if column
49: * properties or nr cols change etc - this is the same as sending TM_NEWID
50: * except that no TQ_CLOSE happens on TM_NEWLAYOUT.
51: *
52: * TQ_SELECT is sent whenever the current selection changes. TQ_ENTER is sent
53: * when enter or double-click occurs.
54: *
55: ****************************************************************************/
56:
57: #include <windows.h>
58: #include <commdlg.h>
59:
60: #include "gutils.h"
61: #include "table.h"
62: #include "tpriv.h"
63:
64: /* global tools etc */
65: extern HANDLE hLibInst;
66: HANDLE hVertCurs;
67: HANDLE hNormCurs;
68: HPEN hpenDotted;
69: UINT gtab_msgcode;
70:
71: /* function prototypes */
72: long FAR PASCAL gtab_wndproc(HWND, UINT, UINT, long);
73: void gtab_createtools(void);
74: void gtab_deltable(HWND hwnd, lpTable ptab);
75: lpTable gtab_buildtable(HWND hwnd, DWORD id);
76: void gtab_setsize(HWND hwnd, lpTable ptab);
77: void gtab_newsize(HWND hwnd, lpTable ptab);
78: void gtab_calcwidths(HWND hwnd, lpTable ptab);
79: BOOL gtab_alloclinedata(HWND hwnd, HANDLE heap, lpTable ptab);
80: void gtab_invallines(HWND hwnd, lpTable ptab, int start, int count);
81: void gtab_append(HWND hwnd, lpTable ptab, int rows, DWORD id);
82:
83: /***************************************************************************
84: * Function: gtab_init
85: *
86: * Purpose:
87: *
88: * Initialise window class - called from DLL main init
89: */
90: void
91: gtab_init(void)
92: {
93: WNDCLASS wc;
94:
95: gtab_createtools();
96: gtab_msgcode = RegisterWindowMessage(TableMessage);
97:
98: wc.style = CS_GLOBALCLASS | CS_DBLCLKS;
99: wc.lpfnWndProc = gtab_wndproc;
100: wc.cbClsExtra = 0;
101: wc.cbWndExtra = WLTOTAL;
102: wc.hInstance = hLibInst;
103: wc.hIcon = NULL;
104: wc.hCursor = NULL;
105: wc.hbrBackground = GetStockObject(WHITE_BRUSH);
106: wc.lpszClassName = TableClassName;
107: wc.lpszMenuName = NULL;
108:
109: RegisterClass(&wc);
110: }
111:
112: /***************************************************************************
113: * Function: gtab_createtools
114: *
115: * Purpose:
116: *
117: * Load cursors and pens.
118: */
119: void
120: gtab_createtools(void)
121: {
122: hVertCurs = LoadCursor(hLibInst, "VertLine");
123: hNormCurs = LoadCursor(NULL, IDC_ARROW);
124:
125: hpenDotted = CreatePen(PS_DOT, 1, RGB(0, 0, 0));
126: }
127:
128: /***************************************************************************
129: * Function: gtab_deltools
130: *
131: * Purpose:
132: *
133: * Delete pen
134: */
135: void
136: gtab_deltools(void)
137: {
138: DeleteObject(hpenDotted);
139: }
140:
141:
142: /***************************************************************************
143: * Function: gtab_wndproc
144: *
145: * Purpose:
146: *
147: * Window procedure for table
148: */
149: long FAR PASCAL
150: gtab_wndproc(HWND hwnd, UINT msg, UINT wParam, long lParam)
151: {
152: CREATESTRUCT FAR * csp;
153: HWND hOwner;
154: lpTable ptab;
155: HANDLE hHeap;
156: PAINTSTRUCT ps;
157: int y, y2, i;
158: HDC hDC;
159: lpTableSelection pselect;
160: long oldtop;
161: long change;
162:
163: switch(msg) {
164:
165: case WM_CREATE:
166: /* create window. set the wnd extra bytes to
167: * contain the owner window, a heap and a null table.
168: * Owner window is either in lParam or the parent.
169: * Then wait for TM_NEWID.
170: */
171: csp = (CREATESTRUCT FAR *) lParam;
172: if (csp->lpCreateParams == NULL) {
173: hOwner = GetParent(hwnd);
174: } else {
175: hOwner = (HWND) (long) csp->lpCreateParams;
176: }
177: ptab = NULL;
178: hHeap = gmem_init();
179: SetWindowLong(hwnd, WL_TABLE, (LONG) ptab);
180: SetWindowLong(hwnd, WW_OWNER, (LONG) hOwner);
181: SetWindowLong(hwnd, WW_HEAP, (LONG) hHeap);
182:
183: SetScrollRange(hwnd, SB_VERT, 0, 0, TRUE);
184: SetScrollRange(hwnd, SB_HORZ, 0, 0, TRUE);
185: break;
186:
187: case TM_NEWID:
188: /* complete change of table.
189: * close old table, discard memory and
190: * build new table
191: */
192: ptab = (lpTable) GetWindowLong(hwnd, WL_TABLE);
193: if (ptab != NULL) {
194: gtab_sendtq(hwnd, TQ_CLOSE, ptab->hdr.id);
195: gtab_deltable(hwnd, ptab);
196: SetCursor(hNormCurs);
197: SetWindowLong(hwnd, WL_TABLE, 0);
198: }
199: if ( (ptab = gtab_buildtable(hwnd, lParam)) != NULL) {
200: SetWindowLong(hwnd, WL_TABLE, (long) (LPSTR) ptab);
201: gtab_setsize(hwnd, ptab);
202: } else {
203: SetScrollRange(hwnd, SB_VERT, 0, 0, TRUE);
204: SetScrollRange(hwnd, SB_HORZ, 0, 0, TRUE);
205: }
206: InvalidateRect(hwnd, NULL, TRUE);
207: break;
208:
209: case TM_NEWLAYOUT:
210: /* change of layout but for same id. no TQ_CLOSE,
211: * but otherwise same as TM_NEWID
212: */
213: ptab = (lpTable) GetWindowLong(hwnd, WL_TABLE);
214: if (ptab != NULL) {
215: gtab_deltable(hwnd, ptab);
216: SetCursor(hNormCurs);
217: SetWindowLong(hwnd, WL_TABLE, 0);
218: }
219: if ( (ptab = gtab_buildtable(hwnd, lParam)) != NULL) {
220: SetWindowLong(hwnd, WL_TABLE, (long) (LPSTR) ptab);
221: gtab_setsize(hwnd, ptab);
222: } else {
223: SetScrollRange(hwnd, SB_VERT, 0, 0, TRUE);
224: SetScrollRange(hwnd, SB_HORZ, 0, 0, TRUE);
225: }
226: InvalidateRect(hwnd, NULL, TRUE);
227: break;
228:
229: case TM_REFRESH:
230: /* data in table has changed. nrows may have
231: * changed. ncols and col types have not changed
232: */
233: ptab = (lpTable) GetWindowLong(hwnd, WL_TABLE);
234: if (ptab != NULL) {
235: gtab_newsize(hwnd, ptab);
236: }
237: InvalidateRect(hwnd, NULL, TRUE);
238: break;
239:
240: case TM_SELECT:
241: ptab = (lpTable) GetWindowLong(hwnd, WL_TABLE);
242: if (ptab != NULL) {
243: pselect = (lpTableSelection) lParam;
244:
245: /*
246: * we only support TM_SINGLE - so force the
247: * selection to a single row or cell.
248: */
249: gtab_select(hwnd, ptab, pselect->startrow,
250: pselect->startcell,
251: 1,
252: (ptab->hdr.selectmode & TM_ROW) ?
253: ptab->hdr.ncols : 1,
254: TRUE);
255: gtab_showsel_middle(hwnd, ptab);
256: }
257: break;
258:
259: case TM_PRINT:
260: ptab = (lpTable) GetWindowLong(hwnd, WL_TABLE);
261: hHeap = (HANDLE) GetWindowLong(hwnd, WW_HEAP);
262: if (ptab != NULL) {
263: gtab_print(hwnd, ptab, hHeap, (lpPrintContext) lParam);
264: return(TRUE);
265: }
266:
267: case TM_TOPROW:
268:
269: /* return top row. if wParam is TRUE, set lParam
270: * as the new toprow
271: */
272: ptab = (lpTable) GetWindowLong(hwnd, WL_TABLE);
273: if (ptab == NULL) {
274: return(0);
275: }
276: oldtop = ptab->toprow;
277: if ((wParam) && (lParam < ptab->hdr.nrows)) {
278: change = lParam - ptab->toprow;
279: change -= ptab->hdr.fixedrows;
280: gtab_dovscroll(hwnd, ptab, change);
281: }
282: return(oldtop);
283:
284: case TM_ENDROW:
285: /* return the last visible row in the window */
286: ptab = (lpTable) GetWindowLong(hwnd, WL_TABLE);
287: if (ptab == NULL) {
288: return(0);
289: }
290: return(ptab->nlines + ptab->toprow - 1);
291:
292:
293: case TM_APPEND:
294: /* new rows have been added to the end of the
295: * table, but the rest of the table has no
296: * been change. Update without forcing redraw of
297: * everything.
298: * lParam contains the new total nr of rows
299: */
300: ptab = (lpTable) GetWindowLong(hwnd, WL_TABLE);
301: if (ptab != NULL) {
302: gtab_append(hwnd, ptab, wParam, lParam);
303: return(TRUE);
304: }
305: break;
306:
307: case WM_SIZE:
308: ptab = (lpTable) GetWindowLong(hwnd, WL_TABLE);
309: if (ptab != NULL) {
310: gtab_setsize(hwnd, ptab);
311: }
312: break;
313:
314: case WM_DESTROY:
315: ptab = (lpTable) GetWindowLong(hwnd, WL_TABLE);
316: if (ptab != NULL) {
317: gtab_sendtq(hwnd, TQ_CLOSE, ptab->hdr.id);
318: gtab_deltable(hwnd, ptab);
319: }
320: hHeap = (HANDLE) GetWindowLong(hwnd, WW_HEAP);
321: gmem_freeall(hHeap);
322: break;
323:
324: case WM_PAINT:
325: hDC = BeginPaint(hwnd, &ps);
326: ptab = (lpTable) GetWindowLong(hwnd, WL_TABLE);
327: if (ptab != NULL) {
328: /* separator lines between fixed rows/columns
329: * (ie headers) and the rest - if enabled
330: */
331: /* paint here first for good impression,
332: * and again after to clean up!!
333: */
334: if (ptab->hdr.vseparator) {
335: gtab_vsep(hwnd, ptab, hDC);
336: }
337: if (ptab->hdr.hseparator) {
338: gtab_hsep(hwnd, ptab, hDC);
339: }
340:
341: /* paint only the rows that need painting */
342: for (i = 0; i < ptab->nlines; i++) {
343: y = ptab->pdata[i].linepos.start;
344: y2 = y + ptab->pdata[i].linepos.size;
345: if ( (y <= ps.rcPaint.bottom) &&
346: (y2 >= ps.rcPaint.top)) {
347: gtab_paint(hwnd, hDC, ptab, i);
348: }
349: }
350: if (ptab->hdr.vseparator) {
351: gtab_vsep(hwnd, ptab, hDC);
352: }
353: if (ptab->hdr.hseparator) {
354: gtab_hsep(hwnd, ptab, hDC);
355: }
356: if (ptab->selvisible) {
357: gtab_invertsel(hwnd, ptab, hDC);
358: }
359: }
360:
361: EndPaint(hwnd, &ps);
362: break;
363:
364: case WM_HSCROLL:
365: ptab = (lpTable) GetWindowLong(hwnd, WL_TABLE);
366: if (ptab != NULL) {
367: gtab_msg_hscroll(hwnd, ptab,
368: GET_SCROLL_OPCODE(wParam, lParam),
369: GET_SCROLL_POS(wParam, lParam));
370: }
371: break;
372:
373: case WM_VSCROLL:
374: ptab = (lpTable) GetWindowLong(hwnd, WL_TABLE);
375: if (ptab != NULL) {
376: gtab_msg_vscroll(hwnd, ptab,
377: GET_SCROLL_OPCODE(wParam, lParam),
378: GET_SCROLL_POS(wParam, lParam));
379: }
380: break;
381:
382: case WM_MOUSEMOVE:
383: ptab = (lpTable) GetWindowLong(hwnd, WL_TABLE);
384: if (ptab != NULL) {
385: gtab_move(hwnd, ptab, LOWORD(lParam), HIWORD(lParam));
386: } else {
387: SetCursor(hNormCurs);
388: }
389: break;
390:
391: case WM_LBUTTONDOWN:
392: ptab = (lpTable) GetWindowLong(hwnd, WL_TABLE);
393: if (ptab != NULL) {
394: gtab_press(hwnd, ptab, LOWORD(lParam), HIWORD(lParam));
395: }
396: break;
397:
398: case WM_LBUTTONUP:
399: ptab = (lpTable) GetWindowLong(hwnd, WL_TABLE);
400: if (ptab != NULL) {
401: gtab_release(hwnd, ptab,
402: LOWORD(lParam), HIWORD(lParam));
403: }
404: break;
405:
406: case WM_LBUTTONDBLCLK:
407: ptab = (lpTable) GetWindowLong(hwnd, WL_TABLE);
408: if (ptab != NULL) {
409: gtab_dblclick(hwnd, ptab,
410: LOWORD(lParam), HIWORD(lParam));
411: }
412: break;
413:
414: case WM_KEYDOWN:
415: /* handle key presses for cursor movement about
416: * the table, and return/space for selection.
417: * Any key we don't handle is passed to the owner window
418: * for him to handle.
419: * The table window should have the focus
420: */
421: ptab = (lpTable) GetWindowLong(hwnd, WL_TABLE);
422: if (ptab != NULL) {
423: if (gtab_key(hwnd, ptab, wParam) != 0) {
424: /* pass key to owner since
425: * we don't know what to do with it
426: */
427: hOwner = (HANDLE) GetWindowLong(hwnd, WW_OWNER);
428: return(SendMessage(hOwner, WM_KEYDOWN,
429: wParam, lParam));
430: } else {
431: return(0);
432: }
433: }
434: break;
435:
436: default:
437: return(DefWindowProc(hwnd, msg, wParam, lParam));
438: }
439: return(TRUE);
440: }
441:
442: /***************************************************************************
443: * Function: gtab_sendtq
444: *
445: * Purpose:
446: *
447: * Send a table-query message to the owner window. Returns message
448: * value.
449: */
450: long
451: gtab_sendtq(HWND hwnd, UINT cmd, long lParam)
452: {
453: HWND hOwner;
454:
455: hOwner = (HANDLE) GetWindowLong(hwnd, WW_OWNER);
456: return (SendMessage(hOwner, gtab_msgcode, cmd, lParam));
457: }
458:
459: /***************************************************************************
460: * Function: gtab_freelinedata
461: *
462: * Purpose:
463: *
464: * Free the memory allocated for the array of lines (each containing
465: * an array of Cells, each containing an array of chars for the actual
466: * data). Called on any occasion that would change the number of visible lines
467: */
468: void
469: gtab_freelinedata(HANDLE hHeap, lpTable ptab)
470: {
471: int i, j, ncols;
472: lpCellData cd;
473:
474:
475: ncols = ptab->hdr.ncols;
476:
477: /* for each line */
478: for(i = 0; i < ptab->nlines; i++) {
479: /* for each cell */
480: for (j = 0; j < ncols; j++) {
481: /* free up the actual text space */
482: cd = &ptab->pdata[i].pdata[j];
483: gmem_free(hHeap, (LPSTR) cd->ptext, cd->nchars);
484: }
485: /* dealloc array of CellData */
486: gmem_free(hHeap, (LPSTR) ptab->pdata[i].pdata,
487: sizeof(CellData) * ncols);
488: }
489: /* de-alloc array of linedatas */
490: gmem_free(hHeap, (LPSTR) ptab->pdata,
491: sizeof(LineData) * ptab->nlines);
492: ptab->pdata = NULL;
493: }
494:
495: /***************************************************************************
496: * Function: gtab_alloclinedata
497: *
498: * Purpose:
499: *
500: * Allocate and init array of linedatas (include cell array
501: * and text for each cell)
502: */
503: BOOL
504: gtab_alloclinedata(HWND hwnd, HANDLE heap, lpTable ptab)
505: {
506: lpLineData pline;
507: lpCellData cd;
508: int i, j;
509:
510: ptab->pdata = (lpLineData) gmem_get(heap,
511: sizeof(LineData) * ptab->nlines);
512: if (ptab->pdata == NULL) {
513: return(FALSE);
514: }
515: for (i = 0; i < ptab->nlines; i++) {
516: pline = &ptab->pdata[i];
517: pline->linepos.size = ptab->rowheight;
518: pline->pdata = (lpCellData) gmem_get(heap,
519: sizeof(CellData) * ptab->hdr.ncols);
520: if (pline->pdata == NULL) {
521: return(FALSE);
522: }
523: for (j = 0; j < ptab->hdr.ncols; j++) {
524: cd = &pline->pdata[j];
525: cd->props.valid = 0;
526: cd->flags = 0;
527: cd->nchars = ptab->pcolhdr[j].nchars;
528: if (cd->nchars > 0) {
529: cd->ptext = gmem_get(heap, cd->nchars);
530: if (cd->ptext == NULL) {
531: return(FALSE);
532: }
533: }
534: }
535: }
536: }
537:
538: /***************************************************************************
539: * Function: gtab_deltable
540: *
541: * Purpose:
542: *
543: * Free up all table data structures. Called for new layout or new data.
544: */
545: void
546: gtab_deltable(HWND hwnd, lpTable ptab)
547: {
548: HANDLE hHeap;
549: int ncols;
550:
551: if (ptab == NULL) {
552: return;
553: }
554: hHeap = (HANDLE) GetWindowLong(hwnd, WW_HEAP);
555: ncols = ptab->hdr.ncols;
556:
557: if (ptab->pcolhdr != NULL) {
558: gmem_free(hHeap, (LPSTR) ptab->pcolhdr,
559: sizeof(ColProps) * ncols);
560: }
561: if (ptab->pcellpos != NULL) {
562: gmem_free(hHeap, (LPSTR) ptab->pcellpos,
563: sizeof(CellPos) * ncols);
564: }
565: if (ptab->pdata != NULL) {
566: gtab_freelinedata(hHeap, ptab);
567: }
568: gmem_free(hHeap, (LPSTR) ptab, sizeof(Table));
569: }
570:
571:
572: /***************************************************************************
573: * Function: gtab_buildtable
574: *
575: * Purpose:
576: *
577: * Build up a Table struct (excluding data allocation and
578: * anything to do with font or window size).
579: * Return ptr to this or NULL if error
580: */
581: lpTable
582: gtab_buildtable(HWND hwnd, DWORD id)
583: {
584: lpTable ptab;
585: HANDLE hHeap;
586: int ncols, i;
587: ColPropsList cplist;
588:
589: hHeap = (HANDLE) GetWindowLong(hwnd, WW_HEAP);
590: ptab = (lpTable) gmem_get(hHeap, sizeof(Table));
591: if (ptab == NULL) {
592: return(NULL);
593: }
594:
595: /* get the row/column count from owner window */
596: ptab->hdr.id = id;
597: ptab->hdr.props.valid = 0;
598: ptab->hdr.sendscroll = FALSE;
599: if (gtab_sendtq(hwnd, TQ_GETSIZE, (long) (LPSTR)&ptab->hdr) == FALSE) {
600: return(NULL);
601: }
602:
603: ncols = ptab->hdr.ncols;
604: ptab->pcolhdr = (lpColProps) gmem_get(hHeap, sizeof(ColProps) * ncols);
605: if (ptab->pcolhdr == NULL) {
606: /* should prob send TQ_CLOSE at this point */
607: return(NULL);
608: }
609:
610: /* init col properties to default */
611: for (i=0; i < ncols; i++) {
612: ptab->pcolhdr[i].props.valid = 0;
613: ptab->pcolhdr[i].nchars = 0;
614: }
615: /* get the column props from owner */
616: cplist.plist = ptab->pcolhdr;
617: cplist.id = id;
618: cplist.startcol = 0;
619: cplist.ncols = ncols;
620: gtab_sendtq(hwnd, TQ_GETCOLPROPS, (long) (LPSTR)&cplist);
621:
622: /* init remaining fields */
623: ptab->pcellpos = (lpCellPos) gmem_get(hHeap, sizeof(CellPos) * ncols);
624: if (ptab->pcellpos == NULL) {
625: return(NULL);
626: }
627:
628: ptab->scrollscale = 1;
629: ptab->scroll_dx = 0;
630: ptab->toprow = 0;
631: ptab->pdata = NULL;
632: ptab->nlines = 0;
633: ptab->trackmode = TRACK_NONE;
634:
635: /* we have to notify owner of the current selection
636: * whenever it is changed
637: */
638: ptab->select.id = id;
639: gtab_select(hwnd, ptab, 0, 0, 0, 0, TRUE);
640:
641: /* calc ave height/width, cell widths and min height.
642: * these change only when cell properties / col count changes -
643: * ie only on rebuild-header events
644: */
645: gtab_calcwidths(hwnd, ptab);
646: return(ptab);
647: }
648:
649: /***************************************************************************
650: * Function: gtab_setsize
651: *
652: * Purpose:
653: *
654: * Set sizes that are based on window size and scroll pos
655: * set:
656: * winwidth
657: * nlines
658: * cellpos start, clip start/end
659: * Alloc linedata and init
660: */
661: void
662: gtab_setsize(HWND hwnd, lpTable ptab)
663: {
664: RECT rc;
665: int nlines;
666: HANDLE heap;
667: long range, change;
668:
669: GetClientRect(hwnd, &rc);
670: ptab->winwidth = rc.right - rc.left;
671: nlines = (rc.bottom - rc.top) / ptab->rowheight;
672: /* nlines is the number of whole lines - add one extra
673: * for the partial line at the bottom
674: */
675: nlines += 1;
676:
677: /* alloc space for nlines of data - if nlines has changed */
678: if (nlines != ptab->nlines) {
679: heap = (HANDLE) GetWindowLong(hwnd, WW_HEAP);
680: gtab_freelinedata(heap, ptab);
681: ptab->nlines = nlines;
682: if (!gtab_alloclinedata(hwnd, heap, ptab)) {
683: ptab->nlines = 0;
684: return;
685: }
686: }
687:
688: /* set scroll vertical range */
689: range = ptab->hdr.nrows - (ptab->nlines - 1);
690: if (range < 0) {
691: range = 0;
692: change = -(ptab->toprow);
693: } else if (ptab->toprow > range) {
694: change = range - ptab->toprow;
695: } else {
696: change = 0;
697: }
698: /* the scroll range must be 16-bits for Win3
699: * scale until this is true
700: */
701: ptab->scrollscale = 1;
702: while (range > 32766) {
703: ptab->scrollscale *= 16;
704: range /= 16;
705: }
706:
707: SetScrollRange(hwnd, SB_VERT, 0, (int) range, TRUE);
708: gtab_dovscroll(hwnd, ptab, change);
709:
710: /* set horz scroll range */
711: range = ptab->rowwidth - ptab->winwidth;
712: if (range < 0) {
713: range = 0;
714: change = -(ptab->scroll_dx);
715: } else if (ptab->scroll_dx > range) {
716: change = range - ptab->scroll_dx;
717: } else {
718: change = 0;
719: }
720: /* horz scroll range will always be < 16 bits */
721: SetScrollRange(hwnd, SB_HORZ, 0, (int) range, TRUE);
722: gtab_dohscroll(hwnd, ptab, change);
723: }
724:
725: /***************************************************************************
726: * Function: gtab_calcwidths
727: *
728: * Purpose:
729: *
730: * Set column widths/height and totals (based on column props)
731: * - no assumption of window size (see gtab_setsize)
732: * sets avewidth,rowheight,cellpos.size,rowwidth (total of cellpos.size)
733: */
734: void
735: gtab_calcwidths(HWND hwnd, lpTable ptab)
736: {
737: int i, cxtotal, cx, ave;
738: TEXTMETRIC tm, tmcol;
739: HDC hdc;
740: lpProps hdrprops, cellprops;
741: HFONT hfont;
742:
743: hdrprops = &ptab->hdr.props;
744: hdc = GetDC(hwnd);
745: if (hdrprops->valid & P_FONT) {
746: hfont = SelectObject(hdc, hdrprops->hFont);
747: }
748: GetTextMetrics(hdc, &tm);
749: if (hdrprops->valid & P_FONT) {
750: SelectObject(hdc, hfont);
751: }
752: ReleaseDC(hwnd, hdc);
753:
754: /* get width and height of average character */
755: ptab->avewidth = tm.tmAveCharWidth;
756: ptab->rowheight = tm.tmHeight + tm.tmExternalLeading;
757: if (hdrprops->valid & P_HEIGHT) {
758: ptab->rowheight = hdrprops->height;
759: }
760:
761: /* set pixel width of each cell (and add up for row total)
762: * based on ave width * nr chars, unless P_WIDTH set
763: */
764: cxtotal = 0;
765: for (i = 0; i < ptab->hdr.ncols; i++) {
766: cellprops = &ptab->pcolhdr[i].props;
767:
768: if (cellprops->valid & P_WIDTH) {
769: cx = cellprops->width;
770: } else if (hdrprops->valid & P_WIDTH) {
771: cx = hdrprops->width;
772: } else {
773:
774: if (cellprops->valid & P_FONT) {
775: hdc = GetDC(hwnd);
776: hfont = SelectObject(hdc, cellprops->hFont);
777: GetTextMetrics(hdc, &tmcol);
778: SelectObject(hdc, hfont);
779: ReleaseDC(hwnd, hdc);
780: ave = tmcol.tmAveCharWidth;
781: } else {
782: ave = ptab->avewidth;
783: }
784: /* ave width * nchars */
785: cx = ptab->pcolhdr[i].nchars + 1;
786: cx *= ave;
787: }
788: /* add 2 pixels for box lines */
789: cx += 2;
790: ptab->pcellpos[i].size = cx;
791: cxtotal += cx;
792: }
793: ptab->rowwidth = cxtotal;
794: }
795:
796: /***************************************************************************
797: * Function: gtab_newsize
798: *
799: * Purpose:
800: *
801: * Called when row data + possible nrows changes.
802: * other changes are ignored
803: */
804: void
805: gtab_newsize(HWND hwnd, lpTable ptab)
806: {
807: TableHdr hdr;
808:
809: /* get new row count */
810: hdr = ptab->hdr;
811: gtab_sendtq(hwnd, TQ_GETSIZE, (long) (LPSTR) &hdr);
812: if (hdr.nrows != ptab->hdr.nrows) {
813: ptab->hdr.nrows = hdr.nrows;
814: gtab_setsize(hwnd, ptab);
815: }
816:
817: gtab_invallines(hwnd, ptab, 0, ptab->nlines);
818:
819: InvalidateRect(hwnd, NULL, TRUE);
820: }
821:
822: void
823: gtab_invallines(HWND hwnd, lpTable ptab, int start, int count)
824: {
825: int i, j;
826:
827: for (i = start; i < start + count; i++) {
828: for (j = 0; j < ptab->hdr.ncols; j++) {
829: ptab->pdata[i].pdata[j].flags = 0;
830: }
831: }
832: }
833:
834: /***************************************************************************
835: * Function: gtab_append
836: *
837: * Purpose:
838: *
839: * New rows have been added to the table. Adjust the scroll range and
840: * position, and redraw the rows if the end of the table is currently
841: * visible.
842: * rows = the new total row count.
843: */
844: void
845: gtab_append(HWND hwnd, lpTable ptab, int rows, DWORD id)
846: {
847: long range;
848: long oldrows;
849: int line, nupdates;
850: RECT rc;
851:
852:
853: /* change to the new id */
854: ptab->hdr.id = id;
855: ptab->select.id = id;
856:
857: /* update the header, but remember the old nr of rows
858: * so we know where to start updating
859: */
860: oldrows = ptab->hdr.nrows;
861:
862: /* check that the new nr of rows is not smaller. this is
863: * illegal at this point and should be ignored
864: */
865: if (oldrows >= rows) {
866: return;
867: }
868:
869: ptab->hdr.nrows = rows;
870:
871: /* set the vertical scroll range */
872: range = rows - (ptab->nlines - 1);
873:
874: if (range < 0) {
875: range = 0;
876: }
877:
878: /* force the scroll range into 16-bits for win 3.1 */
879: ptab->scrollscale = 1;
880: while (range > 32766) {
881: ptab->scrollscale *= 16;
882: range /= 16;
883: }
884:
885: /* now set the scroll bar range and position */
886: SetScrollRange(hwnd, SB_VERT, 0, (int) range, TRUE);
887: if (range > 0) {
888: SetScrollPos(hwnd, SB_VERT,
889: (int) (ptab->toprow / ptab->scrollscale), TRUE);
890: }
891:
892: /* calculate which screen lines need to be updated - find what
893: * screen line the start of the new section is at
894: */
895: line = gtab_rowtoline(hwnd, ptab, oldrows);
896: if (line == -1) {
897: /* not visible -> no more to do */
898: return;
899: }
900:
901: /* how many lines to update - rest of screen or nr of
902: * new lines if less than rest of screen
903: */
904: nupdates = min((ptab->nlines - line), (int)(rows - oldrows));
905:
906: /* invalidate the screen line buffers to indicate data
907: * needs to be refetch from parent window
908: */
909: gtab_invallines(hwnd, ptab, line, nupdates);
910:
911: /* calculate the region of the screen to be repainted -
912: * left and right are same as window. top and bottom
913: * need to be calculated from screen line height
914: */
915:
916: GetClientRect(hwnd, &rc);
917: rc.top += line * ptab->rowheight;
918: rc.bottom = rc.top + (nupdates * ptab->rowheight);
919:
920: /* force a repaint of the updated region */
921: InvalidateRect(hwnd, &rc, TRUE);
922: }
923:
924:
925:
926:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.