![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to crempoly.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / ole20 / samples / dispdemo|
Return to crempoly.cpp CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / dispdemo |
1.1 root 1: /***
2: *crempoly.cpp
3: *
4: * Copyright (C) 1992, Microsoft Corporation. All Rights Reserved.
5: * Information Contained Herein Is Proprietary and Confidential.
6: *
7: *Purpose:
8: * This file contains the implementation of CRemPoly, the remote polygon
9: * class. This class presents a standard C++ vtable interface to the
10: * rest of the application, and hides the details of talking to the
11: * actual remote CPoly class exposed by the SPoly server. Each of
12: * the introduced methods is simply a cover for an IDispatch invocation
13: * of the actual method on the remote object.
14: *
15: *Implementation Notes:
16: *
17: *****************************************************************************/
18:
19: #include "dispdemo.h"
20: #include "crempoly.h"
21:
22: extern int g_fTrace;
23:
24: // method names on the CPoly class.
25: //
26: char FAR* CRemPoly::m_rgszMethods[] = {
27: "draw",
28: "dump",
29: "reset",
30: "addpoint",
31: "enumpoints",
32: "getxorigin",
33: "setxorigin",
34: "getyorigin",
35: "setyorigin",
36: "getwidth",
37: "setwidth",
38: "get_red",
39: "set_red",
40: "get_green",
41: "set_green",
42: "get_blue",
43: "set_blue"
44: };
45:
46: #ifdef _MAC
47: # define IfMac(X) (X)
48: # define IfWin(X)
49: #else
50: # define IfMac(X)
51: # define IfWin(X) (X)
52: #endif
53:
54:
55: CRemPoly::CRemPoly()
56: {
57: m_refs = 0;
58: m_pdisp = (IDispatch FAR*)NULL;
59: }
60:
61:
62: // A useful pre-initialized DISPATCHPARAMS, used on all the methods that
63: // take 0 arguments.
64: //
65: DISPPARAMS NEAR g_dispparamsNoArgs = {NULL, NULL, 0, 0};
66:
67:
68: /***
69: *HRESULT CRemPoly::Create(clsid, CRemPoly**)
70: *
71: *Purpose:
72: * This function creates an instance of the CRemPoly class, connects
73: * it to the IDispatch interface of the remote CPoly class, and learns
74: * the DISPIDs for the members (that we know about) exposed by that
75: * class.
76: *
77: *Entry:
78: * clsid = The CLSID of the CPoly we are to create. (taking this as a
79: * param is a bit weird, but allows us to connect to several remote
80: * versions.
81: *
82: *Exit:
83: * return value = HRESULT
84: *
85: * *pprempoly = pointer to the newly created CRemPoly, if successfyl.
86: *
87: ***********************************************************************/
88: HRESULT
89: CRemPoly::Create(CLSID clsid, CRemPoly FAR* FAR* pprempoly)
90: {
91: int i;
92: HRESULT hresult;
93: IUnknown FAR* punk;
94: CRemPoly FAR* prempoly;
95:
96:
97: prempoly = new FAR CRemPoly();
98: if(prempoly == (CRemPoly FAR*)NULL){
99: hresult = ResultFromScode(E_OUTOFMEMORY);
100: goto LError;
101: }
102: prempoly->AddRef();
103:
104: // create an instance of the remote CPoly class.
105: //
106: IfMac(DbPrintf("CoCreateInstance(CLSID_CPoly)"));
107: hresult = CoCreateInstance(
108: clsid, NULL, CLSCTX_LOCAL_SERVER, IID_IUnknown, (void FAR* FAR*)&punk);
109: if(hresult != NOERROR){
110: IfMac(DbPrintf("CoCreateInstance() = 0x%x", hresult));
111: IfWin(MessageBox(NULL, "Unable to create polygon object", NULL, MB_OK));
112: goto LFreeCRemPoly;
113: }
114:
115: // were going to talk to this remote instance via IDispatch.
116: //
117: IfMac(DbPrintf("QueryInterface(IID_IDispatch)"));
118: hresult = punk->QueryInterface(
119: IID_IDispatch, (void FAR* FAR*)&prempoly->m_pdisp);
120: if(hresult != NOERROR){
121: IfMac(DbPrintf("QueryInterface(IID_IDispatch) = 0x%x", hresult));
122: IfWin(MessageBox(NULL, "Unable to QueryInterface to IDispatch", NULL, MB_OK));
123: goto LReleaseUnk;
124: }
125:
126: // We learn *all* the member IDs up front. A more sophisticated
127: // implementation might defer learning about the IDs for a given
128: // method until the first time the method is invoked, thereby
129: // amortizing the creation costs.
130: //
131: IfMac(DbPrintf("GetIDsOfNames()"));
132: for(i = 0; i < IMETH_CREMPOLY_MAX; ++i){
133: hresult = prempoly->m_pdisp->GetIDsOfNames(
134: IID_NULL,
135: &prempoly->m_rgszMethods[i],
136: 1, LOCALE_USER_DEFAULT,
137: &prempoly->m_rgdispid[i]);
138: if(hresult != NOERROR){
139: IfMac(DbPrintf("GetIDsOfNames() = 0x%x", hresult));
140: IfWin(MessageBox(NULL, "Unrecognized member name", NULL, MB_OK));
141: goto LReleaseUnk;
142: }
143: }
144:
145: punk->Release();
146:
147: *pprempoly = prempoly;
148:
149: IfMac(DbPrintf("Object created."));
150:
151: return NOERROR;
152:
153: LReleaseUnk:;
154: punk->Release();
155:
156: LFreeCRemPoly:;
157: prempoly->Release();
158:
159: LError:;
160: return hresult;
161: }
162:
163:
164: //---------------------------------------------------------------------
165: // IUnknown methods
166: //---------------------------------------------------------------------
167:
168:
169: /***
170: *HRESULT CRemPoly::QueryInterface(REFIID, void**)
171: *
172: *Purpose:
173: * Standard Ole2 implementation of QueryInterface. This class
174: * supports the IUnknown interface, and introduces a number of
175: * nonvirtual members.
176: *
177: *Entry:
178: * riid = reference to the requested interface id
179: *
180: *Exit:
181: * return value = HRESULT
182: * *ppv = pointer to the requested interface, if successful.
183: *
184: ***********************************************************************/
185: STDMETHODIMP
186: CRemPoly::QueryInterface(REFIID riid, void FAR* FAR* ppv)
187: {
188: if(riid == IID_IUnknown){
189: *ppv = this;
190: AddRef();
191: return NOERROR;
192: }
193: return ResultFromScode(E_NOINTERFACE);
194: }
195:
196:
197: /***
198: *unsigned long CRemPoly::AddRef(void)
199: *
200: *Purpose:
201: * Add a reference to the instance.
202: *
203: *Entry:
204: * None
205: *
206: *Exit:
207: * return value = unsigned long. The resulting reference count.
208: *
209: ***********************************************************************/
210: STDMETHODIMP_(unsigned long)
211: CRemPoly::AddRef(void)
212: {
213: return ++m_refs;
214: }
215:
216:
217: /***
218: *unsigned long CRemPoly::Release(void)
219: *
220: *Purpose:
221: * Release a reference to the instance. If the reference count goes
222: * to zero, delete the instance.
223: *
224: *Entry:
225: * None
226: *
227: *Exit:
228: * return value = unsigned long. The resulting reference count.
229: *
230: ***********************************************************************/
231: STDMETHODIMP_(unsigned long)
232: CRemPoly::Release(void)
233: {
234: if(--m_refs == 0){
235: if(m_pdisp != (IDispatch FAR*)NULL){
236: m_pdisp->Release();
237: }
238: delete this;
239: return 0;
240: }
241: return m_refs;
242: }
243:
244:
245: //---------------------------------------------------------------------
246: // Introduced methods
247: //---------------------------------------------------------------------
248:
249:
250: /*
251: * Each of these methods is simply a cover for an IDispatch Invocation
252: * of the actual method on the remote CPoly class. This allows CRemPoly
253: * to present an interface that looks and acts just like the CPoly
254: * object, even though the actual work is being done in another process.
255: *
256: */
257:
258: /***
259: *HRESULT CRemPoly::Draw(void)
260: *
261: *Purpose:
262: * Invoke the Draw method on the remote CPoly instance.
263: *
264: *Entry:
265: * None
266: *
267: *Exit:
268: * return value = HRESULT
269: *
270: ***********************************************************************/
271: HRESULT
272: CRemPoly::Draw()
273: {
274: return m_pdisp->Invoke(
275: m_rgdispid[IMETH_CREMPOLY_DRAW],
276: IID_NULL,
277: LOCALE_USER_DEFAULT,
278: DISPATCH_METHOD,
279: &g_dispparamsNoArgs, NULL, NULL, NULL);
280: }
281:
282:
283: /***
284: *HRESULT CRemPoly::Dump(void)
285: *
286: *Purpose:
287: * Invoke the Dump() method on the remote CPoly instance. This method
288: * dumps the contained CPoints and writes the properties of the remote
289: * CPoly instance to the debug window.
290: *
291: *Entry:
292: * None
293: *
294: *Exit:
295: * return value = HRESULT
296: *
297: ***********************************************************************/
298: HRESULT
299: CRemPoly::Dump()
300: {
301: return m_pdisp->Invoke(
302: m_rgdispid[IMETH_CREMPOLY_DUMP],
303: IID_NULL,
304: LOCALE_USER_DEFAULT,
305: DISPATCH_METHOD,
306: &g_dispparamsNoArgs, NULL, NULL, NULL);
307: }
308:
309:
310: /***
311: *HRESULT CRemPoly::Reset(void)
312: *
313: *Purpose:
314: * Invoke the Reset() method on the remote CPoly instance. The Reset()
315: * method causes the remote CPoly to release all contained CPoints.
316: *
317: *Entry:
318: * None
319: *
320: *Exit:
321: * return value = HRESULT
322: *
323: ***********************************************************************/
324: HRESULT
325: CRemPoly::Reset()
326: {
327: return m_pdisp->Invoke(
328: m_rgdispid[IMETH_CREMPOLY_RESET],
329: IID_NULL,
330: LOCALE_USER_DEFAULT,
331: DISPATCH_METHOD,
332: &g_dispparamsNoArgs, NULL, NULL, NULL);
333: }
334:
335:
336: /***
337: *HRESULT CRemPoly::AddPoint(short, short)
338: *
339: *Purpose:
340: * Invoke the AddPoint method in the remote CPoly object to add a
341: * new point with the given coordinates to this instance.
342: *
343: *Entry:
344: * x,y = the x and y coordinates of the new point.
345: *
346: *Exit:
347: * return value = HRESULT
348: *
349: ***********************************************************************/
350: HRESULT
351: CRemPoly::AddPoint(short x, short y)
352: {
353: HRESULT hresult;
354: VARIANTARG varg[2];
355: DISPPARAMS dispparams;
356:
357: V_VT(&varg[0]) = VT_I2;
358: V_I2(&varg[0]) = y;
359:
360: V_VT(&varg[1]) = VT_I2;
361: V_I2(&varg[1]) = x;
362:
363: dispparams.cArgs = 2;
364: dispparams.rgvarg = varg;
365: dispparams.cNamedArgs = 0;
366: dispparams.rgdispidNamedArgs = NULL;
367:
368: hresult = m_pdisp->Invoke(
369: m_rgdispid[IMETH_CREMPOLY_ADDPOINT],
370: IID_NULL,
371: LOCALE_USER_DEFAULT,
372: DISPATCH_METHOD,
373: &dispparams, NULL, NULL, NULL);
374:
375: return hresult;
376: }
377:
378:
379: /***
380: *HRESULT CRemPoly::EnumPoints(IEnumVARIANT**)
381: *Purpose:
382: * Inoke the EnumPoints() method in the remote object to
383: * get a enumerator for the points contained in the current poly.
384: *
385: *Entry:
386: * None
387: *
388: *Exit:
389: * return value = HRESULT
390: *
391: * *ppenum = pointer to the point enumerator
392: *
393: ***********************************************************************/
394: HRESULT
395: CRemPoly::EnumPoints(IEnumVARIANT FAR* FAR* ppenum)
396: {
397: HRESULT hresult;
398: IEnumVARIANT FAR* penum;
399: VARIANT varResult, FAR* pvarResult;
400:
401:
402: pvarResult = &varResult;
403: VariantInit(pvarResult);
404: hresult = m_pdisp->Invoke(
405: m_rgdispid[IMETH_CREMPOLY_ENUMPOINTS],
406: IID_NULL,
407: LOCALE_USER_DEFAULT,
408: DISPATCH_METHOD,
409: &g_dispparamsNoArgs, pvarResult, NULL, NULL);
410:
411: if(hresult != NOERROR)
412: return hresult;
413:
414: if(V_VT(pvarResult) != VT_UNKNOWN)
415: return ResultFromScode(E_FAIL);
416:
417: hresult = V_UNKNOWN(pvarResult)->QueryInterface(
418: IID_IEnumVARIANT, (void FAR* FAR*)&penum);
419:
420: if(hresult == NOERROR)
421: *ppenum = penum;
422:
423: VariantClear(pvarResult);
424:
425: return NOERROR;
426: }
427:
428:
429: /***
430: *HRESULT CRemPoly::GetXOrigin(short*)
431: *
432: *Purpose:
433: * Invoke the GetXOrigin() method on the remote object to extract
434: * the current value of the XOrigin property.
435: *
436: *Entry:
437: * None
438: *
439: *Exit:
440: * return value = HRESULT
441: *
442: * *pxorg = the current X origin of the polygon.
443: *
444: ***********************************************************************/
445: HRESULT
446: CRemPoly::GetXOrigin(short FAR* pxorg)
447: {
448: HRESULT hresult;
449: VARIANT varResult;
450:
451: VariantInit(&varResult);
452: hresult = m_pdisp->Invoke(
453: m_rgdispid[IMETH_CREMPOLY_GETXORIGIN],
454: IID_NULL,
455: LOCALE_USER_DEFAULT,
456: DISPATCH_METHOD,
457: &g_dispparamsNoArgs, &varResult, NULL, NULL);
458:
459: if(hresult != NOERROR)
460: return hresult;
461:
462: *pxorg = V_I2(&varResult);
463:
464: return NOERROR;
465: }
466:
467:
468: /***
469: *HRESULT CRemPoly::SetXOrigin(short)
470: *
471: *Purpose:
472: * Invoke the SetXOrigin method on the remote object to set the
473: * XOrigin property of the polygon to the given value.
474: *
475: *Entry:
476: * xorg = the new X origin
477: *
478: *Exit:
479: * return value = HRESULT
480: *
481: ***********************************************************************/
482: HRESULT
483: CRemPoly::SetXOrigin(short xorg)
484: {
485: VARIANTARG varg;
486: DISPPARAMS dispparams;
487:
488:
489: V_VT(&varg) = VT_I2;
490: V_I2(&varg) = xorg;
491:
492: dispparams.cArgs = 1;
493: dispparams.cNamedArgs = 0;
494: dispparams.rgvarg = &varg;
495:
496: return m_pdisp->Invoke(
497: m_rgdispid[IMETH_CREMPOLY_SETXORIGIN],
498: IID_NULL,
499: LOCALE_USER_DEFAULT,
500: DISPATCH_METHOD,
501: &dispparams, NULL, NULL, NULL);
502: }
503:
504:
505: /***
506: *HRESULT CRemPoly::GetYOrigin(short*)
507: *
508: *Purpose:
509: * Invoke the GetYOrigin() method on the remote object to extract
510: * the current value of the YOrigin property.
511: *
512: *Entry:
513: * None
514: *
515: *Exit:
516: * return value = HRESULT
517: *
518: * *pyorg = the current Y origin of the polygon
519: *
520: ***********************************************************************/
521: HRESULT
522: CRemPoly::GetYOrigin(short FAR* pyorg)
523: {
524: HRESULT hresult;
525: VARIANT varResult;
526:
527:
528: VariantInit(&varResult);
529: hresult = m_pdisp->Invoke(
530: m_rgdispid[IMETH_CREMPOLY_GETYORIGIN],
531: IID_NULL,
532: LOCALE_USER_DEFAULT,
533: DISPATCH_METHOD,
534: &g_dispparamsNoArgs, &varResult, NULL, NULL);
535:
536: if(hresult != NOERROR)
537: return hresult;
538:
539: *pyorg = V_I2(&varResult);
540:
541: return hresult;
542: }
543:
544:
545: /***
546: *HRESULT CRemPoly::SetYOrigin(short)
547: *
548: *Purpose:
549: * Invoke the SetYOrigin method on the remote object to set the
550: * YOrigin property of the polygon to the given value.
551: *
552: *Entry:
553: * yorg = the new Y origin
554: *
555: *Exit:
556: * return value = HRESULT
557: *
558: ***********************************************************************/
559: HRESULT
560: CRemPoly::SetYOrigin(short yorg)
561: {
562: VARIANTARG varg;
563: DISPPARAMS dispparams;
564:
565: V_VT(&varg) = VT_I2;
566: V_I2(&varg) = yorg;
567:
568: dispparams.cArgs = 1;
569: dispparams.cNamedArgs = 0;
570: dispparams.rgvarg = &varg;
571:
572: return m_pdisp->Invoke(
573: m_rgdispid[IMETH_CREMPOLY_SETYORIGIN],
574: IID_NULL,
575: LOCALE_USER_DEFAULT,
576: DISPATCH_METHOD,
577: &dispparams, NULL, NULL, NULL);
578: }
579:
580:
581: /***
582: *HRESULT CRemPoly::GetWidth(short*)
583: *
584: *Purpose:
585: * Invoke the GetWidth() method on the remote object to extract
586: * the current value of the line width property.
587: *
588: *Entry:
589: * None
590: *
591: *Exit:
592: * return value = HRESULT
593: *
594: * *pwidth = short, the current line width of the polygon
595: *
596: ***********************************************************************/
597: HRESULT
598: CRemPoly::GetWidth(short FAR* pwidth)
599: {
600: HRESULT hresult;
601: VARIANT varResult;
602:
603:
604: hresult = m_pdisp->Invoke(
605: m_rgdispid[IMETH_CREMPOLY_GETWIDTH],
606: IID_NULL,
607: LOCALE_USER_DEFAULT,
608: DISPATCH_METHOD,
609: &g_dispparamsNoArgs, &varResult, NULL, NULL);
610:
611: if(hresult != NOERROR)
612: return hresult;
613:
614: *pwidth = V_I2(&varResult);
615:
616: return NOERROR;
617: }
618:
619:
620: /***
621: *HRESULT CRemPoly::SetWidth(short)
622: *
623: *Purpose:
624: * Invoke the SetWidth method on the remote object to set the
625: * line width property of the polygon to the given value.
626: *
627: *Entry:
628: * width = the new value for the line width property.
629: *
630: *Exit:
631: * return value = HRESULT
632: *
633: ***********************************************************************/
634: HRESULT
635: CRemPoly::SetWidth(short width)
636: {
637: VARIANTARG varg;
638: DISPPARAMS dispparams;
639:
640:
641: V_VT(&varg) = VT_I2;
642: V_I2(&varg) = width;
643:
644: dispparams.cArgs = 1;
645: dispparams.cNamedArgs = 0;
646: dispparams.rgvarg = &varg;
647:
648: return m_pdisp->Invoke(
649: m_rgdispid[IMETH_CREMPOLY_SETWIDTH],
650: IID_NULL,
651: LOCALE_USER_DEFAULT,
652: DISPATCH_METHOD,
653: &dispparams, NULL, NULL, NULL);
654: }
655:
656:
657: HRESULT CRemPoly::get_red(short FAR* psRed)
658: {
659: return get_i2(m_rgdispid[IMETH_CREMPOLY_GETRED], psRed);
660: }
661:
662: HRESULT CRemPoly::set_red(short sRed)
663: {
664: return set_i2(m_rgdispid[IMETH_CREMPOLY_SETRED], sRed);
665: }
666:
667:
668: HRESULT CRemPoly::get_green(short FAR* psGreen)
669: {
670: return get_i2(m_rgdispid[IMETH_CREMPOLY_GETGREEN], psGreen);
671: }
672:
673: HRESULT CRemPoly::set_green(short sGreen)
674: {
675: return set_i2(m_rgdispid[IMETH_CREMPOLY_SETGREEN], sGreen);
676: }
677:
678:
679: HRESULT CRemPoly::get_blue(short FAR* psBlue)
680: {
681: return get_i2(m_rgdispid[IMETH_CREMPOLY_GETBLUE], psBlue);
682: }
683:
684: HRESULT CRemPoly::set_blue(short sBlue)
685: {
686: return set_i2(m_rgdispid[IMETH_CREMPOLY_SETBLUE], sBlue);
687: }
688:
689: HRESULT
690: CRemPoly::get_i2(DISPID dispid, short FAR* ps)
691: {
692: HRESULT hresult;
693: VARIANT varResult;
694:
695: VariantInit(&varResult);
696:
697: hresult = m_pdisp->Invoke(
698: dispid,
699: IID_NULL,
700: LOCALE_SYSTEM_DEFAULT,
701: DISPATCH_METHOD,
702: &g_dispparamsNoArgs,
703: &varResult, NULL, NULL);
704:
705: if(hresult != NOERROR)
706: return hresult;
707:
708: hresult = VariantChangeType(&varResult, &varResult, 0, VT_I2);
709: if(hresult != NOERROR){
710: VariantClear(&varResult);
711: return hresult;
712: }
713:
714: *ps = V_I2(&varResult);
715: return NOERROR;
716: }
717:
718: HRESULT
719: CRemPoly::set_i2(DISPID dispid, short s)
720: {
721: VARIANTARG varg;
722: DISPPARAMS dispparams;
723:
724: V_VT(&varg) = VT_I2;
725: V_I2(&varg) = s;
726:
727: dispparams.cArgs = 1;
728: dispparams.cNamedArgs = 0;
729: dispparams.rgvarg = &varg;
730:
731: return m_pdisp->Invoke(
732: dispid,
733: IID_NULL,
734: LOCALE_SYSTEM_DEFAULT,
735: DISPATCH_METHOD,
736: &dispparams, NULL, NULL, NULL);
737: }
738:
739:
740: /***
741: *void DoPoly(CLSID)
742: *
743: *Purpose:
744: * This function simply exercises our CRemPoly class by creating an
745: * instance and invoking a number of its methods.
746: *
747: *Entry:
748: * None
749: *
750: *Exit:
751: * None
752: *
753: ***********************************************************************/
754: STDAPI
755: DoPoly(CLSID clsid)
756: {
757: HRESULT hr;
758: int numpoly, i, j;
759:
760: static struct {
761: short x;
762: short y;
763: } rgptPoly[] = {
764: { 25, 0}
765: , { 75, 0}
766: , {100, 25}
767: , {100, 75}
768: , { 75, 100}
769: , { 25, 100}
770: , { 0, 75}
771: , { 0, 25}
772: };
773:
774: static struct {
775: short red;
776: short green;
777: short blue;
778: } rgrgbColors[] = {
779: #ifdef _MAC
780: { 0, 0, 0}
781: , { 0, 0, 0x7fff}
782: , { 0, 0x7fff, 0}
783: , {0x7fff, 0, 0}
784: , {0x7fff, 0, 0x7fff}
785: , {0x7fff, 0x7fff, 0}
786: , {0x7fff, 0x7fff, 0x7fff}
787: #else
788: { 0, 0, 0}
789: , { 0, 0, 127}
790: , { 0, 127, 0}
791: , {127, 0, 0}
792: , {127, 0, 127}
793: , {127, 127, 0}
794: , {127, 127, 127}
795: #endif
796: };
797:
798: CRemPoly FAR* rgprempoly[DIM(rgrgbColors)];
799:
800: numpoly = DIM(rgprempoly);
801:
802: // init
803: for(i = 0; i < numpoly; ++i)
804: rgprempoly[i] = (CRemPoly FAR*)NULL;
805:
806: for(i = 0; i < numpoly; ++i){
807: hr = CRemPoly::Create(clsid, &rgprempoly[i]);
808: if(hr != NOERROR)
809: goto LError0;
810: IfMac(DbPrintf("CRemPoly::Create()"));
811:
812: for(j = 0; j < DIM(rgptPoly); ++j){
813: short x = rgptPoly[j].x;
814: short y = rgptPoly[j].y;
815: IfMac(DbPrintf("CRemPoly::AddPoint(%d,%d)", x, y));
816: hr = rgprempoly[i]->AddPoint(x, y);
817: ASSERT(hr == NOERROR);
818: }
819:
820: for(j = 0; j < DIM(rgrgbColors); ++j){
821: hr = rgprempoly[i]->SetWidth(i + j);
822: ASSERT(hr == NOERROR);
823: IfMac(DbPrintf("CRemPoly::SetWidth()"));
824:
825: hr = rgprempoly[i]->set_red(rgrgbColors[j].red);
826: ASSERT(hr == NOERROR);
827: IfMac(DbPrintf("CRemPoly::set_red()"));
828:
829: hr = rgprempoly[i]->set_green(rgrgbColors[j].green);
830: ASSERT(hr == NOERROR);
831: IfMac(DbPrintf("CRemPoly::set_green()"));
832:
833: hr = rgprempoly[i]->set_blue(rgrgbColors[j].blue);
834: ASSERT(hr == NOERROR);
835: IfMac(DbPrintf("CRemPoly::set_blue()"));
836:
837: hr = rgprempoly[i]->SetXOrigin((2*i) + j << 4);
838: ASSERT(hr == NOERROR);
839: IfMac(DbPrintf("CRemPoly::SetXOrigin()"));
840:
841: hr = rgprempoly[i]->SetYOrigin(j << 4);
842: ASSERT(hr == NOERROR);
843: IfMac(DbPrintf("CRemPoly::SetYOrigin()"));
844:
845: hr = rgprempoly[i]->Draw();
846: ASSERT(hr == NOERROR);
847: IfMac(DbPrintf("CRemPoly::Draw()"));
848: }
849: }
850:
851: hr = NOERROR;
852:
853: LError0:;
854: for(i = 0; i < numpoly; ++i){
855: if(rgprempoly[i] != (CRemPoly FAR*)NULL){
856: rgprempoly[i]->Release();
857: }
858: }
859:
860: return hr;
861: }
862:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.