开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
SPROA.CPP
资源名称：MSDN_VC98.zip　[点击查看]
上传用户：bangxh
上传日期：2007-01-31
资源大小：42235k
文件大小：23k
源码类别：

Windows编程

开发平台：

Visual C++

SPROA.CPP：源码内容
  1. //---------------------------------------------------------------------------
  2. // SprOA.cpp
  3. //---------------------------------------------------------------------------
  4. // Sprite handler, OLE Automation support
  5. //---------------------------------------------------------------------------
  6. // (C) Copyright 1992-1997 by Microsoft Corporation.  All rights reserved.
  7. //
  8. // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF 
  9. // ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO 
  10. // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A 
  11. // PARTICULAR PURPOSE.
  12. //---------------------------------------------------------------------------
  14. #include "Main.h"
  15. #pragma hdrstop
  16. #include "Spr.h"
  17. #include "DispIDs.h"
  18. #include <math.h>
  21. //---------------------------------------------------------------------------
  22. // DEBUG info
  23. //---------------------------------------------------------------------------
  24. SZTHISFILE
  27. //***************************************************************************
  28. //***************************************************************************
  29. //**
  30. //**  SpriteClass Class
  31. //**
  32. //***************************************************************************
  33. //***************************************************************************
  36. //***************************************************************************
  37. // Fire ISpriteClassEvents Events
  38. //***************************************************************************
  40. //---------------------------------------------------------------------------
  41. // 
  42. //---------------------------------------------------------------------------
  43. void CSpriteClass::FireInit
  44. (
  45.   CSprite *pspr,
  46.   VARIANT *pvarUser
  47. )
  48. {
  49.   IDispatch **ppdisp = m_cp.m_rgpdisp;
  50.   VARIANTARG  var[2];
  52.   VariantInit(&var[1]);
  53.   var[1].vt = VT_DISPATCH;
  54.   var[1].pdispVal = pspr->GetDispatch();
  55.   pspr->AddRef();
  56.   VariantInit(&var[0]);
  57.   VariantCopy(&var[0], pvarUser);
  59.   for (; ppdisp < &m_cp.m_rgpdisp[SC_cADVISE]; ppdisp++)
  60.     if (*ppdisp)
  61.       InvokeEvent(*ppdisp, DISPID_SpriteClassEvents_Init, var, 2);
  63.   pspr->Release();    // For var[1].pdispVal
  64.   VariantClear(&var[0]);
  65. }
  68. //---------------------------------------------------------------------------
  69. // 
  70. //---------------------------------------------------------------------------
  71. void CSpriteClass::FireTick
  72. (
  73.   CSprite *pspr
  74. )
  75. {
  76.   IDispatch **ppdisp = m_cp.m_rgpdisp;
  77.   VARIANTARG  var[1];
  79.   VariantInit(&var[0]);
  80.   var[0].vt = VT_DISPATCH;
  81.   var[0].pdispVal = pspr->GetDispatch();
  82.   pspr->AddRef();
  84.   for (; ppdisp < &m_cp.m_rgpdisp[SC_cADVISE]; ppdisp++)
  85.     if (*ppdisp)
  86.       InvokeEvent(*ppdisp, DISPID_SpriteClassEvents_Tick, var, 1);
  88.   pspr->Release();    // For var[0].pdispVal
  89. }
  92. //---------------------------------------------------------------------------
  93. // 
  94. //---------------------------------------------------------------------------
  95. void CSpriteClass::FireBorder
  96. (
  97.   CSprite *pspr,
  98.   BRD      brd
  99. )
  100. {
  101.   IDispatch **ppdisp = m_cp.m_rgpdisp;
  102.   VARIANTARG  var[2];
  104.   VariantInit(&var[1]);
  105.   var[1].vt = VT_DISPATCH;
  106.   var[1].pdispVal = pspr->GetDispatch();
  107.   pspr->AddRef();
  108.   VariantInit(&var[0]);
  109.   var[0].vt = VT_I4;
  110.   var[0].lVal = brd;
  112.   for (; ppdisp < &m_cp.m_rgpdisp[SC_cADVISE]; ppdisp++)
  113.     if (*ppdisp)
  114.       {
  115.       BOOL f;
  116.       HRESULT hr = InvokeEvent(*ppdisp, DISPID_SpriteClassEvents_Border, var, 2);
  117.       if (hr)
  118.         f = TRUE;
  119.       }
  121.   pspr->Release();    // For var[1].pdispVal
  122. }
  125. //---------------------------------------------------------------------------
  126. // 
  127. //---------------------------------------------------------------------------
  128. void CSpriteClass::FireTerm
  129. (
  130.   CSprite *pspr
  131. )
  132. {
  133.   IDispatch **ppdisp = m_cp.m_rgpdisp;
  134.   VARIANTARG  var[1];
  136.   VariantInit(&var[0]);
  137.   var[0].vt = VT_DISPATCH;
  138.   var[0].pdispVal = pspr->GetDispatch();
  139.   pspr->AddRef();
  141.   for (; ppdisp < &m_cp.m_rgpdisp[SC_cADVISE]; ppdisp++)
  142.     if (*ppdisp)
  143.       InvokeEvent(*ppdisp, DISPID_SpriteClassEvents_Term, var, 1);
  145.   pspr->Release();    // For var[0].pdispVal
  146. }
  149. //---------------------------------------------------------------------------
  150. // 
  151. //---------------------------------------------------------------------------
  152. void CSpriteClass::FireLastTerm
  153. (
  154.   void
  155. )
  156. {
  157.   IDispatch **ppdisp = m_cp.m_rgpdisp;
  159.   for (; ppdisp < &m_cp.m_rgpdisp[SC_cADVISE]; ppdisp++)
  160.     if (*ppdisp)
  161.       InvokeEvent(*ppdisp, DISPID_SpriteClassEvents_LastTerm, NULL, 0);
  162. }
  165. //***************************************************************************
  166. // ISpriteClass Interface
  167. //***************************************************************************
  169. //---------------------------------------------------------------------------
  170. // 
  171. //---------------------------------------------------------------------------
  172. STDMETHODIMP CSpriteClass::get_Application
  173. (
  174.   ISpruuidsApp** ppRet
  175. )
  176. {
  177.   if (!ppRet)
  178.     return E_INVALIDARG;
  179.   return g_punkApplicationNA->QueryInterface(IID_ISpruuidsApp, (void **)ppRet);
  180. }
  183. //---------------------------------------------------------------------------
  184. // 
  185. //---------------------------------------------------------------------------
  186. STDMETHODIMP CSpriteClass::get_Parent
  187. (
  188.   IGame** ppRet
  189. )
  190. {
  191.   if (!ppRet)
  192.     return E_INVALIDARG;
  193.   return m_pdisp->m_punkParent->QueryInterface(IID_IGame, (void **)ppRet);
  194. }
  197. //---------------------------------------------------------------------------
  198. // 
  199. //---------------------------------------------------------------------------
  200. STDMETHODIMP CSpriteClass::CreateSprite
  201. (
  202.   int       x,
  203.   int       y,
  204.   VARIANT   arg,
  205.   ISprite **ppRet
  206. )
  207. {
  208.   CSprite *pspr = new CSprite(this, x, y, NULL, &arg);
  209.   if (!pspr)
  210.     return E_OUTOFMEMORY;
  211.   *ppRet = pspr;
  212.   (*ppRet)->AddRef();
  213.   return S_OK;
  214. }
  217. //---------------------------------------------------------------------------
  218. // 
  219. //---------------------------------------------------------------------------
  220. STDMETHODIMP CSpriteClass::get_Tag
  221. (
  222.   VARIANT* pRet
  223. )
  224. {
  225.   if (!pRet)
  226.     return E_INVALIDARG;
  227.   VariantInit(pRet);
  228.   return VariantCopy(pRet, &m_varTag);
  229. }
  232. //---------------------------------------------------------------------------
  233. // 
  234. //---------------------------------------------------------------------------
  235. STDMETHODIMP CSpriteClass::put_Tag
  236. (
  237.   VARIANT val
  238. )
  239. {
  240.   return VariantCopy(&m_varTag, &val);
  241. }
  244. //---------------------------------------------------------------------------
  245. // 
  246. //---------------------------------------------------------------------------
  247. STDMETHODIMP CSpriteClass::get_Image
  248. (
  249.   int* pRet
  250. )
  251. {
  252.   if (!pRet)
  253.     return E_INVALIDARG;
  254.   *pRet = m_iimg;
  255.   return S_OK;
  256. }
  259. //---------------------------------------------------------------------------
  260. // 
  261. //---------------------------------------------------------------------------
  262. STDMETHODIMP CSpriteClass::put_Image
  263. (
  264.   int val
  265. )
  266. {
  267.   if (val > 0 && val < m_pdisp->m_cimg)
  268.     m_iimg = val;
  269.   return S_OK;
  270. }
  273. //---------------------------------------------------------------------------
  274. // 
  275. //---------------------------------------------------------------------------
  276. STDMETHODIMP CSpriteClass::get_Border
  277. (
  278.   int* pRet
  279. )
  280. {
  281.   if (!pRet)
  282.     return E_INVALIDARG;
  283.   *pRet = m_brd;
  284.   return S_OK;
  285. }
  288. //---------------------------------------------------------------------------
  289. // 
  290. //---------------------------------------------------------------------------
  291. STDMETHODIMP CSpriteClass::put_Border
  292. (
  293.   int val
  294. )
  295. {
  296.   m_brd = val;
  297.   return S_OK;
  298. }
  301. //---------------------------------------------------------------------------
  302. // 
  303. //---------------------------------------------------------------------------
  304. STDMETHODIMP CSpriteClass::get_Collide
  305. (
  306.   int* pRet
  307. )
  308. {
  309.   if (!pRet)
  310.     return E_INVALIDARG;
  311.   *pRet = m_maskCollide;
  312.   return S_OK;
  313. }
  316. //---------------------------------------------------------------------------
  317. // 
  318. //---------------------------------------------------------------------------
  319. STDMETHODIMP CSpriteClass::put_Collide
  320. (
  321.   int val
  322. )
  323. {
  324.   m_maskCollide = val;
  325.   return S_OK;
  326. }
  329. //---------------------------------------------------------------------------
  330. // 
  331. //---------------------------------------------------------------------------
  332. STDMETHODIMP CSpriteClass::get_MaximumVelocity
  333. (
  334.   FLOAT* pRet
  335. )
  336. {
  337.   if (!pRet)
  338.     return E_INVALIDARG;
  340.   *pRet = FLOATOFFULL(m_vFullMax);
  341.   return S_OK;
  342. }
  345. //---------------------------------------------------------------------------
  346. // 
  347. //---------------------------------------------------------------------------
  348. STDMETHODIMP CSpriteClass::put_MaximumVelocity
  349. (
  350.   FLOAT val
  351. )
  352. {
  353.   m_vFullMax = FULLOFFLOAT(val);
  354.   return S_OK;
  355. }
  358. //---------------------------------------------------------------------------
  359. // 
  360. //---------------------------------------------------------------------------
  361. STDMETHODIMP CSpriteClass::get_Friction
  362. (
  363.   FLOAT* pRet
  364. )
  365. {
  366.   if (!pRet)
  367.     return E_INVALIDARG;
  368.   *pRet = m_friction;
  369.   return S_OK;
  370. }
  373. //---------------------------------------------------------------------------
  374. // 
  375. //---------------------------------------------------------------------------
  376. STDMETHODIMP CSpriteClass::put_Friction
  377. (
  378.   FLOAT val
  379. )
  380. {
  381.   m_friction = val;
  382.   return S_OK;
  383. }
  386. //---------------------------------------------------------------------------
  387. // 
  388. //---------------------------------------------------------------------------
  389. STDMETHODIMP CSpriteClass::get_MaximumAcceleration
  390. (
  391.   FLOAT* pRet
  392. )
  393. {
  394.   if (!pRet)
  395.     return E_INVALIDARG;
  397.   *pRet = FLOATOFFULL(m_aFullMax);
  398.   return S_OK;
  399. }
  402. //---------------------------------------------------------------------------
  403. // 
  404. //---------------------------------------------------------------------------
  405. STDMETHODIMP CSpriteClass::put_MaximumAcceleration
  406. (
  407.   FLOAT val
  408. )
  409. {
  410.   m_aFullMax = FULLOFFLOAT(val);
  411.   return S_OK;
  412. }
  415. //---------------------------------------------------------------------------
  416. // 
  417. //---------------------------------------------------------------------------
  418. STDMETHODIMP CSpriteClass::get_AccelerationFriction
  419. (
  420.   FLOAT* pRet
  421. )
  422. {
  423.   if (!pRet)
  424.     return E_INVALIDARG;
  425.   *pRet = m_frictionAccel;
  426.   return S_OK;
  427. }
  430. //---------------------------------------------------------------------------
  431. // 
  432. //---------------------------------------------------------------------------
  433. STDMETHODIMP CSpriteClass::put_AccelerationFriction
  434. (
  435.   FLOAT val
  436. )
  437. {
  438.   m_frictionAccel = val;
  439.   m_fFrictionAccel = (val != (FLOAT)1.0);
  440.   return S_OK;
  441. }
  444. //---------------------------------------------------------------------------
  445. // 
  446. //---------------------------------------------------------------------------
  447. STDMETHODIMP CSpriteClass::get_SpriteCount
  448. (
  449.   int* pRet
  450. )
  451. {
  452.   if (!pRet)
  453.     return E_INVALIDARG;
  454.   *pRet = m_cspr;
  455.   return S_OK;
  456. }
  460. //***************************************************************************
  461. //***************************************************************************
  462. //**
  463. //**  Sprite Class
  464. //**
  465. //***************************************************************************
  466. //***************************************************************************
  469. //***************************************************************************
  470. // ISprite Interface
  471. //***************************************************************************
  473. //---------------------------------------------------------------------------
  474. // 
  475. //---------------------------------------------------------------------------
  476. STDMETHODIMP CSprite::get_Application
  477. (
  478.   ISpruuidsApp** ppRet
  479. )
  480. {
  481.   if (!ppRet)
  482.     return E_INVALIDARG;
  483.   return g_punkApplicationNA->QueryInterface(IID_ISpruuidsApp, (void **)ppRet);
  484. }
  487. //---------------------------------------------------------------------------
  488. // 
  489. //---------------------------------------------------------------------------
  490. STDMETHODIMP CSprite::get_Parent
  491. (
  492.   ISpriteClass** ppRet
  493. )
  494. {
  495.   if (!ppRet)
  496.     return E_INVALIDARG;
  497.   return m_psc->QueryInterface(IID_ISpriteClass, (void **)ppRet);
  498. }
  501. //---------------------------------------------------------------------------
  502. // 
  503. //---------------------------------------------------------------------------
  504. STDMETHODIMP CSprite::MoveTo
  505. (
  506.   FLOAT x,
  507.   FLOAT y
  508. )
  509. {
  510.   this->MoveToFull(FULLOFFLOAT(x), FULLOFFLOAT(y), TRUE);
  511.   return S_OK;
  512. }
  515. //---------------------------------------------------------------------------
  516. // 
  517. //---------------------------------------------------------------------------
  518. STDMETHODIMP CSprite::MoveBy
  519. (
  520.   FLOAT dx,
  521.   FLOAT dy
  522. )
  523. {
  524.   this->MoveByFull(FULLOFFLOAT(dx), FULLOFFLOAT(dy), TRUE);
  525.   return S_OK;
  526. }
  530. //---------------------------------------------------------------------------
  531. //
  532. //---------------------------------------------------------------------------
  533. STDMETHODIMP CSprite::MoveAtSprite
  534. (
  535.   ISprite* sprite,
  536.   float    dMax,
  537.   float    scale,
  538.   long     flags
  539. )
  540. {
  541.   if (!sprite)
  542.     return E_INVALIDARG;
  544.   // Store parameters & do every tickMove ticks if MAS_REMEMBER set.
  545.   if (flags & MAS_REMEMBER)
  546.     {
  547.     if (m_psprAt)
  548.       {
  549.       m_psprAt->Release();
  550.       m_psprAt = NULL;
  551.       }
  552.     m_psprAt = (CSprite *)(void *)sprite;
  553.     if (!m_psprAt)
  554.       return S_OK;
  555.     m_psprAt->AddRef();
  556.     m_dMaxAt = dMax;
  557.     m_scaleAt = scale;
  558.     m_flagsAt = flags;
  559.     return S_OK;
  560.     }
  562.   // Otherwise, do this right now.
  563.   this->DoMoveAt((CSprite *)(void *)sprite, dMax, scale, flags, FALSE);
  564.   return S_OK;
  565. }
  569. //---------------------------------------------------------------------------
  570. // 
  571. //---------------------------------------------------------------------------
  572. STDMETHODIMP CSprite::Remove
  573. (
  574.   void 
  575. )
  576. {
  577.   this->MarkFree();
  578.   return S_OK;
  579. }
  582. //---------------------------------------------------------------------------
  583. // 
  584. //---------------------------------------------------------------------------
  585. STDMETHODIMP CSprite::Refresh
  586. (
  587.   void 
  588. )
  589. {
  590.   this->_FDraw(FALSE);
  591.   return S_OK;
  592. }
  595. //---------------------------------------------------------------------------
  596. // 
  597. //---------------------------------------------------------------------------
  598. STDMETHODIMP CSprite::IgnoreMove
  599. (
  600.   void 
  601. )
  602. {
  603.   m_fIgnoreMove = TRUE;
  604.   return S_OK;
  605. }
  608. //---------------------------------------------------------------------------
  609. // 
  610. //---------------------------------------------------------------------------
  611. STDMETHODIMP CSprite::get_Left
  612. (
  613.   FLOAT* pRet
  614. )
  615. {
  616.   if (!pRet)
  617.     return E_INVALIDARG;
  619.   *pRet = FLOATOFFULL(m_xFull);
  620.   return S_OK;
  621. }
  624. //---------------------------------------------------------------------------
  625. // 
  626. //---------------------------------------------------------------------------
  627. STDMETHODIMP CSprite::put_Left
  628. (
  629.   FLOAT val
  630. )
  631. {
  632.   m_xFull = FULLOFFLOAT(val);
  633.   return S_OK;
  634. }
  637. //---------------------------------------------------------------------------
  638. // 
  639. //---------------------------------------------------------------------------
  640. STDMETHODIMP CSprite::get_Top
  641. (
  642.   FLOAT* pRet
  643. )
  644. {
  645.   if (!pRet)
  646.     return E_INVALIDARG;
  648.   *pRet = FLOATOFFULL(m_yFull);
  649.   return S_OK;
  650. }
  653. //---------------------------------------------------------------------------
  654. // 
  655. //---------------------------------------------------------------------------
  656. STDMETHODIMP CSprite::put_Top
  657. (
  658.   FLOAT val
  659. )
  660. {
  661.   m_yFull = FULLOFFLOAT(val);
  662.   return S_OK;
  663. }
  666. //---------------------------------------------------------------------------
  667. // 
  668. //---------------------------------------------------------------------------
  669. STDMETHODIMP CSprite::get_Vx
  670. (
  671.   FLOAT* pRet
  672. )
  673. {
  674.   if (!pRet)
  675.     return E_INVALIDARG;
  677.   *pRet = FLOATOFFULL(m_vxFull);
  678.   return S_OK;
  679. }
  682. //---------------------------------------------------------------------------
  683. // 
  684. //---------------------------------------------------------------------------
  685. STDMETHODIMP CSprite::put_Vx
  686. (
  687.   FLOAT val
  688. )
  689. {
  690.   m_vxFull = FULLOFFLOAT(val);
  691.   return S_OK;
  692. }
  695. //---------------------------------------------------------------------------
  696. // 
  697. //---------------------------------------------------------------------------
  698. STDMETHODIMP CSprite::get_Vy
  699. (
  700.   FLOAT* pRet
  701. )
  702. {
  703.   if (!pRet)
  704.     return E_INVALIDARG;
  706.   *pRet = FLOATOFFULL(m_vyFull);
  707.   return S_OK;
  708. }
  711. //---------------------------------------------------------------------------
  712. // 
  713. //---------------------------------------------------------------------------
  714. STDMETHODIMP CSprite::put_Vy
  715. (
  716.   FLOAT val
  717. )
  718. {
  719.   m_vyFull = FULLOFFLOAT(val);
  720.   return S_OK;
  721. }
  724. //---------------------------------------------------------------------------
  725. // 
  726. //---------------------------------------------------------------------------
  727. STDMETHODIMP CSprite::get_Ax
  728. (
  729.   FLOAT* pRet
  730. )
  731. {
  732.   if (!pRet)
  733.     return E_INVALIDARG;
  735.   *pRet = FLOATOFFULL(m_axFull);
  736.   return S_OK;
  737. }
  740. //---------------------------------------------------------------------------
  741. // 
  742. //---------------------------------------------------------------------------
  743. STDMETHODIMP CSprite::put_Ax
  744. (
  745.   FLOAT val
  746. )
  747. {
  748.   m_axFull = FULLOFFLOAT(val);
  749.   return S_OK;
  750. }
  753. //---------------------------------------------------------------------------
  754. // 
  755. //---------------------------------------------------------------------------
  756. STDMETHODIMP CSprite::get_Ay
  757. (
  758.   FLOAT* pRet
  759. )
  760. {
  761.   if (!pRet)
  762.     return E_INVALIDARG;
  764.   *pRet = FLOATOFFULL(m_ayFull);
  765.   return S_OK;
  766. }
  769. //---------------------------------------------------------------------------
  770. // 
  771. //---------------------------------------------------------------------------
  772. STDMETHODIMP CSprite::put_Ay
  773. (
  774.   FLOAT val
  775. )
  776. {
  777.   m_ayFull = FULLOFFLOAT(val);
  778.   return S_OK;
  779. }
  782. //---------------------------------------------------------------------------
  783. // 
  784. //---------------------------------------------------------------------------
  785. STDMETHODIMP CSprite::get_FrictionX
  786. (
  787.   FLOAT* pRet
  788. )
  789. {
  790.   if (!pRet)
  791.     return E_INVALIDARG;
  793.   *pRet = m_fx;
  794.   return S_OK;
  795. }
  798. //---------------------------------------------------------------------------
  799. // 
  800. //---------------------------------------------------------------------------
  801. STDMETHODIMP CSprite::put_FrictionX
  802. (
  803.   FLOAT val
  804. )
  805. {
  806.   m_fx = val;
  807.   m_fFriction = (m_fx != 1.0) || (m_fy != 1.0);
  808.   return S_OK;
  809. }
  812. //---------------------------------------------------------------------------
  813. // 
  814. //---------------------------------------------------------------------------
  815. STDMETHODIMP CSprite::get_FrictionY
  816. (
  817.   FLOAT* pRet
  818. )
  819. {
  820.   if (!pRet)
  821.     return E_INVALIDARG;
  823.   *pRet = m_fy;
  824.   return S_OK;
  825. }
  828. //---------------------------------------------------------------------------
  829. // 
  830. //---------------------------------------------------------------------------
  831. STDMETHODIMP CSprite::put_FrictionY
  832. (
  833.   FLOAT val
  834. )
  835. {
  836.   m_fy = val;
  837.   m_fFriction = (m_fx != 1.0) || (m_fy != 1.0);
  838.   return S_OK;
  839. }
  842. //---------------------------------------------------------------------------
  843. // 
  844. //---------------------------------------------------------------------------
  845. STDMETHODIMP CSprite::get_Width
  846. (
  847.   int* pRet
  848. )
  849. {
  850.   if (!pRet)
  851.     return E_INVALIDARG;
  852.   *pRet = m_pimg->cx;
  853.   return S_OK;
  854. }
  857. //---------------------------------------------------------------------------
  858. // 
  859. //---------------------------------------------------------------------------
  860. STDMETHODIMP CSprite::get_Height
  861. (
  862.   int* pRet
  863. )
  864. {
  865.   if (!pRet)
  866.     return E_INVALIDARG;
  867.   *pRet = m_pimg->cy;
  868.   return S_OK;
  869. }
  872. //---------------------------------------------------------------------------
  873. // 
  874. //---------------------------------------------------------------------------
  875. STDMETHODIMP CSprite::get_Image
  876. (
  877.   int* pRet
  878. )
  879. {
  880.   if (!pRet)
  881.     return E_INVALIDARG;
  882.   *pRet = m_iimg;
  883.   return S_OK;
  884. }
  887. //---------------------------------------------------------------------------
  888. // 
  889. //---------------------------------------------------------------------------
  890. STDMETHODIMP CSprite::put_Image
  891. (
  892.   int val
  893. )
  894. {
  895.   if (val >= 0 && val < m_pdisp->m_cimg)
  896.     {
  897.     PIMG pimgCur = m_pimg;
  899.     if (!m_fHidden)
  900.       this->_Erase();
  901.     m_iimg = val;
  902.     m_pimg = &(m_pdisp->m_prgimg[m_iimg]);
  903.     // Keep image centered, if Visible
  904.     if (!m_fHidden)
  905.       {
  906.       m_x += (pimgCur->cx - m_pimg->cx) >> 1;
  907.       m_y += (pimgCur->cy - m_pimg->cy) >> 1;
  908.       this->_FDraw(FALSE);
  909.       }
  910.     }
  911.   return S_OK;
  912. }
  915. //---------------------------------------------------------------------------
  916. // 
  917. //---------------------------------------------------------------------------
  918. STDMETHODIMP CSprite::get_TickMove
  919. (
  920.   int* pRet
  921. )
  922. {
  923.   if (!pRet)
  924.     return E_INVALIDARG;
  925.   *pRet = m_tickMoveMax;
  926.   return S_OK;
  927. }
  930. //---------------------------------------------------------------------------
  931. // 
  932. //---------------------------------------------------------------------------
  933. STDMETHODIMP CSprite::put_TickMove
  934. (
  935.   int val
  936. )
  937. {
  938.   m_tickMoveMax = val;
  939.   if (m_tickMove > m_tickMoveMax)
  940.     m_tickMove = m_tickMoveMax;
  941.   return S_OK;
  942. }
  945. //---------------------------------------------------------------------------
  946. // 
  947. //---------------------------------------------------------------------------
  948. STDMETHODIMP CSprite::get_TickEvent
  949. (
  950.   int* pRet
  951. )
  952. {
  953.   if (!pRet)
  954.     return E_INVALIDARG;
  955.   *pRet = m_tickEvtMax;
  956.   return S_OK;
  957. }
  960. //---------------------------------------------------------------------------
  961. // 
  962. //---------------------------------------------------------------------------
  963. STDMETHODIMP CSprite::put_TickEvent
  964. (
  965.   int val
  966. )
  967. {
  968.   m_tickEvtMax = val;
  969.   if (m_tickEvt > m_tickEvtMax)
  970.     m_tickEvt = m_tickEvtMax;
  971.   return S_OK;
  972. }
  975. //---------------------------------------------------------------------------
  976. // 
  977. //---------------------------------------------------------------------------
  978. STDMETHODIMP CSprite::get_Visible
  979. (
  980.   VARIANT_BOOL* pRet
  981. )
  982. {
  983.   if (!pRet)
  984.     return E_INVALIDARG;
  985.   *pRet = m_fHidden ? 0 : -1;
  986.   return S_OK;
  987. }
  990. //---------------------------------------------------------------------------
  991. // 
  992. //---------------------------------------------------------------------------
  993. STDMETHODIMP CSprite::put_Visible
  994. (
  995.   VARIANT_BOOL val
  996. )
  997. {
  998.   if (m_fLinked)
  999.     {
  1000.     m_fHidden = !val;
  1001.     if (!m_fHidden)
  1002.       this->_Erase();
  1003.     else
  1004.       this->_FDraw(FALSE);
  1005.     }
  1006.   return S_OK;
  1007. }
  1010. //---------------------------------------------------------------------------
  1011. // 
  1012. //---------------------------------------------------------------------------
  1013. STDMETHODIMP CSprite::get_Tag
  1014. (
  1015.   VARIANT* pRet
  1016. )
  1017. {
  1018.   if (!pRet)
  1019.     return E_INVALIDARG;
  1020.   VariantInit(pRet);
  1021.   return VariantCopy(pRet, &m_varTag);
  1022. }
  1025. //---------------------------------------------------------------------------
  1026. // 
  1027. //---------------------------------------------------------------------------
  1028. STDMETHODIMP CSprite::put_Tag
  1029. (
  1030.   VARIANT val
  1031. )
  1032. {
  1033.   return VariantCopy(&m_varTag, &val);
  1034. }
  1036. //--- EOF -------------------------------------------------------------------