![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to cpoly.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / ole20 / samples / spoly|
Return to cpoly.cpp CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / spoly |
1.1 ! root 1: /*** ! 2: *CPoly.cpp ! 3: * ! 4: * Copyright (C) 1992-93, Microsoft Corporation. All Rights Reserved. ! 5: * ! 6: *Purpose: ! 7: * This module implements the CPoly and CPolyCF classes. ! 8: * ! 9: * This module is intended as a sample implementation of the IDispatch ! 10: * interface, and its purpose is to demonstrate how an object can ! 11: * expose methods and properties for programatic and cross-process ! 12: * access via the IDispatch interface. ! 13: * ! 14: *Implementation Notes: ! 15: * ! 16: *****************************************************************************/ ! 17: ! 18: #include "spoly.h" ! 19: #include "cpoint.h" ! 20: #include "cpoly.h" ! 21: #include "cenumpt.h" ! 22: ! 23: #ifndef _MAC ! 24: extern CStatBar FAR* g_psb; ! 25: #endif ! 26: ! 27: ! 28: // our global list of polygons. ! 29: // ! 30: POLYLINK FAR* g_ppolylink = (POLYLINK FAR*)NULL; ! 31: ! 32: // global count of polygons. ! 33: // ! 34: int g_cPoly = 0; ! 35: ! 36: ! 37: CPoly::CPoly() ! 38: { ! 39: m_refs = 0; ! 40: m_xorg = 0; ! 41: m_yorg = 0; ! 42: m_width = 0; ! 43: m_cPoints = 0; ! 44: ! 45: m_red = 0; ! 46: m_green = 0; ! 47: m_blue = 0; ! 48: ! 49: m_ppointlink = NULL; ! 50: m_ppointlinkLast = NULL; ! 51: } ! 52: ! 53: ! 54: /*** ! 55: *CPoly *CPoly::Create(void) ! 56: *Purpose: ! 57: * Create an instance of a CPoly object, and add it to the global ! 58: * list of polygons. ! 59: * ! 60: *Entry: ! 61: * None ! 62: * ! 63: *Exit: ! 64: * returns a polygon object, NULL the allocation failed. ! 65: * ! 66: ***********************************************************************/ ! 67: CPoly FAR* ! 68: CPoly::Create() ! 69: { ! 70: CPoly FAR* ppoly; ! 71: POLYLINK FAR* ppolylink; ! 72: ! 73: if((ppolylink = new FAR POLYLINK) == (POLYLINK FAR*)NULL) ! 74: return (CPoly FAR*)NULL; ! 75: ! 76: if((ppoly = new FAR CPoly()) == (CPoly FAR*)NULL) ! 77: return (CPoly FAR*)NULL; ! 78: ! 79: ppoly->AddRef(); ! 80: ! 81: // push the new polygon onto the front of the polygon list. ! 82: // ! 83: ++g_cPoly; ! 84: ! 85: ppolylink->ppoly = ppoly; ! 86: ! 87: ppolylink->next = g_ppolylink; ! 88: g_ppolylink = ppolylink; ! 89: ! 90: #ifndef _MAC ! 91: SBprintf(g_psb, "#poly = %d", g_cPoly); ! 92: #endif ! 93: ! 94: return ppoly; ! 95: } ! 96: ! 97: ! 98: //--------------------------------------------------------------------- ! 99: // IUnknown Methods ! 100: //--------------------------------------------------------------------- ! 101: ! 102: ! 103: STDMETHODIMP ! 104: CPoly::QueryInterface(REFIID riid, void FAR* FAR* ppv) ! 105: { ! 106: if(riid != IID_IUnknown){ ! 107: if(riid != IID_IDispatch){ ! 108: *ppv = NULL; ! 109: return ResultFromScode(E_NOINTERFACE); ! 110: } ! 111: } ! 112: ! 113: *ppv = this; ! 114: AddRef(); ! 115: return NOERROR; ! 116: } ! 117: ! 118: ! 119: STDMETHODIMP_(unsigned long) ! 120: CPoly::AddRef() ! 121: { ! 122: return ++m_refs; ! 123: } ! 124: ! 125: ! 126: STDMETHODIMP_(unsigned long) ! 127: CPoly::Release() ! 128: { ! 129: POLYLINK FAR* FAR* pppolylink, FAR* ppolylinkDead; ! 130: ! 131: if(--m_refs == 0){ ! 132: Reset(); // release all CPoints ! 133: ! 134: // remove ourselves from the global list of polygons ! 135: // ! 136: for( pppolylink = &g_ppolylink; ! 137: *pppolylink != NULL; ! 138: pppolylink = &(*pppolylink)->next) ! 139: { ! 140: if((*pppolylink)->ppoly == this){ ! 141: ppolylinkDead = *pppolylink; ! 142: *pppolylink = (*pppolylink)->next; ! 143: delete ppolylinkDead; ! 144: break; ! 145: } ! 146: } ! 147: ! 148: --g_cPoly; ! 149: ! 150: #ifndef _MAC ! 151: SBprintf(g_psb, "#poly = %d", g_cPoly); ! 152: #endif ! 153: ! 154: delete this; ! 155: return 0; ! 156: } ! 157: return m_refs; ! 158: } ! 159: ! 160: ! 161: //--------------------------------------------------------------------- ! 162: // IDispatch Methods ! 163: //--------------------------------------------------------------------- ! 164: ! 165: ! 166: /* ! 167: * NOTE: Support for the following two methods is not available ! 168: * in this version. ! 169: * ! 170: */ ! 171: ! 172: STDMETHODIMP ! 173: CPoly::GetTypeInfoCount(unsigned int FAR* pctinfo) ! 174: { ! 175: *pctinfo = 0; ! 176: return NOERROR; ! 177: } ! 178: ! 179: ! 180: STDMETHODIMP ! 181: CPoly::GetTypeInfo(unsigned int itinfo, LCID lcid, ITypeInfo FAR* FAR* pptinfo) ! 182: { ! 183: UNUSED(itinfo); ! 184: UNUSED(lcid); ! 185: UNUSED(pptinfo); ! 186: ! 187: return ResultFromScode(E_NOTIMPL); ! 188: } ! 189: ! 190: ! 191: /*** ! 192: *HRESULT CPoly::GetIDsOfNames(char**, unsigned int, LCID, long*) ! 193: *Purpose: ! 194: * This method translates the given array of names to a corresponding ! 195: * array of DISPIDs. ! 196: * ! 197: * This method deferrs to a common implementation shared by ! 198: * both the CPoly and CPoint objects. See the description of ! 199: * 'SPolyGetIDsOfNames()' in dispimpl.cpp for more information. ! 200: * ! 201: *Entry: ! 202: * rgszNames = pointer to an array of names ! 203: * cNames = the number of names in the rgszNames array ! 204: * lcid = the callers locale ID ! 205: * ! 206: *Exit: ! 207: * return value = HRESULT ! 208: * rgdispid = array of DISPIDs corresponding to the rgszNames array ! 209: * this array will contain -1 for each entry that is not known. ! 210: * ! 211: ***********************************************************************/ ! 212: STDMETHODIMP ! 213: CPoly::GetIDsOfNames( ! 214: REFIID riid, ! 215: char FAR* FAR* rgszNames, ! 216: unsigned int cNames, ! 217: LCID lcid, ! 218: DISPID FAR* rgdispid) ! 219: { ! 220: static PARAMDESC rgpdAddPoint[] = { ! 221: {"X"}, {"Y"} ! 222: }; ! 223: static MEMBERDESC rgmdCPoly[] = { ! 224: {"DRAW", IDMEMBER_CPOLY_DRAW, NULL, 0}, ! 225: {"RESET", IDMEMBER_CPOLY_RESET, NULL, 0}, ! 226: {"ADDPOINT", IDMEMBER_CPOLY_ADDPOINT, rgpdAddPoint, 2}, ! 227: {"ENUMPOINTS", IDMEMBER_CPOLY_ENUMPOINTS, NULL, 0}, ! 228: {"GETXORIGIN", IDMEMBER_CPOLY_GETXORIGIN, NULL, 0}, ! 229: {"SETXORIGIN", IDMEMBER_CPOLY_SETXORIGIN, NULL, 0}, ! 230: {"GETYORIGIN", IDMEMBER_CPOLY_GETYORIGIN, NULL, 0}, ! 231: {"SETYORIGIN", IDMEMBER_CPOLY_SETYORIGIN, NULL, 0}, ! 232: {"GETWIDTH", IDMEMBER_CPOLY_GETWIDTH, NULL, 0}, ! 233: {"SETWIDTH", IDMEMBER_CPOLY_SETWIDTH, NULL, 0}, ! 234: {"get_red", IDMEMBER_CPOLY_GETRED, NULL, 0}, ! 235: {"set_red", IDMEMBER_CPOLY_SETRED, NULL, 0}, ! 236: {"get_green", IDMEMBER_CPOLY_GETGREEN, NULL, 0}, ! 237: {"set_green", IDMEMBER_CPOLY_SETGREEN, NULL, 0}, ! 238: {"get_blue", IDMEMBER_CPOLY_GETBLUE, NULL, 0}, ! 239: {"set_blue", IDMEMBER_CPOLY_SETBLUE, NULL, 0}, ! 240: {"DUMP", IDMEMBER_CPOLY_DUMP, NULL, 0} ! 241: }; ! 242: ! 243: // this object only exposes a "default" interface. ! 244: // ! 245: if(riid != IID_NULL) ! 246: return ResultFromScode(DISP_E_UNKNOWNINTERFACE); ! 247: ! 248: return SPolyGetIDsOfNames( ! 249: rgmdCPoly, DIM(rgmdCPoly), rgszNames, cNames, lcid, rgdispid); ! 250: } ! 251: ! 252: ! 253: /*** ! 254: *HRESULT CPoly::Invoke(...) ! 255: *Purpose: ! 256: * Dispatch a method or property request for objects of type CPoly. ! 257: * ! 258: * see the IDispatch document for more information, and a general ! 259: * description of this method. ! 260: * ! 261: *Entry: ! 262: * dispidMember = the DISPID of the member being requested ! 263: * ! 264: * riid = reference to the interface ID of the interface on this object ! 265: * that the requested member belongs to. IID_NULL means to interpret ! 266: * the member as belonging to the implementation defined "default" ! 267: * or "primary" interface. ! 268: * ! 269: * lcid = the caller's locale ID ! 270: * ! 271: * wFlags = flags indicating the type of access being requested ! 272: * ! 273: * pdispparams = pointer to the DISPPARAMS struct containing the ! 274: * requested members arguments (if any) and its named parameter ! 275: * DISPIDs (if any). ! 276: * ! 277: *Exit: ! 278: * return value = HRESULT ! 279: * see the IDispatch spec for a description of possible success codes. ! 280: * ! 281: * pvarResult = pointer to a caller allocated VARIANT containing ! 282: * the members return value (if any). ! 283: * ! 284: * pexcepinfo = caller allocated exception info structure, this will ! 285: * be filled in only if an exception was raised that must be passed ! 286: * up through Invoke to an enclosing handler. ! 287: * ! 288: * puArgErr = pointer to a caller allocated UINT, that will contain the ! 289: * index of the offending argument if a DISP_E_TYPEMISMATCH error ! 290: * was returned indicating that one of the arguments was of an ! 291: * incorrect type and/or could not be reasonably coerced to a proper ! 292: * type. ! 293: * ! 294: ***********************************************************************/ ! 295: STDMETHODIMP ! 296: CPoly::Invoke( ! 297: DISPID dispidMember, ! 298: REFIID riid, ! 299: LCID lcid, ! 300: unsigned short wFlags, ! 301: DISPPARAMS FAR* pdispparams, ! 302: VARIANT FAR* pvarResult, ! 303: EXCEPINFO FAR* pexcepinfo, ! 304: unsigned int FAR* puArgErr) ! 305: { ! 306: HRESULT hresult; ! 307: VARIANTARG varg0, varg1; ! 308: VARIANT varResultDummy; ! 309: ! 310: UNUSED(lcid); ! 311: UNUSED(pexcepinfo); ! 312: ! 313: if(wFlags & ~(DISPATCH_METHOD | DISPATCH_PROPERTYGET | DISPATCH_PROPERTYPUT | DISPATCH_PROPERTYPUTREF)) ! 314: return ResultFromScode(E_INVALIDARG); ! 315: ! 316: // this object only exposes a "default" interface. ! 317: // ! 318: if(riid != IID_NULL) ! 319: return ResultFromScode(DISP_E_UNKNOWNINTERFACE); ! 320: ! 321: // This makes the following code a bit simpler if the caller ! 322: // happens to be ignoring the return value. Some implementations ! 323: // may choose to deal with this differently. ! 324: // ! 325: if(pvarResult == (VARIANT FAR*)NULL) ! 326: pvarResult = &varResultDummy; ! 327: ! 328: VariantInit(&varg0); ! 329: VariantInit(&varg1); ! 330: ! 331: // assume the return type is void, unless we find otherwise. ! 332: VariantInit(pvarResult); ! 333: ! 334: switch(dispidMember){ ! 335: case IDMEMBER_CPOLY_DRAW: ! 336: Draw(); ! 337: break; ! 338: ! 339: case IDMEMBER_CPOLY_RESET: ! 340: Reset(); ! 341: break; ! 342: ! 343: case IDMEMBER_CPOLY_DUMP: ! 344: Dump(); ! 345: break; ! 346: ! 347: case IDMEMBER_CPOLY_ADDPOINT: ! 348: hresult = DispGetParam(pdispparams, 0, VT_I2, &varg0, puArgErr); ! 349: if(hresult != NOERROR) ! 350: return hresult; ! 351: ! 352: hresult = DispGetParam(pdispparams, 1, VT_I2, &varg1, puArgErr); ! 353: if(hresult != NOERROR) ! 354: return hresult; ! 355: ! 356: hresult = AddPoint(V_I2(&varg1), V_I2(&varg0)); ! 357: if(hresult != NOERROR) ! 358: return hresult; ! 359: break; ! 360: ! 361: case IDMEMBER_CPOLY_ENUMPOINTS: ! 362: IEnumVARIANT FAR* penum; ! 363: ! 364: hresult = EnumPoints(&penum); ! 365: if(hresult != NOERROR) ! 366: return hresult; ! 367: ! 368: V_VT(pvarResult) = VT_UNKNOWN; ! 369: hresult = penum->QueryInterface( ! 370: IID_IUnknown, (void FAR* FAR*)&V_UNKNOWN(pvarResult)); ! 371: if(hresult != NOERROR) ! 372: return hresult; ! 373: penum->Release(); ! 374: break; ! 375: ! 376: case IDMEMBER_CPOLY_GETXORIGIN: ! 377: V_VT(pvarResult) = VT_I2; ! 378: V_I2(pvarResult) = m_xorg; ! 379: break; ! 380: ! 381: case IDMEMBER_CPOLY_SETXORIGIN: ! 382: hresult = DispGetParam(pdispparams, 0, VT_I2, &varg0, puArgErr); ! 383: if(hresult != NOERROR) ! 384: return hresult; ! 385: m_xorg = V_I2(&varg0); ! 386: break; ! 387: ! 388: case IDMEMBER_CPOLY_GETYORIGIN: ! 389: V_VT(pvarResult) = VT_I2; ! 390: V_I2(pvarResult) = m_yorg; ! 391: break; ! 392: ! 393: case IDMEMBER_CPOLY_SETYORIGIN: ! 394: hresult = DispGetParam(pdispparams, 0, VT_I2, &varg0, puArgErr); ! 395: if(hresult != NOERROR) ! 396: return hresult; ! 397: m_yorg = V_I2(&varg0); ! 398: break; ! 399: ! 400: case IDMEMBER_CPOLY_GETWIDTH: ! 401: V_VT(pvarResult) = VT_I2; ! 402: V_I2(pvarResult) = GetWidth(); ! 403: break; ! 404: ! 405: case IDMEMBER_CPOLY_SETWIDTH: ! 406: hresult = DispGetParam(pdispparams, 0, VT_I2, &varg0, puArgErr); ! 407: if(hresult != NOERROR) ! 408: return hresult; ! 409: SetWidth(V_I2(&varg0)); ! 410: break; ! 411: ! 412: case IDMEMBER_CPOLY_GETRED: ! 413: V_VT(pvarResult) = VT_I2; ! 414: V_I2(pvarResult) = get_red(); ! 415: break; ! 416: ! 417: case IDMEMBER_CPOLY_SETRED: ! 418: hresult = DispGetParam(pdispparams, 0, VT_I2, &varg0, puArgErr); ! 419: if(hresult != NOERROR) ! 420: return hresult; ! 421: set_red(V_I2(&varg0)); ! 422: break; ! 423: ! 424: case IDMEMBER_CPOLY_GETGREEN: ! 425: V_VT(pvarResult) = VT_I2; ! 426: V_I2(pvarResult) = get_green(); ! 427: break; ! 428: ! 429: case IDMEMBER_CPOLY_SETGREEN: ! 430: hresult = DispGetParam(pdispparams, 0, VT_I2, &varg0, puArgErr); ! 431: if(hresult != NOERROR) ! 432: return hresult; ! 433: set_green(V_I2(&varg0)); ! 434: break; ! 435: ! 436: case IDMEMBER_CPOLY_GETBLUE: ! 437: V_VT(pvarResult) = VT_I2; ! 438: V_I2(pvarResult) = get_blue(); ! 439: break; ! 440: ! 441: case IDMEMBER_CPOLY_SETBLUE: ! 442: hresult = DispGetParam(pdispparams, 0, VT_I2, &varg0, puArgErr); ! 443: if(hresult != NOERROR) ! 444: return hresult; ! 445: set_blue(V_I2(&varg0)); ! 446: break; ! 447: ! 448: default: ! 449: return ResultFromScode(DISP_E_MEMBERNOTFOUND); ! 450: } ! 451: ! 452: return NOERROR; ! 453: } ! 454: ! 455: ! 456: //--------------------------------------------------------------------- ! 457: // Introduced Methods ! 458: //--------------------------------------------------------------------- ! 459: ! 460: ! 461: /*** ! 462: *void CPoly::Draw(void) ! 463: *Purpose: ! 464: * Draw the polygon, using the current x/y origin and line width ! 465: * properties. ! 466: * ! 467: *Entry: ! 468: * None ! 469: * ! 470: *Exit: ! 471: * None ! 472: * ! 473: ***********************************************************************/ ! 474: void PASCAL ! 475: CPoly::Draw() ! 476: { ! 477: short xorg, yorg; ! 478: POINTLINK FAR* ppointlinkFirst, FAR* ppointlink; ! 479: ! 480: if((ppointlinkFirst = m_ppointlink) == (POINTLINK FAR*)NULL) ! 481: return; ! 482: ! 483: #ifdef _MAC /* { */ ! 484: ! 485: short x, y; ! 486: RGBColor rgb; ! 487: WindowPtr pwndSaved; ! 488: extern WindowPtr g_pwndClient; ! 489: ! 490: GetPort(&pwndSaved); ! 491: SetPort(g_pwndClient); ! 492: ! 493: PenNormal(); ! 494: PenSize(m_width, m_width); ! 495: ! 496: rgb.red = m_red; ! 497: rgb.green = m_green; ! 498: rgb.blue = m_blue; ! 499: RGBForeColor(&rgb); ! 500: ! 501: xorg = m_xorg; ! 502: yorg = m_yorg; ! 503: ! 504: MoveTo( ! 505: xorg + ppointlinkFirst->ppoint->m_x, ! 506: yorg + ppointlinkFirst->ppoint->m_y); ! 507: ! 508: for(ppointlink = ppointlinkFirst->next; ! 509: ppointlink != (POINTLINK FAR*)NULL; ! 510: ppointlink = ppointlink->next) ! 511: { ! 512: x = xorg + ppointlink->ppoint->m_x; ! 513: y = yorg + ppointlink->ppoint->m_y; ! 514: LineTo(x, y); ! 515: } ! 516: ! 517: LineTo( ! 518: xorg + ppointlinkFirst->ppoint->m_x, ! 519: yorg + ppointlinkFirst->ppoint->m_y); ! 520: ! 521: SetPort(pwndSaved); ! 522: ! 523: #else /* }{ */ ! 524: ! 525: HDC hdc; ! 526: RECT rect; ! 527: HPEN hpen, hpenOld; ! 528: extern HWND g_hwndClient; ! 529: ! 530: GetClientRect(g_hwndClient, &rect); ! 531: xorg = m_xorg + (short) rect.left; ! 532: yorg = m_yorg + (short) rect.top; ! 533: ! 534: hdc = GetDC(g_hwndClient); ! 535: hpen = CreatePen(PS_SOLID, m_width, RGB(m_red, m_green, m_blue)); ! 536: hpenOld = SelectObject(hdc, hpen); ! 537: ! 538: #ifdef WIN32 ! 539: MoveToEx(hdc, ! 540: xorg + ppointlinkFirst->ppoint->m_x, ! 541: yorg + ppointlinkFirst->ppoint->m_y, NULL); ! 542: #else ! 543: MoveTo(hdc, ! 544: xorg + ppointlinkFirst->ppoint->m_x, ! 545: yorg + ppointlinkFirst->ppoint->m_y); ! 546: #endif ! 547: ! 548: for(ppointlink = ppointlinkFirst->next; ! 549: ppointlink != (POINTLINK FAR*)NULL; ! 550: ppointlink = ppointlink->next) ! 551: { ! 552: LineTo(hdc, ! 553: xorg + ppointlink->ppoint->m_x, ! 554: yorg + ppointlink->ppoint->m_y); ! 555: } ! 556: ! 557: LineTo(hdc, ! 558: xorg + ppointlinkFirst->ppoint->m_x, ! 559: yorg + ppointlinkFirst->ppoint->m_y); ! 560: ! 561: SelectObject(hdc, hpenOld); ! 562: DeleteObject(hpen); ! 563: ! 564: ReleaseDC(g_hwndClient, hdc); ! 565: ! 566: #endif /* } */ ! 567: } ! 568: ! 569: ! 570: /*** ! 571: *void CPoly::Reset(void) ! 572: *Purpose: ! 573: * Release all points referenced by this poly. ! 574: * ! 575: *Entry: ! 576: * None ! 577: * ! 578: *Exit: ! 579: * None ! 580: * ! 581: ***********************************************************************/ ! 582: void PASCAL ! 583: CPoly::Reset() ! 584: { ! 585: POINTLINK FAR* ppointlink, FAR* ppointlinkNext; ! 586: ! 587: for(ppointlink = m_ppointlink; ! 588: ppointlink != (POINTLINK FAR*)NULL; ! 589: ppointlink = ppointlinkNext) ! 590: { ! 591: ppointlinkNext = ppointlink->next; ! 592: ppointlink->ppoint->Release(); ! 593: delete ppointlink; ! 594: } ! 595: ! 596: m_cPoints = 0; ! 597: m_ppointlink = NULL; ! 598: m_ppointlinkLast = NULL; ! 599: } ! 600: ! 601: ! 602: /*** ! 603: *HRESULT CPoly::AddPoint(short, short) ! 604: *Purpose: ! 605: * Add a CPoint with the given coordinates to the end of our current ! 606: * list of points. ! 607: * ! 608: *Entry: ! 609: * x,y = the x and y coordinates of the new point. ! 610: * ! 611: *Exit: ! 612: * return value = HRESULT ! 613: * ! 614: ***********************************************************************/ ! 615: HRESULT PASCAL ! 616: CPoly::AddPoint(short x, short y) ! 617: { ! 618: CPoint FAR* ppoint; ! 619: POINTLINK FAR* ppointlink; ! 620: ! 621: ppoint = CPoint::Create(); ! 622: if(ppoint == (CPoint FAR*)NULL) ! 623: return ResultFromScode(E_OUTOFMEMORY); ! 624: ! 625: ppoint->SetX(x); ! 626: ppoint->SetY(y); ! 627: ! 628: ppointlink = new FAR POINTLINK; ! 629: if(ppointlink == (POINTLINK FAR*)NULL){ ! 630: delete ppoint; ! 631: return ResultFromScode(E_OUTOFMEMORY); ! 632: } ! 633: ! 634: ppointlink->ppoint = ppoint; ! 635: ppointlink->next = (POINTLINK FAR*)NULL; ! 636: ! 637: if(m_ppointlinkLast == (POINTLINK FAR*)NULL){ ! 638: m_ppointlink = m_ppointlinkLast = ppointlink; ! 639: }else{ ! 640: m_ppointlinkLast->next = ppointlink; ! 641: m_ppointlinkLast = ppointlink; ! 642: } ! 643: ! 644: ++m_cPoints; ! 645: ! 646: return NOERROR; ! 647: } ! 648: ! 649: ! 650: /*** ! 651: *HRESULT CPoly::EnumPoints(IEnumVARIANT**); ! 652: *Purpose: ! 653: * Return and enumerator for the points in this polygon. ! 654: * ! 655: *Entry: ! 656: * None ! 657: * ! 658: *Exit: ! 659: * return value = HRESULT ! 660: * ! 661: * *ppenum = pointer to an IEnumVARIANT for the points in this polygon ! 662: * ! 663: ***********************************************************************/ ! 664: HRESULT PASCAL ! 665: CPoly::EnumPoints(IEnumVARIANT FAR* FAR* ppenum) ! 666: { ! 667: unsigned int i; ! 668: VARIANT var; ! 669: HRESULT hresult; ! 670: SAFEARRAY FAR* psa; ! 671: CEnumPoint FAR* penum; ! 672: POINTLINK FAR* ppointlink; ! 673: SAFEARRAYBOUND rgsabound[1]; ! 674: ! 675: rgsabound[0].lLbound = 0; ! 676: rgsabound[0].cElements = m_cPoints; ! 677: ! 678: psa = SafeArrayCreate(VT_VARIANT, 1, rgsabound); ! 679: if(psa == NULL){ ! 680: hresult = ResultFromScode(E_OUTOFMEMORY); ! 681: goto LError0; ! 682: } ! 683: ! 684: ppointlink = m_ppointlink; ! 685: for(i = 0; i < m_cPoints; ++i){ ! 686: long ix[1]; ! 687: ! 688: if(ppointlink == NULL){ ! 689: // this indicates an internal consistency error. ! 690: // (this test should probably be an assertion) ! 691: hresult = ResultFromScode(E_FAIL); ! 692: goto LError1; ! 693: } ! 694: ! 695: V_VT(&var) = VT_DISPATCH; ! 696: hresult = ppointlink->ppoint->QueryInterface( ! 697: IID_IDispatch, (void FAR* FAR*)&V_DISPATCH(&var)); ! 698: if(hresult != NOERROR) ! 699: goto LError1; ! 700: ! 701: ix[0] = i; ! 702: SafeArrayPutElement(psa, ix, &var); ! 703: ! 704: ppointlink = ppointlink->next; ! 705: } ! 706: ! 707: hresult = CEnumPoint::Create(psa, &penum); ! 708: if(hresult != NOERROR) ! 709: goto LError1; ! 710: ! 711: *ppenum = penum; ! 712: ! 713: return NOERROR; ! 714: ! 715: LError1:; ! 716: // destroy the array if we were not successful creating the enumerator. ! 717: SafeArrayDestroy(psa); ! 718: ! 719: LError0:; ! 720: return hresult; ! 721: } ! 722: ! 723: short PASCAL ! 724: CPoly::GetXOrigin() ! 725: { ! 726: return m_xorg; ! 727: } ! 728: ! 729: void PASCAL ! 730: CPoly::SetXOrigin(short x) ! 731: { ! 732: m_xorg = x; ! 733: } ! 734: ! 735: short PASCAL ! 736: CPoly::GetYOrigin() ! 737: { ! 738: return m_yorg; ! 739: } ! 740: ! 741: void PASCAL ! 742: CPoly::SetYOrigin(short y) ! 743: { ! 744: m_yorg = y; ! 745: } ! 746: ! 747: short PASCAL ! 748: CPoly::GetWidth() ! 749: { ! 750: return m_width; ! 751: } ! 752: ! 753: void PASCAL ! 754: CPoly::SetWidth(short width) ! 755: { ! 756: m_width = width; ! 757: } ! 758: ! 759: short PASCAL ! 760: CPoly::get_red() ! 761: { ! 762: return m_red; ! 763: } ! 764: ! 765: void PASCAL ! 766: CPoly::set_red(short red) ! 767: { ! 768: m_red = red; ! 769: } ! 770: ! 771: short PASCAL ! 772: CPoly::get_green() ! 773: { ! 774: return m_green; ! 775: } ! 776: ! 777: void PASCAL ! 778: CPoly::set_green(short green) ! 779: { ! 780: m_green = green; ! 781: } ! 782: ! 783: short PASCAL ! 784: CPoly::get_blue() ! 785: { ! 786: return m_blue; ! 787: } ! 788: ! 789: void PASCAL ! 790: CPoly::set_blue(short blue) ! 791: { ! 792: m_blue = blue; ! 793: } ! 794: ! 795: ! 796: /*** ! 797: *void CPoly::Dump(void) ! 798: *Purpose: ! 799: * Output a debug dump of this instance. ! 800: * ! 801: *Entry: ! 802: * None ! 803: * ! 804: *Exit: ! 805: * None ! 806: * ! 807: ***********************************************************************/ ! 808: void PASCAL ! 809: CPoly::Dump() ! 810: { ! 811: #ifdef _MAC ! 812: ! 813: // REVIEW: implement for the mac ! 814: ! 815: #else ! 816: ! 817: char buffer[80]; ! 818: POINTLINK FAR* ppointlink; ! 819: ! 820: wsprintf(buffer, "CPoly(0x%x) =\n", (int)this); ! 821: OutputDebugString(buffer); ! 822: ! 823: wsprintf(buffer, ! 824: " xorg = %d, yorg = %d, width = %d, rgb = {%d,%d,%d}\n points = ", ! 825: m_xorg, m_yorg, m_width, ! 826: get_red(), ! 827: get_green(), ! 828: get_blue()); ! 829: ! 830: OutputDebugString(buffer); ! 831: ! 832: for(ppointlink = m_ppointlink; ! 833: ppointlink != (POINTLINK FAR*)NULL; ! 834: ppointlink = ppointlink->next) ! 835: { ! 836: wsprintf(buffer, "{%d,%d}", ! 837: ppointlink->ppoint->GetX(), ! 838: ppointlink->ppoint->GetY()); ! 839: OutputDebugString(buffer); ! 840: ! 841: wsprintf(buffer, " "); ! 842: OutputDebugString(buffer); ! 843: } ! 844: wsprintf(buffer, "\n"); ! 845: OutputDebugString(buffer); ! 846: ! 847: #endif ! 848: } ! 849: ! 850: /*** ! 851: *void CPoly::PolyDraw(void) ! 852: *Purpose: ! 853: * Draw all polygons. ! 854: * ! 855: *Entry: ! 856: * None ! 857: * ! 858: *Exit: ! 859: * None ! 860: * ! 861: ***********************************************************************/ ! 862: void ! 863: CPoly::PolyDraw() ! 864: { ! 865: POLYLINK FAR* polylink; ! 866: ! 867: for(polylink = g_ppolylink; ! 868: polylink != (POLYLINK FAR*)NULL; ! 869: polylink = polylink->next) ! 870: { ! 871: polylink->ppoly->Draw(); ! 872: } ! 873: } ! 874: ! 875: ! 876: /*** ! 877: *void PolyTerm(void) ! 878: *Purpose: ! 879: * Release all polygons. ! 880: * ! 881: *Entry: ! 882: * None ! 883: * ! 884: *Exit: ! 885: * None ! 886: * ! 887: ***********************************************************************/ ! 888: void ! 889: CPoly::PolyTerm() ! 890: { ! 891: POLYLINK FAR* ppolylink; ! 892: POLYLINK FAR* ppolylinkNext; ! 893: ! 894: for(ppolylink = g_ppolylink; ! 895: ppolylink != (POLYLINK FAR*)NULL; ! 896: ppolylink = ppolylinkNext) ! 897: { ! 898: ppolylinkNext = ppolylink->next; ! 899: ppolylink->ppoly->Release(); ! 900: delete ppolylink; ! 901: } ! 902: } ! 903: ! 904: ! 905: /*** ! 906: *void PolyDump(void) ! 907: *Purpose: ! 908: * Invoke the debug Dump() method on all polygons were currently ! 909: * holding on to. ! 910: * ! 911: *Entry: ! 912: * None ! 913: * ! 914: *Exit: ! 915: * None ! 916: * ! 917: ***********************************************************************/ ! 918: void ! 919: CPoly::PolyDump() ! 920: { ! 921: POLYLINK FAR* ppolylink; ! 922: ! 923: if(g_ppolylink == (POLYLINK FAR*)NULL){ ! 924: #ifndef _MAC ! 925: OutputDebugString("\t(none)\n"); ! 926: #endif ! 927: return; ! 928: } ! 929: ! 930: for(ppolylink = g_ppolylink; ! 931: ppolylink != (POLYLINK FAR*)NULL; ! 932: ppolylink = ppolylink->next) ! 933: { ! 934: ppolylink->ppoly->Dump(); ! 935: } ! 936: } ! 937: ! 938: ! 939: //--------------------------------------------------------------------- ! 940: // Implementation of the CPoly Class Factory ! 941: //--------------------------------------------------------------------- ! 942: ! 943: ! 944: CPolyCF::CPolyCF() ! 945: { ! 946: m_refs = 0; ! 947: } ! 948: ! 949: IClassFactory FAR* ! 950: CPolyCF::Create() ! 951: { ! 952: CPolyCF FAR* pCF; ! 953: ! 954: if((pCF = new FAR CPolyCF()) == NULL) ! 955: return NULL; ! 956: pCF->AddRef(); ! 957: return pCF; ! 958: } ! 959: ! 960: STDMETHODIMP ! 961: CPolyCF::QueryInterface(REFIID riid, void FAR* FAR* ppv) ! 962: { ! 963: if(riid != IID_IUnknown){ ! 964: if(riid != IID_IClassFactory){ ! 965: *ppv = NULL; ! 966: return ResultFromScode(E_NOINTERFACE); ! 967: } ! 968: } ! 969: ! 970: *ppv = this; ! 971: ++m_refs; ! 972: return NOERROR; ! 973: } ! 974: ! 975: STDMETHODIMP_(unsigned long) ! 976: CPolyCF::AddRef(void) ! 977: { ! 978: return ++m_refs; ! 979: } ! 980: ! 981: STDMETHODIMP_(unsigned long) ! 982: CPolyCF::Release(void) ! 983: { ! 984: if(--m_refs == 0){ ! 985: delete this; ! 986: return 0; ! 987: } ! 988: return m_refs; ! 989: } ! 990: ! 991: STDMETHODIMP ! 992: CPolyCF::CreateInstance( ! 993: IUnknown FAR* punkOuter, ! 994: REFIID iid, ! 995: void FAR* FAR* ppv) ! 996: { ! 997: HRESULT hresult; ! 998: CPoly FAR *ppoly; ! 999: ! 1000: UNUSED(punkOuter); ! 1001: ! 1002: #ifdef _MAC ! 1003: if(GetZone() != ApplicZone()){ ! 1004: DebugStr("\pZones do not match"); ! 1005: } ! 1006: ! 1007: #endif ! 1008: ! 1009: if((ppoly = CPoly::Create()) == NULL){ ! 1010: *ppv = NULL; ! 1011: return ResultFromScode(E_OUTOFMEMORY); ! 1012: } ! 1013: hresult = ppoly->QueryInterface(iid, ppv); ! 1014: ppoly->Release(); ! 1015: return hresult; ! 1016: } ! 1017: ! 1018: STDMETHODIMP ! 1019: #ifdef _MAC ! 1020: CPolyCF::LockServer(unsigned long fLock) ! 1021: #else ! 1022: CPolyCF::LockServer(BOOL fLock) ! 1023: #endif ! 1024: { ! 1025: UNUSED(fLock); ! 1026: ! 1027: return NOERROR; ! 1028: } ! 1029:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.