home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1998 November / pcwk_11_98a.iso / Wtestowe / SOFTSRC / vtrial15.exe / DATA.1 / Vutil.h < prev    next >
Encoding:
C/C++ Source or Header  |  1997-02-09  |  4.2 KB  |  152 lines
  1. /*
  2. Vdraft plugin    - vutil.h
  3.     (C) Copyright 1997 by SoftSource.  All rights reserved.
  4. Scott Sherman 1-97...
  5.  
  6.     useful tools to help build Vdraft add-ons
  7. */
  8.  
  9. #ifndef VUTIL_H
  10. #define VUTIL_H
  11.  
  12. #define PI    3.14159265358979
  13.  
  14. // base class for encapsulating handling Vdraft Plug-in events
  15. class cVdraftEvent
  16. {
  17. public:
  18.     cVdraftEvent(IVdraft& vdraft, vtAddOnID id);
  19.     virtual ~cVdraftEvent()    {}
  20.  
  21. protected:
  22.     // derived classes can access Vdraft objects from here
  23.     IVdraft& getVdraft()    { return m_vdraft; }
  24.     vtAddOnID getAddOnID()    { return m_id; }
  25. private:
  26.     IVdraft m_vdraft;    // Vdraft interface
  27.     vtAddOnID m_id;        // id passed to Vdraft when requesting events
  28. };
  29.  
  30. //
  31. // to handle pick events, derive from cPickEvent and override
  32. //        the event functions you need to handle
  33. // if you use this class, remember to add Vutil.cpp to your project
  34. //        and export vfPickEvent in your .def file
  35. // e.g.    IPickEvents pick(doc.GetPickEvents());
  36. //            pick.RequestPick(id,cVariant(new cMyEvent(vdraft,id)));
  37. class cPickEvent : public cVdraftEvent
  38. {
  39. public:
  40.     cPickEvent(IVdraft& vdraft, vtAddOnID id) : cVdraftEvent(vdraft,id)    {}
  41.  
  42.     // events derived classes can respond to
  43.     // override & provide your own implementation
  44.     virtual void Done() {}              // Done chosen from popup
  45.     virtual void Cancel() {}            // pick was aborted
  46.     virtual void Pick(double* point) {} // a point has been picked
  47.     virtual void Properties() {}        // Properties chosen from popup
  48.     virtual void Undo() {}              // Undo chosen from popup
  49. };
  50.  
  51. //
  52. // to handle draw events, derive from cDrawEvent and override
  53. //        the event functions you need to handle
  54. // if you use this class, remember to add Vutil.cpp to your project
  55. //        and export vfDrawEvent in your .def file
  56. // e.g.    IPickEvents pick(doc.GetPickEvents());
  57. //            pick.RequestDraw(id,cVariant(new cMyEvent(vdraft,id)));
  58. class cDrawEvent : public cVdraftEvent
  59. {
  60. public:
  61.     cDrawEvent(IVdraft& vdraft, vtAddOnID id) : cVdraftEvent(vdraft,id)    {}
  62.  
  63.     // events derived classes can respond to
  64.     // override & provide your own implementation
  65.     virtual void Done() {}    // drawing is completely done
  66.     virtual void Cancel() {}  // drawing has been aborted
  67.     virtual void Pick(double* point, short picknumber) {} // a point has been picked
  68. };
  69.  
  70. //
  71. // to handle selection events, derive from cSelectEvent and override
  72. //        the event functions you need to handle
  73. // if you use this class, remember to add Vutil.cpp to your project
  74. //        and export vfSelectEvent in your .def file
  75. // e.g.    ISelectionEvents select(doc.GetSelectionEvents());
  76. //            select.RequestSelect(id,cVariant(new cSelectEvent(vdraft,id)));
  77. class cSelectEvent : public cVdraftEvent
  78. {
  79. public:
  80.     cSelectEvent(IVdraft& vdraft, vtAddOnID id) : cVdraftEvent(vdraft,id)    {}
  81.  
  82.     // events derived classes can respond to
  83.     // override & provide your own implementation
  84.     virtual void Done() {}    // the user is done selecting objects
  85.     virtual void Cancel() {}  // the user aborted the selection process
  86. };
  87.  
  88.  
  89.  
  90. //
  91. // utility class which makes passing VARIANTs easier
  92. // e.g. IVector myvector( vdraft.NewVector(cVariant(2.97), cVariant(3.14), cVariant() );
  93. class cVariant
  94. {
  95. public:
  96.     cVariant()
  97.     {
  98.         variant.vt = VT_EMPTY;
  99.     }
  100.     cVariant(BOOL val)
  101.     {
  102.         variant.vt = VT_BOOL;
  103.         variant.boolVal = val;
  104.     }
  105.     cVariant(short val)
  106.     {
  107.         variant.vt = VT_I2;
  108.         variant.iVal = val;
  109.     }
  110.     cVariant(long val)
  111.     {
  112.         variant.vt = VT_I4;
  113.         variant.lVal = val;
  114.     }
  115.     cVariant(double val)
  116.     {
  117.         variant.vt = VT_R8;
  118.         variant.dblVal = val;
  119.     }
  120.     cVariant(BSTR val)
  121.     {
  122.         variant.vt = VT_BSTR;
  123.         variant.bstrVal = val;
  124.     }
  125.     cVariant(CString& val)
  126.     {
  127.         variant.vt = VT_BSTR;
  128.         variant.bstrVal = val.AllocSysString();
  129.     }
  130.     cVariant(LPDISPATCH val)
  131.     {
  132.         variant.vt = VT_DISPATCH;
  133.         variant.pdispVal = val;
  134.     }
  135.     cVariant(cVdraftEvent* event)
  136.     {
  137.         variant.vt = VT_I4;
  138.         variant.lVal = (long)event;
  139.     }
  140.  
  141.     inline operator VARIANT&()    { return variant; }
  142. protected:
  143.     VARIANT variant;
  144. };
  145.  
  146.  
  147. // creating vectors
  148. #define VECTOR2D(vdraft,x,y)    (vdraft.NewVector(cVariant(x),cVariant(y),cVariant()))
  149. #define VECTOR3D(vdraft,x,y,z)    (vdraft.NewVector(cVariant(x),cVariant(y),cVariant(z)))
  150.  
  151. #endif    // VUTIL_H
  152.