Return to dspcalc2.h CVS log

Up to [WindowsNT SDKs] / mstools / ole20 / samples / dspcalc2

Annotation of mstools/ole20/samples/dspcalc2/dspcalc2.h, revision 1.1.1.1

1.1       root        1: /*** 
                      2: *dspcalc2.h
                      3: *
                      4: *  Copyright (C) 1992, Microsoft Corporation.  All Rights Reserved.
                      5: *  Information Contained Herein Is Proprietary and Confidential.
                      6: *
                      7: *Purpose:
                      8: *  UNDONE
                      9: *
                     10: *
                     11: *Implementation Notes:
                     12: *
                     13: *****************************************************************************/
                     14: 
                     15: #include "clsid.h" 
                     16: 
                     17: /* 
                     18:  * UNDONE: Shouldn't have to do this.
                     19:  */
                     20: typedef BOOL boolean;
                     21: 
                     22: /* 
                     23:  * The .h file included below is created via MkTypLib
                     24:  */
                     25: #include "calctype.h"
                     26: 
                     27: #pragma warning(disable:4355)
                     28: 
                     29: #define DIM(X) (sizeof(X)/sizeof(X[0]))
                     30: 
                     31: 
                     32: class FAR CCalc : public IUnknown {
                     33: public:
                     34:     static CCalc FAR* Create();
                     35: 
                     36:     STDMETHOD(QueryInterface)(REFIID riid, void FAR* FAR* ppv);
                     37:     STDMETHOD_(ULONG, AddRef)(void);
                     38:     STDMETHOD_(ULONG, Release)(void);
                     39: 
                     40:     // Introduced "calculator" interface
                     41:     //
                     42:     // This nested class implementes core arithmetic functionality
                     43:     // (such as it is) *and* is the interface that will be exposed via
                     44:     // IDispatch for external programmability.
                     45:     //
                     46:     class FAR CArith : _Calculator {
                     47:     public:
                     48: 
                     49:       /* IUnknown methods */
                     50:       STDMETHOD(QueryInterface)(THIS_ REFIID riid, LPVOID FAR * ppvObj);
                     51:       STDMETHOD_(ULONG, AddRef)(THIS);
                     52:       STDMETHOD_(ULONG, Release)(THIS);
                     53: 
                     54:       /* _Calculator methods */
                     55:       STDMETHOD_(void, put_Accum)(long l);
                     56:       STDMETHOD_(long, get_Accum)(void);
                     57:       STDMETHOD_(void, put_Opnd)(long l);
                     58:       STDMETHOD_(long, get_Opnd)(void);
                     59:       STDMETHOD_(void, put_Op)(short op);
                     60:       STDMETHOD_(short, get_Op)(void);
                     61:       STDMETHOD_(boolean, Eval)(void);
                     62:       STDMETHOD_(void, Clear)(void);
                     63:       STDMETHOD_(void, Display)(void);
                     64:       STDMETHOD_(void, Quit)(void);
                     65:       STDMETHOD_(BOOL, Button)(BSTR button);
                     66: 
                     67:       // the following method is internal, and not exposed for programmability
                     68:       BOOL ButtonPush(int button);
                     69: 
                     70:       CArith(CCalc FAR* pcalc){
                     71:         m_pcalc = pcalc;
                     72:         Clear();
                     73:       }
                     74: 
                     75:       enum states { STATE_LOPND, STATE_OP, STATE_ROPND, STATE_EVAL };
                     76: 
                     77:     private:
                     78:       CCalc FAR* m_pcalc;
                     79: 
                     80:       short    m_op;
                     81:       long     m_opnd;
                     82:       long     m_accum;
                     83:       enum states m_state;
                     84:     };
                     85:     friend CArith;
                     86:     CArith m_arith;
                     87: 
                     88: 
                     89:     HWND m_hwnd;
                     90: 
                     91:     CCalc() : m_arith(this)
                     92:     {
                     93:       m_refs = 1;
                     94:       m_hwnd = 0;
                     95:       m_punkStdDisp = NULL;
                     96:     }
                     97: 
                     98: private:
                     99:     ULONG m_refs;
                    100:     IUnknown FAR* m_punkStdDisp;
                    101: };
                    102: 
                    103: 
                    104: // the CCalc Class Factory
                    105: //
                    106: class FAR CCalcCF : public IClassFactory {
                    107: public:
                    108:     static IClassFactory FAR* Create();
                    109: 
                    110:     STDMETHOD(QueryInterface)(REFIID riid, void FAR* FAR* ppv);
                    111:     STDMETHOD_(ULONG, AddRef)(void);
                    112:     STDMETHOD_(ULONG, Release)(void);
                    113: 
                    114:     STDMETHOD(CreateInstance)(
                    115:       IUnknown FAR* punkOuter, REFIID riid, void FAR* FAR* ppv);
                    116:     STDMETHOD(LockServer)(BOOL fLock);
                    117: 
                    118:     CCalcCF() { m_refs = 1; }
                    119: 
                    120: private:
                    121:     ULONG m_refs;
                    122: };

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.