![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to outllist.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / ole20 / samples / outline|
Return to outllist.c CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / outline |
1.1 root 1: /*************************************************************************
2: **
3: ** OLE 2 Sample Code
4: **
5: ** outldata.c
6: **
7: ** This file contains LineList and NameTable functions
8: ** and related support functions.
9: **
10: ** (c) Copyright Microsoft Corp. 1992 - 1993 All Rights Reserved
11: **
12: *************************************************************************/
13:
14:
15: #include "outline.h"
16:
17: OLEDBGDATA
18:
19: extern LPOUTLINEAPP g_lpApp;
20:
21: char ErrMsgListBox[] = "Can't create ListBox!";
22:
23: static int g_iMapMode;
24:
25: /* LineList_Init
26: * -------------
27: *
28: * Create and Initialize the LineList (owner-drawn listbox)
29: */
30: BOOL LineList_Init(LPLINELIST lpLL, LPOUTLINEDOC lpOutlineDoc)
31: {
32: LPOUTLINEAPP lpOutlineApp = (LPOUTLINEAPP)g_lpApp;
33:
34: #if defined( INPLACE_CNTR )
35: lpLL->m_hWndListBox = CreateWindow(
36: "listbox", /* Window class name */
37: NULL, /* Window's title */
38: WS_CHILDWINDOW |
39:
40: /* OLE2NOTE: an in-place contanier MUST use
41: ** WS_CLIPCHILDREN window style for the window
42: ** that it uses as the parent for the server's
43: ** in-place active window so that its
44: ** painting does NOT interfere with the painting
45: ** of the server's in-place active child window.
46: */
47:
48: WS_CLIPCHILDREN |
49: WS_VISIBLE |
50: WS_VSCROLL |
51: WS_HSCROLL |
52: LBS_EXTENDEDSEL |
53: LBS_NOTIFY |
54: LBS_OWNERDRAWVARIABLE |
55: LBS_NOINTEGRALHEIGHT |
56: LBS_USETABSTOPS,
57: 0, 0, /* Use default X, Y */
58: 0, 0, /* Use default X, Y */
59: lpOutlineDoc->m_hWndDoc,/* Parent window's handle */
60: (HMENU)IDC_LINELIST, /* Child Window ID */
61: lpOutlineApp->m_hInst, /* Instance of window */
62: NULL); /* Create struct for WM_CREATE */
63: #else
64: lpLL->m_hWndListBox = CreateWindow(
65: "listbox", /* Window class name */
66: NULL, /* Window's title */
67: WS_CHILDWINDOW |
68: WS_VISIBLE |
69: WS_VSCROLL |
70: WS_HSCROLL |
71: LBS_EXTENDEDSEL |
72: LBS_NOTIFY |
73: LBS_OWNERDRAWVARIABLE |
74: LBS_NOINTEGRALHEIGHT |
75: LBS_USETABSTOPS,
76: 0, 0, /* Use default X, Y */
77: 0, 0, /* Use default X, Y */
78: lpOutlineDoc->m_hWndDoc,/* Parent window's handle */
79: (HMENU)IDC_LINELIST, /* Child Window ID */
80: lpOutlineApp->m_hInst, /* Instance of window */
81: NULL); /* Create struct for WM_CREATE */
82:
83: #endif
84:
85:
86: if(! lpLL->m_hWndListBox) {
87: OutlineApp_ErrorMessage(g_lpApp, ErrMsgListBox);
88: return FALSE;
89: }
90:
91: lpOutlineApp->m_ListBoxWndProc =
92: (FARPROC) GetWindowLong ( lpLL->m_hWndListBox, GWL_WNDPROC );
93: SetWindowLong (lpLL->m_hWndListBox, GWL_WNDPROC, (LONG) LineListWndProc);
94:
95: #if defined ( USE_DRAGDROP )
96: /* m_iDragOverLine saves index of line that has drag/drop target
97: ** feedback. we currently use our focus rectangle feedback for
98: ** this. it would be better to have a different visual feedback
99: ** for potential target of the pending drop.
100: */
101: lpLL->m_iDragOverLine = -1;
102: #endif
103:
104: lpLL->m_nNumLines = 0;
105: lpLL->m_nMaxLineWidthInHimetric = 0;
106: lpLL->m_lpDoc = lpOutlineDoc;
107: _fmemset(&lpLL->m_lrSaveSel, 0, sizeof(LINERANGE));
108:
109: return TRUE;
110: }
111:
112:
113: /* LineList_Destroy
114: * ----------------
115: *
116: * Clear (delete) all Line objects from the list and free supporting
117: * memory (ListBox Window) used by the LineList object itself.
118: */
119: void LineList_Destroy(LPLINELIST lpLL)
120: {
121: int i;
122: int linesTotal = lpLL->m_nNumLines;
123:
124: // Delete all Line objects
125: for (i = 0; i < linesTotal; i++)
126: LineList_DeleteLine(lpLL, 0); // NOTE: always delete line 0
127:
128: // Remove all Lines from the ListBox
129: SendMessage(lpLL->m_hWndListBox,LB_RESETCONTENT,0,0L);
130:
131: lpLL->m_nNumLines=0;
132: DestroyWindow(lpLL->m_hWndListBox);
133: lpLL->m_hWndListBox = NULL;
134: }
135:
136:
137: /* LineList_AddLine
138: * ----------------
139: *
140: * Add one line to the list box. The line is added following the
141: * line with index "nIndex". If nIndex is larger than the number of lines
142: * in the ListBox, then the line is appended to the end. The selection
143: * is set to the newly added line.
144: */
145: void LineList_AddLine(LPLINELIST lpLL, LPLINE lpLine, int nIndex)
146: {
147: int nAddIndex = (lpLL->m_nNumLines == 0 ?
148: 0 :
149: (nIndex >= lpLL->m_nNumLines ? lpLL->m_nNumLines : nIndex+1));
150: LINERANGE lrSel;
151:
152: #if defined( USE_HEADING )
153: int nHeight = Line_GetHeightInHimetric(lpLine);
154:
155: nHeight = XformHeightInHimetricToPixels(NULL, nHeight);
156:
157: // Add a dummy string to the row heading
158: Heading_RH_SendMessage(OutlineDoc_GetHeading(lpLL->m_lpDoc),
159: LB_INSERTSTRING, (WPARAM)nAddIndex, MAKELPARAM(nHeight, 0));
160: #endif
161:
162:
163: lrSel.m_nStartLine = nAddIndex;
164: lrSel.m_nEndLine = nAddIndex;
165:
166: if (!lpLine) {
167: OutlineApp_ErrorMessage(g_lpApp, "Could not create line.");
168: return;
169: }
170:
171: SendMessage(lpLL->m_hWndListBox, LB_INSERTSTRING, (WPARAM)nAddIndex,
172: (DWORD)lpLine);
173:
174: LineList_SetMaxLineWidthInHimetric(
175: lpLL,
176: Line_GetTotalWidthInHimetric(lpLine)
177: );
178:
179: lpLL->m_nNumLines++;
180:
181: LineList_SetSel(lpLL, &lrSel);
182: }
183:
184:
185: /* LineList_DeleteLine
186: * -------------------
187: *
188: * Delete one line from listbox and memory
189: */
190: void LineList_DeleteLine(LPLINELIST lpLL, int nIndex)
191: {
192: LPLINE lpLine = LineList_GetLine(lpLL, nIndex);
193: BOOL fResetSel;
194:
195: fResetSel = (BOOL)SendMessage(lpLL->m_hWndListBox, LB_GETSEL, (WPARAM)nIndex, 0L);
196:
197: if (lpLine)
198: Line_Delete(lpLine); // free memory of Line
199:
200: // Remove the Line from the ListBox
201: SendMessage(lpLL->m_hWndListBox, LB_DELETESTRING, (WPARAM)nIndex, 0L);
202: lpLL->m_nNumLines--;
203:
204: if (fResetSel) {
205: if (nIndex > 0) {
206: #if defined( WIN32 )
207: SendMessage(
208: lpLL->m_hWndListBox,
209: LB_SETSEL,
210: (WPARAM)TRUE,
211: (LPARAM)nIndex-1
212: );
213: #else
214: SendMessage(
215: lpLL->m_hWndListBox,
216: LB_SETSEL,
217: (WPARAM)TRUE,
218: MAKELPARAM(nIndex-1,0)
219: );
220: #endif
221: } else {
222: if (lpLL->m_nNumLines > 0) {
223: #if defined( WIN32 )
224: SendMessage(
225: lpLL->m_hWndListBox,
226: LB_SETSEL,
227: (WPARAM)TRUE,
228: (LPARAM)0
229: );
230: #else
231: SendMessage(
232: lpLL->m_hWndListBox,
233: LB_SETSEL,
234: (WPARAM)TRUE,
235: MAKELPARAM(0,0)
236: );
237: #endif
238: }
239: }
240: }
241:
242: #if defined( USE_HEADING )
243: // Remove the dummy string from the row heading
244: Heading_RH_SendMessage(OutlineDoc_GetHeading(lpLL->m_lpDoc),
245: LB_DELETESTRING, (WPARAM)nIndex, 0L);
246: #endif
247:
248: }
249:
250:
251: /* LineList_ReplaceLine
252: * --------------------
253: *
254: * Replace the line at a given index in the list box with a new
255: * line.
256: */
257: void LineList_ReplaceLine(LPLINELIST lpLL, LPLINE lpLine, int nIndex)
258: {
259: LPLINE lpOldLine = LineList_GetLine(lpLL, nIndex);
260:
261: if (lpOldLine)
262: Line_Delete(lpOldLine); // free memory of Line
263: else
264: return; // if no previous line then invalid index
265:
266: SendMessage(
267: lpLL->m_hWndListBox,
268: LB_SETITEMDATA,
269: (WPARAM)nIndex,
270: (LPARAM)lpLine
271: );
272: }
273:
274:
275: /* LineList_GetLineIndex
276: * ---------------------
277: *
278: * Return the index of the Line given a pointer to the line.
279: * Return -1 if the line is not found.
280: */
281: int LineList_GetLineIndex(LPLINELIST lpLL, LPLINE lpLine)
282: {
283: LRESULT lReturn;
284:
285: if (! lpLine) return -1;
286:
287: lReturn = SendMessage(
288: lpLL->m_hWndListBox,
289: LB_FINDSTRING,
290: (WPARAM)-1,
291: (LPARAM)(LPCSTR)lpLine
292: );
293:
294: return ((lReturn == LB_ERR) ? -1 : (int)lReturn);
295: }
296:
297:
298: /* LineList_GetLine
299: * ----------------
300: *
301: * Retrieve the pointer to the Line given its index in the LineList
302: */
303: LPLINE LineList_GetLine(LPLINELIST lpLL, int nIndex)
304: {
305: DWORD dWord = 0;
306: LPLINE lpLine;
307:
308: if (lpLL->m_nNumLines == 0 || nIndex > lpLL->m_nNumLines || nIndex < 0)
309: return NULL;
310:
311: SendMessage(lpLL->m_hWndListBox,LB_GETTEXT,nIndex,(LPARAM)(LPCSTR)&dWord);
312: lpLine=(LPLINE)dWord;
313: return lpLine;
314: }
315:
316:
317: /* LineList_SetFocusLine
318: * ---------------------
319: *
320: */
321:
322: void LineList_SetFocusLine ( LPLINELIST lpLL, WORD wIndex )
323: {
324:
325: SendMessage(lpLL->m_hWndListBox, LB_SETCARETINDEX, (WPARAM)wIndex, 0L );
326:
327: }
328:
329:
330: /* LineList_GetLineRect
331: * --------------------
332: *
333: * Retrieve the rectangle of a Line given its index in the LineList
334: */
335: BOOL LineList_GetLineRect(LPLINELIST lpLL, int nIndex, LPRECT lpRect)
336: {
337: DWORD iReturn = (DWORD)LB_ERR;
338:
339: if ( !(lpLL->m_nNumLines == 0 || nIndex > lpLL->m_nNumLines || nIndex < 0) )
340: iReturn = SendMessage(lpLL->m_hWndListBox,LB_GETITEMRECT,nIndex,(LPARAM)lpRect);
341:
342: return (iReturn == LB_ERR ? FALSE : TRUE );
343: }
344:
345:
346: /* LineList_GetFocusLineIndex
347: * --------------------------
348: *
349: * Get the index of the line that currently has focus (the active line).
350: */
351: int LineList_GetFocusLineIndex(LPLINELIST lpLL)
352: {
353: return (int)SendMessage(lpLL->m_hWndListBox,LB_GETCARETINDEX,0,0L);
354: }
355:
356:
357: /* LineList_GetCount
358: * -----------------
359: *
360: * Return number of line objects
361: */
362: int LineList_GetCount(LPLINELIST lpLL)
363: {
364: if (lpLL)
365: return lpLL->m_nNumLines;
366: else {
367: OleDbgAssert(lpLL!=NULL);
368: return 0;
369: }
370: }
371:
372:
373: /* LineList_SetMaxLineWidthInHimetric
374: * ----------------------------------
375: *
376: * Adjust the maximum line width for the listbox. The max line width is
377: * used to determine if a horizontal scroll bar is needed.
378: *
379: * Parameters:
380: * nWidthInHimetric - if +ve, width of an additional line
381: * - if -ve, reset Max to be the value
382: *
383: * Returns:
384: * TRUE is max line width of LineList changed
385: * FALSE if no change
386: */
387: BOOL LineList_SetMaxLineWidthInHimetric(LPLINELIST lpLL, int nWidthInHimetric)
388: {
389: int nWidthInPix;
390: BOOL fSizeChanged = FALSE;
391: LPSCALEFACTOR lpscale;
392:
393: if (!lpLL)
394: return FALSE;
395:
396: lpscale = OutlineDoc_GetScaleFactor(lpLL->m_lpDoc);
397:
398: if (nWidthInHimetric < 0) {
399: lpLL->m_nMaxLineWidthInHimetric = -1;
400: nWidthInHimetric *= -1;
401: }
402:
403: if (nWidthInHimetric > lpLL->m_nMaxLineWidthInHimetric) {
404: lpLL->m_nMaxLineWidthInHimetric = nWidthInHimetric;
405: nWidthInPix = XformWidthInHimetricToPixels(NULL, nWidthInHimetric +
406: LOWORD(OutlineDoc_GetMargin(lpLL->m_lpDoc)) +
407: HIWORD(OutlineDoc_GetMargin(lpLL->m_lpDoc)));
408:
409: nWidthInPix = (int)(nWidthInPix * lpscale->dwSxN / lpscale->dwSxD);
410: SendMessage(
411: lpLL->m_hWndListBox,
412: LB_SETHORIZONTALEXTENT,
413: nWidthInPix,
414: 0L
415: );
416: fSizeChanged = TRUE;
417:
418: #if defined( USE_HEADING )
419: Heading_CH_SetHorizontalExtent(
420: OutlineDoc_GetHeading(lpLL->m_lpDoc), lpLL->m_hWndListBox);
421: #endif
422:
423: }
424: return fSizeChanged;
425: }
426:
427:
428: /* LineList_GetMaxLineWidthInHimetric
429: * ----------------------------------
430: *
431: * Return the width of the widest line
432: */
433: int LineList_GetMaxLineWidthInHimetric(LPLINELIST lpLL)
434: {
435: return lpLL->m_nMaxLineWidthInHimetric;
436: }
437:
438:
439: /* LineList_RecalcMaxLineWidthInHimetric
440: * -------------------------------------
441: *
442: * Recalculate the maximum line width in the entire list.
443: *
444: * Parameters:
445: * nWidthInHimetric should be set to the width of line being removed.
446: * nWidthInHimetric == 0 forces list to recalculate in all cases.
447: * nWidthInHimetric == current max width => forces recalc.
448: *
449: * Returns:
450: * TRUE is max line width of LineList changed
451: * FALSE if no change
452: */
453: BOOL LineList_RecalcMaxLineWidthInHimetric(
454: LPLINELIST lpLL,
455: int nWidthInHimetric
456: )
457: {
458: int i;
459: LPLINE lpLine;
460: BOOL fSizeChanged = FALSE;
461: int nOrgMaxLineWidthInHimetric = lpLL->m_nMaxLineWidthInHimetric;
462:
463: if (nWidthInHimetric == 0 ||
464: nWidthInHimetric == lpLL->m_nMaxLineWidthInHimetric) {
465:
466: lpLL->m_nMaxLineWidthInHimetric = -1;
467:
468: LineList_SetMaxLineWidthInHimetric(lpLL, 0);
469:
470: for(i = 0; i < lpLL->m_nNumLines; i++) {
471: lpLine=LineList_GetLine(lpLL, i);
472: LineList_SetMaxLineWidthInHimetric(
473: lpLL,
474: Line_GetTotalWidthInHimetric(lpLine)
475: );
476: }
477: }
478:
479: if (nOrgMaxLineWidthInHimetric != lpLL->m_nMaxLineWidthInHimetric)
480: fSizeChanged = TRUE;
481:
482: return fSizeChanged;
483: }
484:
485:
486: /* LineList_CalcSelExtentInHimetric
487: * --------------------------------
488: *
489: * Calculate the extents (widht and height) of a selection of lines.
490: *
491: * if lplrSel == NULL, calculate extent of all lines.
492: */
493: void LineList_CalcSelExtentInHimetric(
494: LPLINELIST lpLL,
495: LPLINERANGE lplrSel,
496: LPSIZEL lpsizel
497: )
498: {
499: int i;
500: int nEndLine;
501: int nStartLine;
502: LPLINE lpLine;
503: long lWidth;
504:
505: if (lplrSel) {
506: nEndLine = lplrSel->m_nEndLine;
507: nStartLine = lplrSel->m_nStartLine;
508: } else {
509: nEndLine = LineList_GetCount(lpLL) - 1;
510: nStartLine = 0;
511: }
512:
513: lpsizel->cx = 0;
514: lpsizel->cy = 0;
515:
516: for(i = nStartLine; i <= nEndLine; i++) {
517: lpLine=LineList_GetLine(lpLL,i);
518: lWidth = (long)Line_GetTotalWidthInHimetric(lpLine);
519: lpsizel->cx = max(lpsizel->cx, lWidth);
520: lpsizel->cy += lpLine->m_nHeightInHimetric;
521: }
522: }
523:
524:
525: /* LineList_GetWindow
526: * ------------------
527: *
528: * Return handle of list box
529: */
530: HWND LineList_GetWindow(LPLINELIST lpLL)
531: {
532: return lpLL->m_hWndListBox;
533: }
534:
535:
536: /* LineList_GetDC
537: * --------------
538: *
539: * Return DC handle of list box
540: */
541: HDC LineList_GetDC(LPLINELIST lpLL)
542: {
543: HFONT hfontOld;
544: HDC hDC = GetDC(lpLL->m_hWndListBox);
545: int iXppli; //* pixels per logical inch along width
546: int iYppli; //* pixels per logical inch along height
547: SIZE size;
548:
549: // Setup a mapping mode for the DC which maps physical pixel
550: // coordinates to HIMETRIC units. The standard MM_HIMETRIC mapping
551: // mode does not work correctly because it does not take into
552: // account that a logical inch on the display screen is drawn
553: // physically larger than 1 inch. We will setup an anisotropic
554: // mapping mode which will perform the transformation properly.
555:
556: g_iMapMode = SetMapMode(hDC, MM_ANISOTROPIC);
557: iXppli = GetDeviceCaps (hDC, LOGPIXELSX);
558: iYppli = GetDeviceCaps (hDC, LOGPIXELSY);
559: SetViewportExtEx(hDC, iXppli, iYppli, &size);
560: SetWindowExtEx(hDC, HIMETRIC_PER_INCH, HIMETRIC_PER_INCH, &size);
561:
562: // Set the default font size, and font face name
563: hfontOld = SelectObject(hDC, OutlineApp_GetActiveFont(g_lpApp));
564:
565: return hDC;
566: }
567:
568:
569: /* LineList_ReleaseDC
570: * ------------------
571: *
572: * Release DC of list box returned from previous LineList_GetDC call.
573: */
574: void LineList_ReleaseDC(LPLINELIST lpLL, HDC hDC)
575: {
576: SetMapMode(hDC, g_iMapMode);
577: ReleaseDC(lpLL->m_hWndListBox, hDC);
578: }
579:
580:
581: /* LineList_SetLineHeight
582: * ----------------------
583: *
584: * Set the height of a line in the LineList list box
585: */
586: void LineList_SetLineHeight(LPLINELIST lpLL,int nIndex,int nHeightInHimetric)
587: {
588: LPARAM lParam;
589: LPOUTLINEDOC lpDoc;
590: LPSCALEFACTOR lpscale;
591: UINT uHeightInPix;
592: LPHEADING lphead;
593:
594: if (!lpLL)
595: return;
596:
597: lpDoc = lpLL->m_lpDoc;
598: lphead = OutlineDoc_GetHeading(lpDoc);
599: lpscale = OutlineDoc_GetScaleFactor(lpDoc);
600:
601: uHeightInPix = XformHeightInHimetricToPixels(NULL, nHeightInHimetric);
602:
603: Heading_RH_SendMessage(lphead, LB_SETITEMDATA, (WPARAM)nIndex,
604: MAKELPARAM(uHeightInPix, 0));
605:
606: uHeightInPix = (UINT)(uHeightInPix * lpscale->dwSyN / lpscale->dwSyD);
607:
608: if (uHeightInPix > LISTBOX_HEIGHT_LIMIT)
609: uHeightInPix = LISTBOX_HEIGHT_LIMIT;
610:
611:
612: lParam = MAKELPARAM(uHeightInPix, 0);
613: SendMessage(lpLL->m_hWndListBox,LB_SETITEMHEIGHT,(WPARAM)nIndex, lParam);
614: Heading_RH_SendMessage(lphead, LB_SETITEMHEIGHT, (WPARAM)nIndex, lParam);
615: Heading_RH_ForceRedraw(lphead, TRUE);
616: }
617:
618:
619: /* LineList_ReScale
620: * ----------------
621: *
622: * Re-scale the LineList list box
623: */
624: void LineList_ReScale(LPLINELIST lpLL, LPSCALEFACTOR lpscale)
625: {
626: int nIndex;
627: LPLINE lpLine;
628: UINT uWidthInHim;
629:
630: if (!lpLL)
631: return;
632:
633: for (nIndex = 0; nIndex < lpLL->m_nNumLines; nIndex++) {
634: lpLine = LineList_GetLine(lpLL, nIndex);
635: LineList_SetLineHeight(
636: lpLL,
637: nIndex,
638: Line_GetHeightInHimetric(lpLine)
639: );
640: }
641:
642: uWidthInHim = LineList_GetMaxLineWidthInHimetric(lpLL);
643: LineList_SetMaxLineWidthInHimetric(lpLL, -(int)uWidthInHim);
644: }
645:
646: /* LineList_SetSel
647: * ---------------
648: *
649: * Set the selection in list box
650: */
651: void LineList_SetSel(LPLINELIST lpLL, LPLINERANGE lplrSel)
652: {
653: DWORD dwSel;
654:
655: if (lpLL->m_nNumLines <= 0 || lplrSel->m_nStartLine < 0)
656: return; // no lines in list; can't set a selection
657:
658: dwSel = MAKELPARAM(lplrSel->m_nStartLine, lplrSel->m_nEndLine);
659:
660: lpLL->m_lrSaveSel = *lplrSel;
661:
662: /* remove previous selection */
663: #if defined( WIN32 )
664: SendMessage(
665: lpLL->m_hWndListBox,
666: LB_SETSEL,
667: (WPARAM)FALSE,
668: (LPARAM)-1
669: );
670: #else
671: SendMessage(
672: lpLL->m_hWndListBox,
673: LB_SETSEL,
674: (WPARAM)FALSE,
675: MAKELPARAM(-1,0)
676: );
677: #endif
678:
679: /* mark selection */
680: SendMessage(lpLL->m_hWndListBox,LB_SELITEMRANGE, (WPARAM)TRUE, (LPARAM)dwSel);
681: /* set focus line (caret) */
682: LineList_SetFocusLine ( lpLL, (WORD)lplrSel->m_nStartLine );
683:
684: }
685:
686:
687: /* LineList_GetSel
688: * ---------------
689: *
690: * Get the selection in list box.
691: *
692: * Returns the count of items selected
693: */
694: int LineList_GetSel(LPLINELIST lpLL, LPLINERANGE lplrSel)
695: {
696: int nNumSel=(int)SendMessage(lpLL->m_hWndListBox,LB_GETSELCOUNT,0,0L);
697:
698: if (nNumSel) {
699: SendMessage(lpLL->m_hWndListBox,LB_GETSELITEMS,
700: (WPARAM)1,(LPARAM)(int FAR*)&(lplrSel->m_nStartLine));
701: lplrSel->m_nEndLine = lplrSel->m_nStartLine + nNumSel - 1;
702: } else {
703: _fmemset(lplrSel, 0, sizeof(LINERANGE));
704: }
705: return nNumSel;
706: }
707:
708:
709: /* LineList_RemoveSel
710: * ------------------
711: *
712: * Remove the selection in list box but save the selection state so that
713: * it can be restored by calling LineList_RestoreSel
714: * LineList_RemoveSel is called when the LineList window looses focus.
715: */
716: void LineList_RemoveSel(LPLINELIST lpLL)
717: {
718: LINERANGE lrSel;
719: if (LineList_GetSel(lpLL, &lrSel) > 0) {
720: lpLL->m_lrSaveSel = lrSel;
721: #if defined( WIN32 )
722: SendMessage(
723: lpLL->m_hWndListBox,
724: LB_SETSEL,
725: (WPARAM)FALSE,
726: (LPARAM)-1
727: );
728: #else
729: SendMessage(
730: lpLL->m_hWndListBox,
731: LB_SETSEL,
732: (WPARAM)FALSE,
733: MAKELPARAM(-1,0)
734: );
735: #endif
736: }
737: }
738:
739:
740: /* LineList_RestoreSel
741: * ------------------
742: *
743: * Restore the selection in list box that was previously saved by a call to
744: * LineList_RemoveSel.
745: * LineList_RestoreSel is called when the LineList window gains focus.
746: */
747: void LineList_RestoreSel(LPLINELIST lpLL)
748: {
749: LineList_SetSel(lpLL, &lpLL->m_lrSaveSel);
750: }
751:
752:
753: /* LineList_SetRedraw
754: * ------------------
755: *
756: * Enable/Disable the redraw of the linelist (listbox) on screen
757: *
758: * fEnbaleDraw = TRUE - enable redraw
759: * FALSE - disable redraw
760: */
761: void LineList_SetRedraw(LPLINELIST lpLL, BOOL fEnableDraw)
762: {
763: SendMessage(lpLL->m_hWndListBox,WM_SETREDRAW,(WPARAM)fEnableDraw,0L);
764: }
765:
766:
767: /* LineList_ForceRedraw
768: * --------------------
769: *
770: * Force redraw of the linelist (listbox) on screen
771: */
772: void LineList_ForceRedraw(LPLINELIST lpLL, BOOL fErase)
773: {
774: InvalidateRect(lpLL->m_hWndListBox, NULL, fErase);
775: }
776:
777:
778: /* LineList_ForceLineRedraw
779: * ------------------------
780: *
781: * Force a particular line of the linelist (listbox) to redraw.
782: */
783: void LineList_ForceLineRedraw(LPLINELIST lpLL, int nIndex, BOOL fErase)
784: {
785: RECT rect;
786:
787: LineList_GetLineRect( lpLL, nIndex, (LPRECT)&rect );
788: InvalidateRect( lpLL->m_hWndListBox, (LPRECT)&rect, fErase );
789: }
790:
791:
792: /* LineList_ScrollLineIntoView
793: * ---------------------------
794: * Make sure that the specified line is in view; if necessary scroll
795: * the listbox. if any portion of the line is visible, then no
796: * scrolling will occur.
797: */
798: void LineList_ScrollLineIntoView(LPLINELIST lpLL, int nIndex)
799: {
800: RECT rcWindow;
801: RECT rcLine;
802: RECT rcInt;
803:
804: if ( lpLL->m_nNumLines == 0 )
805: return;
806:
807: if (! LineList_GetLineRect( lpLL, nIndex, (LPRECT)&rcLine ) )
808: return;
809:
810: GetClientRect( lpLL->m_hWndListBox, (LPRECT) &rcWindow );
811:
812: if (! IntersectRect((LPRECT)&rcInt, (LPRECT)&rcWindow, (LPRECT)&rcLine))
813: SendMessage(
814: lpLL->m_hWndListBox,
815: LB_SETTOPINDEX,
816: (WPARAM)nIndex,
817: (LPARAM)NULL
818: );
819: }
820:
821:
822: /* LineList_CopySelToDoc
823: * ---------------------
824: *
825: * Copy the selection of the linelist to another document
826: *
827: * RETURNS: number of lines copied.
828: */
829: int LineList_CopySelToDoc(
830: LPLINELIST lpSrcLL,
831: LPLINERANGE lplrSel,
832: LPOUTLINEDOC lpDestDoc
833: )
834: {
835: int nEndLine;
836: int nStartLine;
837: LPLINELIST lpDestLL = &lpDestDoc->m_LineList;
838: signed short nDestIndex = LineList_GetFocusLineIndex(lpDestLL);
839: LPLINE lpSrcLine;
840: int nCopied = 0;
841: int i;
842:
843: if (lplrSel) {
844: nEndLine = lplrSel->m_nEndLine;
845: nStartLine = lplrSel->m_nStartLine;
846: } else {
847: nEndLine = LineList_GetCount(lpSrcLL) - 1;
848: nStartLine = 0;
849: }
850:
851: for(i = nStartLine; i <= nEndLine; i++) {
852: lpSrcLine = LineList_GetLine(lpSrcLL, i);
853: if (lpSrcLine && Line_CopyToDoc(lpSrcLine, lpDestDoc, nDestIndex)) {
854: nDestIndex++;
855: nCopied++;
856: }
857: }
858:
859: return nCopied;
860: }
861:
862:
863: /* LineList_SaveSelToStg
864: * ---------------------
865: *
866: * Save lines in selection into lpDestStg.
867: *
868: * Return TRUE if ok, FALSE if error
869: */
870: BOOL LineList_SaveSelToStg(
871: LPLINELIST lpLL,
872: LPLINERANGE lplrSel,
873: UINT uFormat,
874: LPSTORAGE lpSrcStg,
875: LPSTORAGE lpDestStg,
876: LPSTREAM lpLLStm,
877: BOOL fRemember
878: )
879: {
880: int nEndLine;
881: int nStartLine;
882: int nNumLinesWritten = 0;
883: HRESULT hrErr = NOERROR;
884: ULONG nWritten;
885: LPLINE lpLine;
886: LINELISTHEADER llhRecord;
887: int i;
888: LARGE_INTEGER dlibSaveHeaderPos;
889: LARGE_INTEGER dlibZeroOffset;
890: LISet32( dlibZeroOffset, 0 );
891:
892: if (lplrSel) {
893: nEndLine = lplrSel->m_nEndLine;
894: nStartLine = lplrSel->m_nStartLine;
895: } else {
896: nEndLine = LineList_GetCount(lpLL) - 1;
897: nStartLine = 0;
898: }
899:
900: _fmemset((LPLINELISTHEADER)&llhRecord,0,sizeof(LINELISTHEADER));
901:
902: /* save seek position for LineList header record */
903: hrErr = lpLLStm->lpVtbl->Seek(
904: lpLLStm,
905: dlibZeroOffset,
906: STREAM_SEEK_CUR,
907: (ULARGE_INTEGER FAR*)&dlibSaveHeaderPos
908: );
909: if (hrErr != NOERROR) goto error;
910:
911: /* write LineList header record */
912: hrErr = lpLLStm->lpVtbl->Write(
913: lpLLStm,
914: (LPVOID)&llhRecord,
915: sizeof(LINELISTHEADER),
916: &nWritten
917: );
918: if (hrErr != NOERROR) goto error;
919:
920: for(i = nStartLine; i <= nEndLine; i++) {
921: lpLine = LineList_GetLine(lpLL, i);
922: if(Line_SaveToStg(lpLine, uFormat, lpSrcStg, lpDestStg, lpLLStm,
923: fRemember))
924: llhRecord.m_nNumLines++;
925: }
926:
927: /* retore seek position for LineList header record */
928: hrErr = lpLLStm->lpVtbl->Seek(
929: lpLLStm,
930: dlibSaveHeaderPos,
931: STREAM_SEEK_SET,
932: NULL
933: );
934: if (hrErr != NOERROR) goto error;
935:
936: /* write LineList header record */
937: hrErr = lpLLStm->lpVtbl->Write(
938: lpLLStm,
939: (LPVOID)&llhRecord,
940: sizeof(LINELISTHEADER),
941: &nWritten
942: );
943: if (hrErr != NOERROR) goto error;
944:
945: /* reset seek position to end of stream */
946: hrErr = lpLLStm->lpVtbl->Seek(
947: lpLLStm,
948: dlibZeroOffset,
949: STREAM_SEEK_END,
950: NULL
951: );
952: if (hrErr != NOERROR) goto error;
953:
954: return TRUE;
955:
956: error:
957: OleDbgAssertSz(
958: hrErr == NOERROR,
959: "Could not write LineList header to LineList stream"
960: );
961: return FALSE;
962: }
963:
964:
965: /* LineList_LoadFromStg
966: * --------------------
967: *
968: * Load lines into linelist from storage.
969: *
970: * Return TRUE if ok, FALSE if error
971: */
972: BOOL LineList_LoadFromStg(
973: LPLINELIST lpLL,
974: LPSTORAGE lpSrcStg,
975: LPSTREAM lpLLStm
976: )
977: {
978: HRESULT hrErr;
979: ULONG nRead;
980: LPLINE lpLine;
981: int i;
982: int nNumLines;
983: LINELISTHEADER llineRecord;
984:
985: /* write LineList header record */
986: hrErr = lpLLStm->lpVtbl->Read(
987: lpLLStm,
988: (LPVOID)&llineRecord,
989: sizeof(LINELISTHEADER),
990: &nRead
991: );
992:
993: if (! OleDbgVerifySz(hrErr == NOERROR,
994: "Could not read LineList header from LineList stream"))
995: goto error;
996:
997: nNumLines = llineRecord.m_nNumLines;
998:
999: for(i = 0; i < nNumLines; i++) {
1000: lpLine = Line_LoadFromStg(lpSrcStg, lpLLStm, lpLL->m_lpDoc);
1001: if (! lpLine)
1002: goto error;
1003:
1004: // Directly add lines to LineList without trying to update a NameTbl
1005: LineList_AddLine(lpLL, lpLine, i-1);
1006: }
1007:
1008: return TRUE;
1009:
1010: error:
1011: // Delete any Line objects that were created
1012: if (lpLL->m_nNumLines > 0) {
1013: int nNumLines = lpLL->m_nNumLines;
1014: for (i = 0; i < nNumLines; i++)
1015: LineList_DeleteLine(lpLL, i);
1016: }
1017:
1018: return FALSE;
1019: }
1020:
1021:
1022: #if defined( USE_DRAGDROP )
1023:
1024:
1025: /* LineList_SetFocusLineFromPointl
1026: * -------------------------------
1027: *
1028: */
1029:
1030: void LineList_SetFocusLineFromPointl( LPLINELIST lpLL, POINTL pointl )
1031: {
1032: int i = LineList_GetLineIndexFromPointl( lpLL, pointl );
1033:
1034: if ( i == (int)-1)
1035: return ;
1036: else
1037: LineList_SetFocusLine( lpLL, (WORD)i );
1038: }
1039:
1040:
1041: /* LineList_SetDragOverLineFromPointl
1042: * ----------------------------------
1043: *
1044: */
1045:
1046: void LineList_SetDragOverLineFromPointl ( LPLINELIST lpLL, POINTL pointl )
1047: {
1048: int nIndex = LineList_GetLineIndexFromPointl( lpLL, pointl );
1049: LPLINE lpline = LineList_GetLine( lpLL, nIndex );
1050:
1051: if (!lpline)
1052: return;
1053:
1054: if (! lpline->m_fDragOverLine) {
1055: /* user has dragged over a new line. force new drop target line
1056: ** to repaint so that drop feedback will be drawn.
1057: */
1058: lpline->m_fDragOverLine = TRUE;
1059: LineList_ForceLineRedraw( lpLL, nIndex, TRUE );
1060:
1061: if (lpLL->m_iDragOverLine!= -1 && lpLL->m_iDragOverLine!=nIndex) {
1062:
1063: /* force previous drop target line to repaint so that drop
1064: ** feedback will be undrawn
1065: */
1066: lpline = LineList_GetLine( lpLL, lpLL->m_iDragOverLine );
1067: if (lpline)
1068: lpline->m_fDragOverLine = FALSE;
1069:
1070: LineList_ForceLineRedraw( lpLL, lpLL->m_iDragOverLine, TRUE );
1071: }
1072:
1073: lpLL->m_iDragOverLine = nIndex;
1074:
1075: // Force repaint immediately
1076: UpdateWindow(lpLL->m_hWndListBox);
1077: }
1078: }
1079:
1080:
1081: /* LineList_Scroll
1082: * ---------------
1083: *
1084: * Scroll the LineList list box in the desired direction by one line.
1085: *
1086: * this function is called during a drag operation.
1087: */
1088:
1089: void LineList_Scroll(LPLINELIST lpLL, DWORD dwScrollDir)
1090: {
1091: switch (dwScrollDir) {
1092: case SCROLLDIR_UP:
1093: SendMessage( lpLL->m_hWndListBox, WM_VSCROLL, SB_LINEUP, 0L );
1094: break;
1095:
1096: case SCROLLDIR_DOWN:
1097: SendMessage( lpLL->m_hWndListBox, WM_VSCROLL, SB_LINEDOWN, 0L );
1098: break;
1099: }
1100: }
1101:
1102:
1103: /* LineList_GetLineIndexFromPointl
1104: * -------------------------------
1105: * do hit test to get index of line corresponding to pointl
1106: */
1107: int LineList_GetLineIndexFromPointl(LPLINELIST lpLL, POINTL pointl)
1108: {
1109: RECT rect;
1110: POINT point;
1111: DWORD i;
1112:
1113: point.x = (int)pointl.x;
1114: point.y = (int)pointl.y;
1115:
1116: ScreenToClient( lpLL->m_hWndListBox, &point);
1117:
1118: if ( lpLL->m_nNumLines == 0 )
1119: return -1;
1120:
1121: GetClientRect( lpLL->m_hWndListBox, (LPRECT) &rect );
1122:
1123: i = SendMessage( lpLL->m_hWndListBox, LB_GETTOPINDEX, (WPARAM)NULL, (LPARAM)NULL );
1124:
1125: for ( ;; i++){
1126:
1127: RECT rectItem;
1128:
1129: if (!LineList_GetLineRect( lpLL, (int)i, (LPRECT)&rectItem ) )
1130: return -1;
1131:
1132: if ( rectItem.top > rect.bottom )
1133: return -1;
1134:
1135: if ( rectItem.top <= point.y && point.y <= rectItem.bottom)
1136: return (int)i;
1137:
1138: }
1139:
1140: }
1141:
1142:
1143: /* LineList_RestoreDragFeedback
1144: * ----------------------------
1145: *
1146: * Retore the index of the line that currently has focus (the active line).
1147: */
1148: void LineList_RestoreDragFeedback(LPLINELIST lpLL)
1149: {
1150: LPLINE lpLine;
1151:
1152: if (lpLL->m_iDragOverLine < 0 )
1153: return;
1154:
1155: lpLine = LineList_GetLine( lpLL, lpLL->m_iDragOverLine);
1156:
1157: if (lpLine) {
1158:
1159: lpLine->m_fDragOverLine = FALSE;
1160: LineList_ForceLineRedraw( lpLL, lpLL->m_iDragOverLine, TRUE );
1161:
1162: // Force repaint immediately
1163: UpdateWindow(lpLL->m_hWndListBox);
1164: }
1165:
1166: lpLL->m_iDragOverLine = -1;
1167:
1168: }
1169:
1170: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.