![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dspcalc2.cpp CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / ole20 / samples / dspcalc2|
Return to dspcalc2.cpp CVS log | Up to [WindowsNT SDKs] / mstools / ole20 / samples / dspcalc2 |
1.1 root 1: /***
2: *dspcalc2.cpp
3: *
4: * Copyright (C) 1993, Microsoft Corporation. All Rights Reserved.
5: * Information Contained Herein Is Proprietary and Confidential.
6: *
7: *Purpose:
8: * This module implements the basic user interface and arithmetic
9: * functionality of the IDispatch calculator.
10: *
11: * The implementation of IDispatch is via aggregation with an
12: * instance of the "standard" IDispatch implementation, which is
13: * initialized with a TypeInfo loaded from the TypeLib that was
14: * constructed from the ODL description of the calculator.
15: *
16: *Implementation Notes:
17: *
18: *****************************************************************************/
19:
20: #include <windows.h>
21: #include <ole2.h>
22: #if !defined(WIN32)
23: #include <olenls.h>
24: #endif
25: #include <dispatch.h>
26:
27: #include "resource.h"
28: #include "dspcalc2.h"
29:
30:
31: /***
32: *CCalc *CCalc::Create(void)
33: *Purpose:
34: * Create an instance of the IDispatch calculator, load the
35: * TypeInfo that describes the exposed functionality and
36: * aggregate with an instance of CStdDispatch that has been
37: * initialized with this TypeInfo.
38: *
39: *Entry:
40: * None
41: *
42: *Exit:
43: * return value = CCalc*, NULL if the creation failed.
44: *
45: ***********************************************************************/
46: CCalc FAR*
47: CCalc::Create()
48: {
49: HRESULT hresult;
50: CCalc FAR* pcalc;
51: ITypeLib FAR* ptlib;
52: ITypeInfo FAR* ptinfo;
53: IUnknown FAR* punkStdDisp;
54:
55: ptlib = NULL;
56: ptinfo = NULL;
57:
58: if((pcalc = new FAR CCalc()) == NULL)
59: return NULL;
60:
61: if((hresult = LoadTypeLib("dspcalc2.tlb", &ptlib)) != NOERROR){
62: MessageBox(NULL, "error loading TypeLib", "dspcalc2", MB_OK);
63: goto LError0;
64: }
65:
66: if((hresult = ptlib->GetTypeInfoOfGuid(CLSID_CCalc2, &ptinfo)) != NOERROR){
67: MessageBox(NULL, "error accessing TypeInfo", "dspcalc2", MB_OK);
68: goto LError0;
69: }
70:
71: // Create and aggregate with an instance of the default
72: // implementation of IDispatch that is initialized with our
73: // TypeInfo.
74: //
75: hresult = CreateStdDispatch(
76: pcalc, // controlling unknown
77: &pcalc->m_arith, // vtable* to dispatch on
78: ptinfo,
79: &punkStdDisp);
80:
81:
82: if(hresult != NOERROR)
83: goto LError0;
84:
85: pcalc->m_punkStdDisp = punkStdDisp;
86:
87: ptinfo->Release();
88: ptlib->Release();
89:
90: return pcalc;
91:
92: LError0:;
93: pcalc->Release();
94: if(ptinfo != NULL)
95: ptinfo->Release();
96: if(ptlib != NULL)
97: ptlib->Release();
98: return NULL;
99: }
100:
101:
102: //---------------------------------------------------------------------
103: // IUnknown methods
104: //---------------------------------------------------------------------
105:
106:
107: STDMETHODIMP
108: CCalc::QueryInterface(REFIID riid, void FAR* FAR* ppv)
109: {
110: if(riid == IID_IUnknown){
111: *ppv = this;
112: }else
113: if(riid == IID_IDispatch){
114: return m_punkStdDisp->QueryInterface(riid, ppv);
115: }else
116: if(riid == IID_ICalculator){
117: *ppv = &m_arith;
118: }else
119: return ResultFromScode(E_NOINTERFACE);
120:
121: AddRef();
122: return NOERROR;
123: }
124:
125:
126: STDMETHODIMP_(ULONG)
127: CCalc::AddRef()
128: {
129: return ++m_refs;
130: }
131:
132:
133: STDMETHODIMP_(ULONG)
134: CCalc::Release()
135: {
136: if(--m_refs == 0){
137: if(m_punkStdDisp != NULL)
138: m_punkStdDisp->Release();
139: PostQuitMessage(0);
140: delete this;
141: return 0;
142: }
143: return m_refs;
144: }
145:
146:
147: STDMETHODIMP
148: CCalc::CArith::QueryInterface(REFIID riid, void FAR* FAR* ppv)
149: {
150: return m_pcalc->QueryInterface(riid, ppv);
151: }
152:
153:
154: STDMETHODIMP_(ULONG)
155: CCalc::CArith::AddRef()
156: {
157: return m_pcalc->AddRef();
158: }
159:
160:
161: STDMETHODIMP_(ULONG)
162: CCalc::CArith::Release()
163: {
164: return m_pcalc->Release();
165: }
166:
167:
168: //---------------------------------------------------------------------
169: // Arithmetic features
170: //---------------------------------------------------------------------
171:
172:
173: STDMETHODIMP_(void)
174: CCalc::CArith::Clear()
175: {
176: m_opnd = 0;
177: m_accum = 0;
178: m_op = OP_NONE;
179: m_state = STATE_LOPND;
180: }
181:
182: STDMETHODIMP_(void)
183: CCalc::CArith::put_Accum(long l)
184: {
185: m_accum = l;
186: }
187:
188:
189: STDMETHODIMP_(long)
190: CCalc::CArith::get_Accum()
191: {
192: return m_accum;
193: }
194:
195:
196: STDMETHODIMP_(void)
197: CCalc::CArith::put_Opnd(long l)
198: {
199: m_opnd = l;
200: }
201:
202:
203: STDMETHODIMP_(long)
204: CCalc::CArith::get_Opnd()
205: {
206: return m_opnd;
207: }
208:
209:
210: STDMETHODIMP_(void)
211: CCalc::CArith::put_Op(short op)
212: {
213: m_op = op;
214: }
215:
216:
217: STDMETHODIMP_(short)
218: CCalc::CArith::get_Op()
219: {
220: return m_op;
221: }
222:
223:
224: STDMETHODIMP_(BOOL)
225: CCalc::CArith::Eval()
226: {
227: if(m_op == OP_NONE)
228: return FALSE;
229:
230: switch(m_op){
231: case OP_PLUS:
232: m_accum += m_opnd;
233: break;
234: case OP_MINUS:
235: m_accum -= m_opnd;
236: break;
237: case OP_MULT:
238: m_accum *= m_opnd;
239: break;
240: case OP_DIV:
241: m_accum = (m_opnd == 0) ? 0 : (m_accum / m_opnd);
242: break;
243: default:
244: // ASSERT(UNREACHED);
245: return FALSE;
246:
247: }
248:
249: m_state = STATE_EVAL;
250:
251: return TRUE;
252: }
253:
254:
255: //---------------------------------------------------------------------
256: // User Interface features
257: //---------------------------------------------------------------------
258:
259:
260: /***
261: *void CCalc::CArith::Display()
262: *Purpose:
263: * Display the contents of the register currently being edited.
264: *
265: *Entry:
266: * None
267: *
268: *Exit:
269: * None
270: *
271: ***********************************************************************/
272: STDMETHODIMP_(void)
273: CCalc::CArith::Display()
274: {
275: VARIANT var;
276:
277: V_VT(&var) = VT_I4;
278: V_I4(&var) = (m_state == STATE_ROPND) ? m_opnd : m_accum;
279: VariantChangeType(&var, &var, 0, VT_BSTR);
280: SetDlgItemText(m_pcalc->m_hwnd, IDC_DISPLAY, V_BSTR(&var));
281: VariantClear(&var);
282: }
283:
284:
285: STDMETHODIMP_(BOOL)
286: CCalc::CArith::Button(BSTR bstrButton)
287: {
288: int i, button;
289:
290: static struct {
291: char ch;
292: int idc;
293: } NEAR rgIdcOfCh[] = {
294: { '+', IDC_PLUS }
295: , { '-', IDC_MINUS }
296: , { '*', IDC_MULT }
297: , { '/', IDC_DIV }
298: , { 'C', IDC_CLEAR }
299: , { 'c', IDC_CLEAR }
300: , { '=', IDC_EQUALS }
301: , { '0', IDC_ZERO }
302: , { '1', IDC_ONE }
303: , { '2', IDC_TWO }
304: , { '3', IDC_THREE }
305: , { '4', IDC_FOUR }
306: , { '5', IDC_FIVE }
307: , { '6', IDC_SIX }
308: , { '7', IDC_SEVEN }
309: , { '8', IDC_EIGHT }
310: , { '9', IDC_NINE }
311: , { -1 , -1 }
312: };
313:
314: // if the string is more that 1 character long, then we know its wrong.
315: if(SysStringLen(bstrButton) > 1)
316: return FALSE;
317:
318: // translate button string into control ID
319: for(i = 0;; ++i){
320: if(rgIdcOfCh[i].ch == -1)
321: return FALSE;
322: if(rgIdcOfCh[i].ch == bstrButton[0]){
323: button = rgIdcOfCh[i].idc;
324: break;
325: }
326: }
327:
328: return ButtonPush(button);
329: }
330:
331:
332: // the following method is internal, and not exposed for programmability
333: BOOL
334: CCalc::CArith::ButtonPush(int button)
335: {
336: if(button >= IDC_ZERO && button <= IDC_NINE){
337:
338: long lVal = button - IDC_ZERO;
339:
340: switch(m_state){
341: case STATE_EVAL:
342: m_accum = lVal;
343: m_state = STATE_LOPND;
344: break;
345: case STATE_OP:
346: m_opnd = lVal;
347: m_state = STATE_ROPND;
348: break;
349: case STATE_LOPND:
350: m_accum = (m_accum * 10) + lVal;
351: break;
352: case STATE_ROPND:
353: m_opnd = (m_opnd * 10) + lVal;
354: break;
355: }
356:
357: }else if(button >= IDC_PLUS && button <= IDC_DIV){
358:
359: if(m_state == STATE_LOPND){
360: m_opnd = m_accum;
361: m_state = STATE_OP;
362: m_op = button - IDC_PLUS + OP_PLUS;
363: }
364:
365: }else if(button == IDC_EQUALS){
366:
367: if(m_state > STATE_LOPND)
368: Eval();
369:
370: }else if (button == IDC_CLEAR){
371:
372: Clear();
373:
374: }
375:
376: SendMessage(m_pcalc->m_hwnd, BM_SETSTATE, 1, 0L);
377: SendMessage(m_pcalc->m_hwnd, BM_SETSTATE, 0, 0L);
378:
379: Display();
380:
381: return TRUE;
382: }
383:
384: /***
385: *void CCalc::CArith::Quit()
386: *Purpose:
387: *
388: *Entry:
389: * None
390: *
391: *Exit:
392: * None
393: *
394: ***********************************************************************/
395: STDMETHODIMP_(void)
396: CCalc::CArith::Quit()
397: {
398: PostQuitMessage(0);
399: }
400:
401:
402: //---------------------------------------------------------------------
403: // The CCalc Class Factory
404: //---------------------------------------------------------------------
405:
406:
407: IClassFactory FAR*
408: CCalcCF::Create()
409: {
410: return new FAR CCalcCF();
411: }
412:
413:
414: STDMETHODIMP
415: CCalcCF::QueryInterface(REFIID riid, void FAR* FAR* ppv)
416: {
417: if(riid == IID_IUnknown || riid == IID_IClassFactory){
418: AddRef();
419: *ppv = this;
420: return NOERROR;
421: }
422: return ResultFromScode(E_NOINTERFACE);
423: }
424:
425:
426: STDMETHODIMP_(ULONG)
427: CCalcCF::AddRef()
428: {
429: return ++m_refs;
430: }
431:
432:
433: STDMETHODIMP_(ULONG)
434: CCalcCF::Release()
435: {
436: if(--m_refs == 0){
437: delete this;
438: return 0;
439: }
440: return m_refs;
441: }
442:
443:
444: STDMETHODIMP
445: CCalcCF::CreateInstance(
446: IUnknown FAR* punkOuter,
447: REFIID riid,
448: void FAR* FAR* ppv)
449: {
450: extern CCalc FAR* g_pcalc;
451:
452: return g_pcalc->QueryInterface(riid, ppv);
453: }
454:
455:
456: STDMETHODIMP
457: CCalcCF::LockServer(BOOL fLock)
458: {
459: return NOERROR;
460: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.