home *** CD-ROM | disk | FTP | other *** search
/ Tricks of the Windows Gam…ming Gurus (2nd Edition) / Disc2.iso / msdn_vcb / samples / vc98 / sdk / com / tutsamp / dcdmarsh / papint_p.c < prev    next >
C/C++ Source or Header  |  1998-03-30  |  71KB  |  2,371 lines
  1. /* this ALWAYS GENERATED file contains the proxy stub code */
  2.  
  3.  
  4. /* File created by MIDL compiler version 3.03.0110 */
  5. /* at Mon Mar 30 03:39:58 1998
  6.  */
  7. /* Compiler settings for papint.idl:
  8.     Os (OptLev=s), W1, Zp8, env=Win32, ms_ext, app_config, c_ext
  9.     error checks: none
  10. */
  11. //@@MIDL_FILE_HEADING(  )
  12.  
  13.  
  14. /* verify that the <rpcproxy.h> version is high enough to compile this file*/
  15. #ifndef __REDQ_RPCPROXY_H_VERSION__
  16. #define __REQUIRED_RPCPROXY_H_VERSION__ 440
  17. #endif
  18.  
  19.  
  20. #include "rpcproxy.h"
  21. #ifndef __RPCPROXY_H_VERSION__
  22. #error this stub requires an updated version of <rpcproxy.h>
  23. #endif // __RPCPROXY_H_VERSION__
  24.  
  25.  
  26. #include "papint.h"
  27.  
  28. #define TYPE_FORMAT_STRING_SIZE   27                                
  29. #define PROC_FORMAT_STRING_SIZE   69                                
  30.  
  31. typedef struct _MIDL_TYPE_FORMAT_STRING
  32.     {
  33.     short          Pad;
  34.     unsigned char  Format[ TYPE_FORMAT_STRING_SIZE ];
  35.     } MIDL_TYPE_FORMAT_STRING;
  36.  
  37. typedef struct _MIDL_PROC_FORMAT_STRING
  38.     {
  39.     short          Pad;
  40.     unsigned char  Format[ PROC_FORMAT_STRING_SIZE ];
  41.     } MIDL_PROC_FORMAT_STRING;
  42.  
  43.  
  44. extern const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString;
  45. extern const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString;
  46.  
  47.  
  48. /* Object interface: IUnknown, ver. 0.0,
  49.    GUID={0x00000000,0x0000,0x0000,{0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
  50.  
  51.  
  52. /* Object interface: ISharePaper, ver. 0.0,
  53.    GUID={0x0002da31,0x0000,0x0000,{0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
  54.  
  55.  
  56. extern const MIDL_STUB_DESC Object_StubDesc;
  57.  
  58.  
  59. #pragma code_seg(".orpc")
  60.  
  61. HRESULT STDMETHODCALLTYPE ISharePaper_InitPaper_Proxy( 
  62.     ISharePaper __RPC_FAR * This,
  63.     /* [out][in] */ RECT __RPC_FAR *pWinRect,
  64.     /* [out] */ BOOL __RPC_FAR *pbFirst)
  65. {
  66.  
  67.     HRESULT _RetVal;
  68.     
  69.     RPC_MESSAGE _RpcMessage;
  70.     
  71.     MIDL_STUB_MESSAGE _StubMsg;
  72.     
  73.     RpcTryExcept
  74.         {
  75.         NdrProxyInitialize(
  76.                       ( void __RPC_FAR *  )This,
  77.                       ( PRPC_MESSAGE  )&_RpcMessage,
  78.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  79.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  80.                       3);
  81.         
  82.         
  83.         
  84.         RpcTryFinally
  85.             {
  86.             
  87.             _StubMsg.BufferLength = 0U;
  88.             NdrSimpleStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  89.                                        (unsigned char __RPC_FAR *)pWinRect,
  90.                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[4] );
  91.             
  92.             NdrProxyGetBuffer(This, &_StubMsg);
  93.             NdrSimpleStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  94.                                      (unsigned char __RPC_FAR *)pWinRect,
  95.                                      (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[4] );
  96.             
  97.             NdrProxySendReceive(This, &_StubMsg);
  98.             
  99.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  100.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
  101.             
  102.             NdrSimpleStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  103.                                        (unsigned char __RPC_FAR * __RPC_FAR *)&pWinRect,
  104.                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[4],
  105.                                        (unsigned char)0 );
  106.             
  107.             *pbFirst = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
  108.             
  109.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  110.             
  111.             }
  112.         RpcFinally
  113.             {
  114.             NdrProxyFreeBuffer(This, &_StubMsg);
  115.             
  116.             }
  117.         RpcEndFinally
  118.         
  119.         }
  120.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  121.         {
  122.         NdrClearOutParameters(
  123.                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  124.                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[0],
  125.                          ( void __RPC_FAR * )pWinRect);
  126.         NdrClearOutParameters(
  127.                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  128.                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[14],
  129.                          ( void __RPC_FAR * )pbFirst);
  130.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  131.         }
  132.     RpcEndExcept
  133.     return _RetVal;
  134. }
  135.  
  136. void __RPC_STUB ISharePaper_InitPaper_Stub(
  137.     IRpcStubBuffer *This,
  138.     IRpcChannelBuffer *_pRpcChannelBuffer,
  139.     PRPC_MESSAGE _pRpcMessage,
  140.     DWORD *_pdwStubPhase)
  141. {
  142.     BOOL _M0;
  143.     HRESULT _RetVal;
  144.     MIDL_STUB_MESSAGE _StubMsg;
  145.     RECT __RPC_FAR *pWinRect;
  146.     BOOL __RPC_FAR *pbFirst;
  147.     
  148. NdrStubInitialize(
  149.                      _pRpcMessage,
  150.                      &_StubMsg,
  151.                      &Object_StubDesc,
  152.                      _pRpcChannelBuffer);
  153.     ( RECT __RPC_FAR * )pWinRect = 0;
  154.     ( BOOL __RPC_FAR * )pbFirst = 0;
  155.     RpcTryFinally
  156.         {
  157.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  158.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
  159.         
  160.         NdrSimpleStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  161.                                    (unsigned char __RPC_FAR * __RPC_FAR *)&pWinRect,
  162.                                    (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[4],
  163.                                    (unsigned char)0 );
  164.         
  165.         pbFirst = &_M0;
  166.         
  167.         *_pdwStubPhase = STUB_CALL_SERVER;
  168.         _RetVal = (((ISharePaper *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> InitPaper(
  169.              (ISharePaper *) ((CStdStubBuffer *)This)->pvServerObject,
  170.              pWinRect,
  171.              pbFirst);
  172.         
  173.         *_pdwStubPhase = STUB_MARSHAL;
  174.         
  175.         _StubMsg.BufferLength = 0U + 11U + 7U;
  176.         NdrSimpleStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  177.                                    (unsigned char __RPC_FAR *)pWinRect,
  178.                                    (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[4] );
  179.         
  180.         _StubMsg.BufferLength += 16;
  181.         
  182.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  183.         NdrSimpleStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  184.                                  (unsigned char __RPC_FAR *)pWinRect,
  185.                                  (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[4] );
  186.         
  187.         *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = *pbFirst;
  188.         
  189.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  190.         
  191.         }
  192.     RpcFinally
  193.         {
  194.         }
  195.     RpcEndFinally
  196.     _pRpcMessage->BufferLength = 
  197.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  198.     
  199. }
  200.  
  201.  
  202. HRESULT STDMETHODCALLTYPE ISharePaper_Lock_Proxy( 
  203.     ISharePaper __RPC_FAR * This,
  204.     /* [in] */ BOOL bLock)
  205. {
  206.  
  207.     HRESULT _RetVal;
  208.     
  209.     RPC_MESSAGE _RpcMessage;
  210.     
  211.     MIDL_STUB_MESSAGE _StubMsg;
  212.     
  213.     RpcTryExcept
  214.         {
  215.         NdrProxyInitialize(
  216.                       ( void __RPC_FAR *  )This,
  217.                       ( PRPC_MESSAGE  )&_RpcMessage,
  218.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  219.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  220.                       4);
  221.         
  222.         
  223.         
  224.         RpcTryFinally
  225.             {
  226.             
  227.             _StubMsg.BufferLength = 4U;
  228.             NdrProxyGetBuffer(This, &_StubMsg);
  229.             *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = bLock;
  230.             
  231.             NdrProxySendReceive(This, &_StubMsg);
  232.             
  233.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  234.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[10] );
  235.             
  236.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  237.             
  238.             }
  239.         RpcFinally
  240.             {
  241.             NdrProxyFreeBuffer(This, &_StubMsg);
  242.             
  243.             }
  244.         RpcEndFinally
  245.         
  246.         }
  247.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  248.         {
  249.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  250.         }
  251.     RpcEndExcept
  252.     return _RetVal;
  253. }
  254.  
  255. void __RPC_STUB ISharePaper_Lock_Stub(
  256.     IRpcStubBuffer *This,
  257.     IRpcChannelBuffer *_pRpcChannelBuffer,
  258.     PRPC_MESSAGE _pRpcMessage,
  259.     DWORD *_pdwStubPhase)
  260. {
  261.     HRESULT _RetVal;
  262.     MIDL_STUB_MESSAGE _StubMsg;
  263.     BOOL bLock;
  264.     
  265. NdrStubInitialize(
  266.                      _pRpcMessage,
  267.                      &_StubMsg,
  268.                      &Object_StubDesc,
  269.                      _pRpcChannelBuffer);
  270.     RpcTryFinally
  271.         {
  272.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  273.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[10] );
  274.         
  275.         bLock = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
  276.         
  277.         
  278.         *_pdwStubPhase = STUB_CALL_SERVER;
  279.         _RetVal = (((ISharePaper *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Lock((ISharePaper *) ((CStdStubBuffer *)This)->pvServerObject,bLock);
  280.         
  281.         *_pdwStubPhase = STUB_MARSHAL;
  282.         
  283.         _StubMsg.BufferLength = 4U;
  284.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  285.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  286.         
  287.         }
  288.     RpcFinally
  289.         {
  290.         }
  291.     RpcEndFinally
  292.     _pRpcMessage->BufferLength = 
  293.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  294.     
  295. }
  296.  
  297.  
  298. HRESULT STDMETHODCALLTYPE ISharePaper_Load_Proxy( 
  299.     ISharePaper __RPC_FAR * This,
  300.     /* [out] */ RECT __RPC_FAR *pWinRect)
  301. {
  302.  
  303.     HRESULT _RetVal;
  304.     
  305.     RPC_MESSAGE _RpcMessage;
  306.     
  307.     MIDL_STUB_MESSAGE _StubMsg;
  308.     
  309.     MIDL_memset(
  310.                pWinRect,
  311.                0,
  312.                sizeof( RECT  ));
  313.     RpcTryExcept
  314.         {
  315.         NdrProxyInitialize(
  316.                       ( void __RPC_FAR *  )This,
  317.                       ( PRPC_MESSAGE  )&_RpcMessage,
  318.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  319.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  320.                       5);
  321.         
  322.         
  323.         
  324.         RpcTryFinally
  325.             {
  326.             
  327.             _StubMsg.BufferLength = 0U;
  328.             NdrProxyGetBuffer(This, &_StubMsg);
  329.             NdrProxySendReceive(This, &_StubMsg);
  330.             
  331.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  332.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[14] );
  333.             
  334.             NdrSimpleStructUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
  335.                                        (unsigned char __RPC_FAR * __RPC_FAR *)&pWinRect,
  336.                                        (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[4],
  337.                                        (unsigned char)0 );
  338.             
  339.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  340.             
  341.             }
  342.         RpcFinally
  343.             {
  344.             NdrProxyFreeBuffer(This, &_StubMsg);
  345.             
  346.             }
  347.         RpcEndFinally
  348.         
  349.         }
  350.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  351.         {
  352.         NdrClearOutParameters(
  353.                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  354.                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[18],
  355.                          ( void __RPC_FAR * )pWinRect);
  356.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  357.         }
  358.     RpcEndExcept
  359.     return _RetVal;
  360. }
  361.  
  362. void __RPC_STUB ISharePaper_Load_Stub(
  363.     IRpcStubBuffer *This,
  364.     IRpcChannelBuffer *_pRpcChannelBuffer,
  365.     PRPC_MESSAGE _pRpcMessage,
  366.     DWORD *_pdwStubPhase)
  367. {
  368.     HRESULT _RetVal;
  369.     MIDL_STUB_MESSAGE _StubMsg;
  370.     RECT _pWinRectM;
  371.     RECT __RPC_FAR *pWinRect;
  372.     
  373. NdrStubInitialize(
  374.                      _pRpcMessage,
  375.                      &_StubMsg,
  376.                      &Object_StubDesc,
  377.                      _pRpcChannelBuffer);
  378.     ( RECT __RPC_FAR * )pWinRect = 0;
  379.     RpcTryFinally
  380.         {
  381.         pWinRect = &_pWinRectM;
  382.         
  383.         *_pdwStubPhase = STUB_CALL_SERVER;
  384.         _RetVal = (((ISharePaper *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Load((ISharePaper *) ((CStdStubBuffer *)This)->pvServerObject,pWinRect);
  385.         
  386.         *_pdwStubPhase = STUB_MARSHAL;
  387.         
  388.         _StubMsg.BufferLength = 0U + 11U;
  389.         NdrSimpleStructBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
  390.                                    (unsigned char __RPC_FAR *)pWinRect,
  391.                                    (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[4] );
  392.         
  393.         _StubMsg.BufferLength += 16;
  394.         
  395.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  396.         NdrSimpleStructMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
  397.                                  (unsigned char __RPC_FAR *)pWinRect,
  398.                                  (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[4] );
  399.         
  400.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  401.         
  402.         }
  403.     RpcFinally
  404.         {
  405.         }
  406.     RpcEndFinally
  407.     _pRpcMessage->BufferLength = 
  408.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  409.     
  410. }
  411.  
  412.  
  413. HRESULT STDMETHODCALLTYPE ISharePaper_Save_Proxy( 
  414.     ISharePaper __RPC_FAR * This)
  415. {
  416.  
  417.     HRESULT _RetVal;
  418.     
  419.     RPC_MESSAGE _RpcMessage;
  420.     
  421.     MIDL_STUB_MESSAGE _StubMsg;
  422.     
  423.     RpcTryExcept
  424.         {
  425.         NdrProxyInitialize(
  426.                       ( void __RPC_FAR *  )This,
  427.                       ( PRPC_MESSAGE  )&_RpcMessage,
  428.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  429.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  430.                       6);
  431.         
  432.         
  433.         
  434.         RpcTryFinally
  435.             {
  436.             
  437.             _StubMsg.BufferLength = 0U;
  438.             NdrProxyGetBuffer(This, &_StubMsg);
  439.             NdrProxySendReceive(This, &_StubMsg);
  440.             
  441.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  442.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
  443.             
  444.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  445.             
  446.             }
  447.         RpcFinally
  448.             {
  449.             NdrProxyFreeBuffer(This, &_StubMsg);
  450.             
  451.             }
  452.         RpcEndFinally
  453.         
  454.         }
  455.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  456.         {
  457.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  458.         }
  459.     RpcEndExcept
  460.     return _RetVal;
  461. }
  462.  
  463. void __RPC_STUB ISharePaper_Save_Stub(
  464.     IRpcStubBuffer *This,
  465.     IRpcChannelBuffer *_pRpcChannelBuffer,
  466.     PRPC_MESSAGE _pRpcMessage,
  467.     DWORD *_pdwStubPhase)
  468. {
  469.     HRESULT _RetVal;
  470.     MIDL_STUB_MESSAGE _StubMsg;
  471.     
  472. NdrStubInitialize(
  473.                      _pRpcMessage,
  474.                      &_StubMsg,
  475.                      &Object_StubDesc,
  476.                      _pRpcChannelBuffer);
  477.     RpcTryFinally
  478.         {
  479.         
  480.         *_pdwStubPhase = STUB_CALL_SERVER;
  481.         _RetVal = (((ISharePaper *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Save((ISharePaper *) ((CStdStubBuffer *)This)->pvServerObject);
  482.         
  483.         *_pdwStubPhase = STUB_MARSHAL;
  484.         
  485.         _StubMsg.BufferLength = 4U;
  486.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  487.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  488.         
  489.         }
  490.     RpcFinally
  491.         {
  492.         }
  493.     RpcEndFinally
  494.     _pRpcMessage->BufferLength = 
  495.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  496.     
  497. }
  498.  
  499.  
  500. HRESULT STDMETHODCALLTYPE ISharePaper_InkStart_Proxy( 
  501.     ISharePaper __RPC_FAR * This,
  502.     /* [in] */ SHORT nX,
  503.     /* [in] */ SHORT nY,
  504.     /* [in] */ SHORT nInkWidth,
  505.     /* [in] */ COLORREF crInkColor)
  506. {
  507.  
  508.     HRESULT _RetVal;
  509.     
  510.     RPC_MESSAGE _RpcMessage;
  511.     
  512.     MIDL_STUB_MESSAGE _StubMsg;
  513.     
  514.     RpcTryExcept
  515.         {
  516.         NdrProxyInitialize(
  517.                       ( void __RPC_FAR *  )This,
  518.                       ( PRPC_MESSAGE  )&_RpcMessage,
  519.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  520.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  521.                       7);
  522.         
  523.         
  524.         
  525.         RpcTryFinally
  526.             {
  527.             
  528.             _StubMsg.BufferLength = 2U + 2U + 2U + 6U;
  529.             NdrProxyGetBuffer(This, &_StubMsg);
  530.             *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++ = nX;
  531.             
  532.             *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++ = nY;
  533.             
  534.             *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++ = nInkWidth;
  535.             
  536.             _StubMsg.Buffer += 2;
  537.             *(( COLORREF __RPC_FAR * )_StubMsg.Buffer)++ = crInkColor;
  538.             
  539.             NdrProxySendReceive(This, &_StubMsg);
  540.             
  541.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  542.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[22] );
  543.             
  544.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  545.             
  546.             }
  547.         RpcFinally
  548.             {
  549.             NdrProxyFreeBuffer(This, &_StubMsg);
  550.             
  551.             }
  552.         RpcEndFinally
  553.         
  554.         }
  555.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  556.         {
  557.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  558.         }
  559.     RpcEndExcept
  560.     return _RetVal;
  561. }
  562.  
  563. void __RPC_STUB ISharePaper_InkStart_Stub(
  564.     IRpcStubBuffer *This,
  565.     IRpcChannelBuffer *_pRpcChannelBuffer,
  566.     PRPC_MESSAGE _pRpcMessage,
  567.     DWORD *_pdwStubPhase)
  568. {
  569.     HRESULT _RetVal;
  570.     MIDL_STUB_MESSAGE _StubMsg;
  571.     COLORREF crInkColor;
  572.     SHORT nInkWidth;
  573.     SHORT nX;
  574.     SHORT nY;
  575.     
  576. NdrStubInitialize(
  577.                      _pRpcMessage,
  578.                      &_StubMsg,
  579.                      &Object_StubDesc,
  580.                      _pRpcChannelBuffer);
  581.     RpcTryFinally
  582.         {
  583.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  584.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[22] );
  585.         
  586.         nX = *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++;
  587.         
  588.         nY = *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++;
  589.         
  590.         nInkWidth = *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++;
  591.         
  592.         _StubMsg.Buffer += 2;
  593.         crInkColor = *(( COLORREF __RPC_FAR * )_StubMsg.Buffer)++;
  594.         
  595.         
  596.         *_pdwStubPhase = STUB_CALL_SERVER;
  597.         _RetVal = (((ISharePaper *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> InkStart(
  598.             (ISharePaper *) ((CStdStubBuffer *)This)->pvServerObject,
  599.             nX,
  600.             nY,
  601.             nInkWidth,
  602.             crInkColor);
  603.         
  604.         *_pdwStubPhase = STUB_MARSHAL;
  605.         
  606.         _StubMsg.BufferLength = 4U;
  607.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  608.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  609.         
  610.         }
  611.     RpcFinally
  612.         {
  613.         }
  614.     RpcEndFinally
  615.     _pRpcMessage->BufferLength = 
  616.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  617.     
  618. }
  619.  
  620.  
  621. HRESULT STDMETHODCALLTYPE ISharePaper_InkDraw_Proxy( 
  622.     ISharePaper __RPC_FAR * This,
  623.     /* [in] */ SHORT nX,
  624.     /* [in] */ SHORT nY)
  625. {
  626.  
  627.     HRESULT _RetVal;
  628.     
  629.     RPC_MESSAGE _RpcMessage;
  630.     
  631.     MIDL_STUB_MESSAGE _StubMsg;
  632.     
  633.     RpcTryExcept
  634.         {
  635.         NdrProxyInitialize(
  636.                       ( void __RPC_FAR *  )This,
  637.                       ( PRPC_MESSAGE  )&_RpcMessage,
  638.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  639.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  640.                       8);
  641.         
  642.         
  643.         
  644.         RpcTryFinally
  645.             {
  646.             
  647.             _StubMsg.BufferLength = 2U + 2U;
  648.             NdrProxyGetBuffer(This, &_StubMsg);
  649.             *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++ = nX;
  650.             
  651.             *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++ = nY;
  652.             
  653.             NdrProxySendReceive(This, &_StubMsg);
  654.             
  655.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  656.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[32] );
  657.             
  658.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  659.             
  660.             }
  661.         RpcFinally
  662.             {
  663.             NdrProxyFreeBuffer(This, &_StubMsg);
  664.             
  665.             }
  666.         RpcEndFinally
  667.         
  668.         }
  669.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  670.         {
  671.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  672.         }
  673.     RpcEndExcept
  674.     return _RetVal;
  675. }
  676.  
  677. void __RPC_STUB ISharePaper_InkDraw_Stub(
  678.     IRpcStubBuffer *This,
  679.     IRpcChannelBuffer *_pRpcChannelBuffer,
  680.     PRPC_MESSAGE _pRpcMessage,
  681.     DWORD *_pdwStubPhase)
  682. {
  683.     HRESULT _RetVal;
  684.     MIDL_STUB_MESSAGE _StubMsg;
  685.     SHORT nX;
  686.     SHORT nY;
  687.     
  688. NdrStubInitialize(
  689.                      _pRpcMessage,
  690.                      &_StubMsg,
  691.                      &Object_StubDesc,
  692.                      _pRpcChannelBuffer);
  693.     RpcTryFinally
  694.         {
  695.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  696.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[32] );
  697.         
  698.         nX = *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++;
  699.         
  700.         nY = *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++;
  701.         
  702.         
  703.         *_pdwStubPhase = STUB_CALL_SERVER;
  704.         _RetVal = (((ISharePaper *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> InkDraw(
  705.            (ISharePaper *) ((CStdStubBuffer *)This)->pvServerObject,
  706.            nX,
  707.            nY);
  708.         
  709.         *_pdwStubPhase = STUB_MARSHAL;
  710.         
  711.         _StubMsg.BufferLength = 4U;
  712.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  713.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  714.         
  715.         }
  716.     RpcFinally
  717.         {
  718.         }
  719.     RpcEndFinally
  720.     _pRpcMessage->BufferLength = 
  721.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  722.     
  723. }
  724.  
  725.  
  726. HRESULT STDMETHODCALLTYPE ISharePaper_InkStop_Proxy( 
  727.     ISharePaper __RPC_FAR * This,
  728.     /* [in] */ SHORT nX,
  729.     /* [in] */ SHORT nY)
  730. {
  731.  
  732.     HRESULT _RetVal;
  733.     
  734.     RPC_MESSAGE _RpcMessage;
  735.     
  736.     MIDL_STUB_MESSAGE _StubMsg;
  737.     
  738.     RpcTryExcept
  739.         {
  740.         NdrProxyInitialize(
  741.                       ( void __RPC_FAR *  )This,
  742.                       ( PRPC_MESSAGE  )&_RpcMessage,
  743.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  744.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  745.                       9);
  746.         
  747.         
  748.         
  749.         RpcTryFinally
  750.             {
  751.             
  752.             _StubMsg.BufferLength = 2U + 2U;
  753.             NdrProxyGetBuffer(This, &_StubMsg);
  754.             *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++ = nX;
  755.             
  756.             *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++ = nY;
  757.             
  758.             NdrProxySendReceive(This, &_StubMsg);
  759.             
  760.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  761.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[32] );
  762.             
  763.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  764.             
  765.             }
  766.         RpcFinally
  767.             {
  768.             NdrProxyFreeBuffer(This, &_StubMsg);
  769.             
  770.             }
  771.         RpcEndFinally
  772.         
  773.         }
  774.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  775.         {
  776.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  777.         }
  778.     RpcEndExcept
  779.     return _RetVal;
  780. }
  781.  
  782. void __RPC_STUB ISharePaper_InkStop_Stub(
  783.     IRpcStubBuffer *This,
  784.     IRpcChannelBuffer *_pRpcChannelBuffer,
  785.     PRPC_MESSAGE _pRpcMessage,
  786.     DWORD *_pdwStubPhase)
  787. {
  788.     HRESULT _RetVal;
  789.     MIDL_STUB_MESSAGE _StubMsg;
  790.     SHORT nX;
  791.     SHORT nY;
  792.     
  793. NdrStubInitialize(
  794.                      _pRpcMessage,
  795.                      &_StubMsg,
  796.                      &Object_StubDesc,
  797.                      _pRpcChannelBuffer);
  798.     RpcTryFinally
  799.         {
  800.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  801.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[32] );
  802.         
  803.         nX = *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++;
  804.         
  805.         nY = *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++;
  806.         
  807.         
  808.         *_pdwStubPhase = STUB_CALL_SERVER;
  809.         _RetVal = (((ISharePaper *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> InkStop(
  810.            (ISharePaper *) ((CStdStubBuffer *)This)->pvServerObject,
  811.            nX,
  812.            nY);
  813.         
  814.         *_pdwStubPhase = STUB_MARSHAL;
  815.         
  816.         _StubMsg.BufferLength = 4U;
  817.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  818.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  819.         
  820.         }
  821.     RpcFinally
  822.         {
  823.         }
  824.     RpcEndFinally
  825.     _pRpcMessage->BufferLength = 
  826.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  827.     
  828. }
  829.  
  830.  
  831. HRESULT STDMETHODCALLTYPE ISharePaper_GetInk_Proxy( 
  832.     ISharePaper __RPC_FAR * This,
  833.     /* [in] */ LONG lIndex,
  834.     /* [out] */ SHORT __RPC_FAR *pnInkType,
  835.     /* [out] */ SHORT __RPC_FAR *pnX,
  836.     /* [out] */ SHORT __RPC_FAR *pnY,
  837.     /* [out] */ SHORT __RPC_FAR *pnInkWidth,
  838.     /* [out] */ COLORREF __RPC_FAR *pcrInkColor)
  839. {
  840.  
  841.     HRESULT _RetVal;
  842.     
  843.     RPC_MESSAGE _RpcMessage;
  844.     
  845.     MIDL_STUB_MESSAGE _StubMsg;
  846.     
  847.     RpcTryExcept
  848.         {
  849.         NdrProxyInitialize(
  850.                       ( void __RPC_FAR *  )This,
  851.                       ( PRPC_MESSAGE  )&_RpcMessage,
  852.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  853.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  854.                       10);
  855.         
  856.         
  857.         
  858.         RpcTryFinally
  859.             {
  860.             
  861.             _StubMsg.BufferLength = 4U;
  862.             NdrProxyGetBuffer(This, &_StubMsg);
  863.             *(( LONG __RPC_FAR * )_StubMsg.Buffer)++ = lIndex;
  864.             
  865.             NdrProxySendReceive(This, &_StubMsg);
  866.             
  867.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  868.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[38] );
  869.             
  870.             *pnInkType = *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++;
  871.             
  872.             *pnX = *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++;
  873.             
  874.             *pnY = *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++;
  875.             
  876.             *pnInkWidth = *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++;
  877.             
  878.             *pcrInkColor = *(( COLORREF __RPC_FAR * )_StubMsg.Buffer)++;
  879.             
  880.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  881.             
  882.             }
  883.         RpcFinally
  884.             {
  885.             NdrProxyFreeBuffer(This, &_StubMsg);
  886.             
  887.             }
  888.         RpcEndFinally
  889.         
  890.         }
  891.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  892.         {
  893.         NdrClearOutParameters(
  894.                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  895.                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[22],
  896.                          ( void __RPC_FAR * )pnInkType);
  897.         NdrClearOutParameters(
  898.                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  899.                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[22],
  900.                          ( void __RPC_FAR * )pnX);
  901.         NdrClearOutParameters(
  902.                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  903.                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[22],
  904.                          ( void __RPC_FAR * )pnY);
  905.         NdrClearOutParameters(
  906.                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  907.                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[22],
  908.                          ( void __RPC_FAR * )pnInkWidth);
  909.         NdrClearOutParameters(
  910.                          ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  911.                          ( PFORMAT_STRING  )&__MIDL_TypeFormatString.Format[14],
  912.                          ( void __RPC_FAR * )pcrInkColor);
  913.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  914.         }
  915.     RpcEndExcept
  916.     return _RetVal;
  917. }
  918.  
  919. void __RPC_STUB ISharePaper_GetInk_Stub(
  920.     IRpcStubBuffer *This,
  921.     IRpcChannelBuffer *_pRpcChannelBuffer,
  922.     PRPC_MESSAGE _pRpcMessage,
  923.     DWORD *_pdwStubPhase)
  924. {
  925.     SHORT _M1;
  926.     SHORT _M2;
  927.     SHORT _M3;
  928.     SHORT _M4;
  929.     COLORREF _M5;
  930.     HRESULT _RetVal;
  931.     MIDL_STUB_MESSAGE _StubMsg;
  932.     LONG lIndex;
  933.     COLORREF __RPC_FAR *pcrInkColor;
  934.     SHORT __RPC_FAR *pnInkType;
  935.     SHORT __RPC_FAR *pnInkWidth;
  936.     SHORT __RPC_FAR *pnX;
  937.     SHORT __RPC_FAR *pnY;
  938.     
  939. NdrStubInitialize(
  940.                      _pRpcMessage,
  941.                      &_StubMsg,
  942.                      &Object_StubDesc,
  943.                      _pRpcChannelBuffer);
  944.     ( SHORT __RPC_FAR * )pnInkType = 0;
  945.     ( SHORT __RPC_FAR * )pnX = 0;
  946.     ( SHORT __RPC_FAR * )pnY = 0;
  947.     ( SHORT __RPC_FAR * )pnInkWidth = 0;
  948.     ( COLORREF __RPC_FAR * )pcrInkColor = 0;
  949.     RpcTryFinally
  950.         {
  951.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  952.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[38] );
  953.         
  954.         lIndex = *(( LONG __RPC_FAR * )_StubMsg.Buffer)++;
  955.         
  956.         pnInkType = &_M1;
  957.         pnX = &_M2;
  958.         pnY = &_M3;
  959.         pnInkWidth = &_M4;
  960.         pcrInkColor = &_M5;
  961.         
  962.         *_pdwStubPhase = STUB_CALL_SERVER;
  963.         _RetVal = (((ISharePaper *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetInk(
  964.           (ISharePaper *) ((CStdStubBuffer *)This)->pvServerObject,
  965.           lIndex,
  966.           pnInkType,
  967.           pnX,
  968.           pnY,
  969.           pnInkWidth,
  970.           pcrInkColor);
  971.         
  972.         *_pdwStubPhase = STUB_MARSHAL;
  973.         
  974.         _StubMsg.BufferLength = 2U + 2U + 2U + 2U + 4U + 4U;
  975.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  976.         *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++ = *pnInkType;
  977.         
  978.         *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++ = *pnX;
  979.         
  980.         *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++ = *pnY;
  981.         
  982.         *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++ = *pnInkWidth;
  983.         
  984.         *(( COLORREF __RPC_FAR * )_StubMsg.Buffer)++ = *pcrInkColor;
  985.         
  986.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  987.         
  988.         }
  989.     RpcFinally
  990.         {
  991.         }
  992.     RpcEndFinally
  993.     _pRpcMessage->BufferLength = 
  994.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  995.     
  996. }
  997.  
  998.  
  999. HRESULT STDMETHODCALLTYPE ISharePaper_Erase_Proxy( 
  1000.     ISharePaper __RPC_FAR * This)
  1001. {
  1002.  
  1003.     HRESULT _RetVal;
  1004.     
  1005.     RPC_MESSAGE _RpcMessage;
  1006.     
  1007.     MIDL_STUB_MESSAGE _StubMsg;
  1008.     
  1009.     RpcTryExcept
  1010.         {
  1011.         NdrProxyInitialize(
  1012.                       ( void __RPC_FAR *  )This,
  1013.                       ( PRPC_MESSAGE  )&_RpcMessage,
  1014.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1015.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  1016.                       11);
  1017.         
  1018.         
  1019.         
  1020.         RpcTryFinally
  1021.             {
  1022.             
  1023.             _StubMsg.BufferLength = 0U;
  1024.             NdrProxyGetBuffer(This, &_StubMsg);
  1025.             NdrProxySendReceive(This, &_StubMsg);
  1026.             
  1027.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1028.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
  1029.             
  1030.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  1031.             
  1032.             }
  1033.         RpcFinally
  1034.             {
  1035.             NdrProxyFreeBuffer(This, &_StubMsg);
  1036.             
  1037.             }
  1038.         RpcEndFinally
  1039.         
  1040.         }
  1041.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  1042.         {
  1043.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  1044.         }
  1045.     RpcEndExcept
  1046.     return _RetVal;
  1047. }
  1048.  
  1049. void __RPC_STUB ISharePaper_Erase_Stub(
  1050.     IRpcStubBuffer *This,
  1051.     IRpcChannelBuffer *_pRpcChannelBuffer,
  1052.     PRPC_MESSAGE _pRpcMessage,
  1053.     DWORD *_pdwStubPhase)
  1054. {
  1055.     HRESULT _RetVal;
  1056.     MIDL_STUB_MESSAGE _StubMsg;
  1057.     
  1058. NdrStubInitialize(
  1059.                      _pRpcMessage,
  1060.                      &_StubMsg,
  1061.                      &Object_StubDesc,
  1062.                      _pRpcChannelBuffer);
  1063.     RpcTryFinally
  1064.         {
  1065.         
  1066.         *_pdwStubPhase = STUB_CALL_SERVER;
  1067.         _RetVal = (((ISharePaper *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Erase((ISharePaper *) ((CStdStubBuffer *)This)->pvServerObject);
  1068.         
  1069.         *_pdwStubPhase = STUB_MARSHAL;
  1070.         
  1071.         _StubMsg.BufferLength = 4U;
  1072.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  1073.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  1074.         
  1075.         }
  1076.     RpcFinally
  1077.         {
  1078.         }
  1079.     RpcEndFinally
  1080.     _pRpcMessage->BufferLength = 
  1081.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  1082.     
  1083. }
  1084.  
  1085.  
  1086. HRESULT STDMETHODCALLTYPE ISharePaper_Resize_Proxy( 
  1087.     ISharePaper __RPC_FAR * This,
  1088.     /* [in] */ LONG lWidth,
  1089.     /* [in] */ LONG lHeight)
  1090. {
  1091.  
  1092.     HRESULT _RetVal;
  1093.     
  1094.     RPC_MESSAGE _RpcMessage;
  1095.     
  1096.     MIDL_STUB_MESSAGE _StubMsg;
  1097.     
  1098.     RpcTryExcept
  1099.         {
  1100.         NdrProxyInitialize(
  1101.                       ( void __RPC_FAR *  )This,
  1102.                       ( PRPC_MESSAGE  )&_RpcMessage,
  1103.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1104.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  1105.                       12);
  1106.         
  1107.         
  1108.         
  1109.         RpcTryFinally
  1110.             {
  1111.             
  1112.             _StubMsg.BufferLength = 4U + 4U;
  1113.             NdrProxyGetBuffer(This, &_StubMsg);
  1114.             *(( LONG __RPC_FAR * )_StubMsg.Buffer)++ = lWidth;
  1115.             
  1116.             *(( LONG __RPC_FAR * )_StubMsg.Buffer)++ = lHeight;
  1117.             
  1118.             NdrProxySendReceive(This, &_StubMsg);
  1119.             
  1120.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1121.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[62] );
  1122.             
  1123.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  1124.             
  1125.             }
  1126.         RpcFinally
  1127.             {
  1128.             NdrProxyFreeBuffer(This, &_StubMsg);
  1129.             
  1130.             }
  1131.         RpcEndFinally
  1132.         
  1133.         }
  1134.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  1135.         {
  1136.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  1137.         }
  1138.     RpcEndExcept
  1139.     return _RetVal;
  1140. }
  1141.  
  1142. void __RPC_STUB ISharePaper_Resize_Stub(
  1143.     IRpcStubBuffer *This,
  1144.     IRpcChannelBuffer *_pRpcChannelBuffer,
  1145.     PRPC_MESSAGE _pRpcMessage,
  1146.     DWORD *_pdwStubPhase)
  1147. {
  1148.     HRESULT _RetVal;
  1149.     MIDL_STUB_MESSAGE _StubMsg;
  1150.     LONG lHeight;
  1151.     LONG lWidth;
  1152.     
  1153. NdrStubInitialize(
  1154.                      _pRpcMessage,
  1155.                      &_StubMsg,
  1156.                      &Object_StubDesc,
  1157.                      _pRpcChannelBuffer);
  1158.     RpcTryFinally
  1159.         {
  1160.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1161.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[62] );
  1162.         
  1163.         lWidth = *(( LONG __RPC_FAR * )_StubMsg.Buffer)++;
  1164.         
  1165.         lHeight = *(( LONG __RPC_FAR * )_StubMsg.Buffer)++;
  1166.         
  1167.         
  1168.         *_pdwStubPhase = STUB_CALL_SERVER;
  1169.         _RetVal = (((ISharePaper *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Resize(
  1170.           (ISharePaper *) ((CStdStubBuffer *)This)->pvServerObject,
  1171.           lWidth,
  1172.           lHeight);
  1173.         
  1174.         *_pdwStubPhase = STUB_MARSHAL;
  1175.         
  1176.         _StubMsg.BufferLength = 4U;
  1177.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  1178.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  1179.         
  1180.         }
  1181.     RpcFinally
  1182.         {
  1183.         }
  1184.     RpcEndFinally
  1185.     _pRpcMessage->BufferLength = 
  1186.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  1187.     
  1188. }
  1189.  
  1190. const CINTERFACE_PROXY_VTABLE(13) _ISharePaperProxyVtbl = 
  1191. {
  1192.     &IID_ISharePaper,
  1193.     IUnknown_QueryInterface_Proxy,
  1194.     IUnknown_AddRef_Proxy,
  1195.     IUnknown_Release_Proxy ,
  1196.     ISharePaper_InitPaper_Proxy ,
  1197.     ISharePaper_Lock_Proxy ,
  1198.     ISharePaper_Load_Proxy ,
  1199.     ISharePaper_Save_Proxy ,
  1200.     ISharePaper_InkStart_Proxy ,
  1201.     ISharePaper_InkDraw_Proxy ,
  1202.     ISharePaper_InkStop_Proxy ,
  1203.     ISharePaper_GetInk_Proxy ,
  1204.     ISharePaper_Erase_Proxy ,
  1205.     ISharePaper_Resize_Proxy
  1206. };
  1207.  
  1208.  
  1209. static const PRPC_STUB_FUNCTION ISharePaper_table[] =
  1210. {
  1211.     ISharePaper_InitPaper_Stub,
  1212.     ISharePaper_Lock_Stub,
  1213.     ISharePaper_Load_Stub,
  1214.     ISharePaper_Save_Stub,
  1215.     ISharePaper_InkStart_Stub,
  1216.     ISharePaper_InkDraw_Stub,
  1217.     ISharePaper_InkStop_Stub,
  1218.     ISharePaper_GetInk_Stub,
  1219.     ISharePaper_Erase_Stub,
  1220.     ISharePaper_Resize_Stub
  1221. };
  1222.  
  1223. const CInterfaceStubVtbl _ISharePaperStubVtbl =
  1224. {
  1225.     &IID_ISharePaper,
  1226.     0,
  1227.     13,
  1228.     &ISharePaper_table[-3],
  1229.     CStdStubBuffer_METHODS
  1230. };
  1231.  
  1232.  
  1233. /* Object interface: IPaperSink, ver. 0.0,
  1234.    GUID={0x0002da34,0x0000,0x0000,{0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46}} */
  1235.  
  1236.  
  1237. extern const MIDL_STUB_DESC Object_StubDesc;
  1238.  
  1239.  
  1240. #pragma code_seg(".orpc")
  1241.  
  1242. HRESULT STDMETHODCALLTYPE IPaperSink_Locked_Proxy( 
  1243.     IPaperSink __RPC_FAR * This)
  1244. {
  1245.  
  1246.     HRESULT _RetVal;
  1247.     
  1248.     RPC_MESSAGE _RpcMessage;
  1249.     
  1250.     MIDL_STUB_MESSAGE _StubMsg;
  1251.     
  1252.     RpcTryExcept
  1253.         {
  1254.         NdrProxyInitialize(
  1255.                       ( void __RPC_FAR *  )This,
  1256.                       ( PRPC_MESSAGE  )&_RpcMessage,
  1257.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1258.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  1259.                       3);
  1260.         
  1261.         
  1262.         
  1263.         RpcTryFinally
  1264.             {
  1265.             
  1266.             _StubMsg.BufferLength = 0U;
  1267.             NdrProxyGetBuffer(This, &_StubMsg);
  1268.             NdrProxySendReceive(This, &_StubMsg);
  1269.             
  1270.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1271.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
  1272.             
  1273.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  1274.             
  1275.             }
  1276.         RpcFinally
  1277.             {
  1278.             NdrProxyFreeBuffer(This, &_StubMsg);
  1279.             
  1280.             }
  1281.         RpcEndFinally
  1282.         
  1283.         }
  1284.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  1285.         {
  1286.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  1287.         }
  1288.     RpcEndExcept
  1289.     return _RetVal;
  1290. }
  1291.  
  1292. void __RPC_STUB IPaperSink_Locked_Stub(
  1293.     IRpcStubBuffer *This,
  1294.     IRpcChannelBuffer *_pRpcChannelBuffer,
  1295.     PRPC_MESSAGE _pRpcMessage,
  1296.     DWORD *_pdwStubPhase)
  1297. {
  1298.     HRESULT _RetVal;
  1299.     MIDL_STUB_MESSAGE _StubMsg;
  1300.     
  1301. NdrStubInitialize(
  1302.                      _pRpcMessage,
  1303.                      &_StubMsg,
  1304.                      &Object_StubDesc,
  1305.                      _pRpcChannelBuffer);
  1306.     RpcTryFinally
  1307.         {
  1308.         
  1309.         *_pdwStubPhase = STUB_CALL_SERVER;
  1310.         _RetVal = (((IPaperSink *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Locked((IPaperSink *) ((CStdStubBuffer *)This)->pvServerObject);
  1311.         
  1312.         *_pdwStubPhase = STUB_MARSHAL;
  1313.         
  1314.         _StubMsg.BufferLength = 4U;
  1315.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  1316.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  1317.         
  1318.         }
  1319.     RpcFinally
  1320.         {
  1321.         }
  1322.     RpcEndFinally
  1323.     _pRpcMessage->BufferLength = 
  1324.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  1325.     
  1326. }
  1327.  
  1328.  
  1329. HRESULT STDMETHODCALLTYPE IPaperSink_Unlocked_Proxy( 
  1330.     IPaperSink __RPC_FAR * This)
  1331. {
  1332.  
  1333.     HRESULT _RetVal;
  1334.     
  1335.     RPC_MESSAGE _RpcMessage;
  1336.     
  1337.     MIDL_STUB_MESSAGE _StubMsg;
  1338.     
  1339.     RpcTryExcept
  1340.         {
  1341.         NdrProxyInitialize(
  1342.                       ( void __RPC_FAR *  )This,
  1343.                       ( PRPC_MESSAGE  )&_RpcMessage,
  1344.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1345.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  1346.                       4);
  1347.         
  1348.         
  1349.         
  1350.         RpcTryFinally
  1351.             {
  1352.             
  1353.             _StubMsg.BufferLength = 0U;
  1354.             NdrProxyGetBuffer(This, &_StubMsg);
  1355.             NdrProxySendReceive(This, &_StubMsg);
  1356.             
  1357.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1358.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
  1359.             
  1360.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  1361.             
  1362.             }
  1363.         RpcFinally
  1364.             {
  1365.             NdrProxyFreeBuffer(This, &_StubMsg);
  1366.             
  1367.             }
  1368.         RpcEndFinally
  1369.         
  1370.         }
  1371.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  1372.         {
  1373.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  1374.         }
  1375.     RpcEndExcept
  1376.     return _RetVal;
  1377. }
  1378.  
  1379. void __RPC_STUB IPaperSink_Unlocked_Stub(
  1380.     IRpcStubBuffer *This,
  1381.     IRpcChannelBuffer *_pRpcChannelBuffer,
  1382.     PRPC_MESSAGE _pRpcMessage,
  1383.     DWORD *_pdwStubPhase)
  1384. {
  1385.     HRESULT _RetVal;
  1386.     MIDL_STUB_MESSAGE _StubMsg;
  1387.     
  1388. NdrStubInitialize(
  1389.                      _pRpcMessage,
  1390.                      &_StubMsg,
  1391.                      &Object_StubDesc,
  1392.                      _pRpcChannelBuffer);
  1393.     RpcTryFinally
  1394.         {
  1395.         
  1396.         *_pdwStubPhase = STUB_CALL_SERVER;
  1397.         _RetVal = (((IPaperSink *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Unlocked((IPaperSink *) ((CStdStubBuffer *)This)->pvServerObject);
  1398.         
  1399.         *_pdwStubPhase = STUB_MARSHAL;
  1400.         
  1401.         _StubMsg.BufferLength = 4U;
  1402.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  1403.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  1404.         
  1405.         }
  1406.     RpcFinally
  1407.         {
  1408.         }
  1409.     RpcEndFinally
  1410.     _pRpcMessage->BufferLength = 
  1411.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  1412.     
  1413. }
  1414.  
  1415.  
  1416. HRESULT STDMETHODCALLTYPE IPaperSink_Loaded_Proxy( 
  1417.     IPaperSink __RPC_FAR * This)
  1418. {
  1419.  
  1420.     HRESULT _RetVal;
  1421.     
  1422.     RPC_MESSAGE _RpcMessage;
  1423.     
  1424.     MIDL_STUB_MESSAGE _StubMsg;
  1425.     
  1426.     RpcTryExcept
  1427.         {
  1428.         NdrProxyInitialize(
  1429.                       ( void __RPC_FAR *  )This,
  1430.                       ( PRPC_MESSAGE  )&_RpcMessage,
  1431.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1432.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  1433.                       5);
  1434.         
  1435.         
  1436.         
  1437.         RpcTryFinally
  1438.             {
  1439.             
  1440.             _StubMsg.BufferLength = 0U;
  1441.             NdrProxyGetBuffer(This, &_StubMsg);
  1442.             NdrProxySendReceive(This, &_StubMsg);
  1443.             
  1444.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1445.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
  1446.             
  1447.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  1448.             
  1449.             }
  1450.         RpcFinally
  1451.             {
  1452.             NdrProxyFreeBuffer(This, &_StubMsg);
  1453.             
  1454.             }
  1455.         RpcEndFinally
  1456.         
  1457.         }
  1458.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  1459.         {
  1460.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  1461.         }
  1462.     RpcEndExcept
  1463.     return _RetVal;
  1464. }
  1465.  
  1466. void __RPC_STUB IPaperSink_Loaded_Stub(
  1467.     IRpcStubBuffer *This,
  1468.     IRpcChannelBuffer *_pRpcChannelBuffer,
  1469.     PRPC_MESSAGE _pRpcMessage,
  1470.     DWORD *_pdwStubPhase)
  1471. {
  1472.     HRESULT _RetVal;
  1473.     MIDL_STUB_MESSAGE _StubMsg;
  1474.     
  1475. NdrStubInitialize(
  1476.                      _pRpcMessage,
  1477.                      &_StubMsg,
  1478.                      &Object_StubDesc,
  1479.                      _pRpcChannelBuffer);
  1480.     RpcTryFinally
  1481.         {
  1482.         
  1483.         *_pdwStubPhase = STUB_CALL_SERVER;
  1484.         _RetVal = (((IPaperSink *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Loaded((IPaperSink *) ((CStdStubBuffer *)This)->pvServerObject);
  1485.         
  1486.         *_pdwStubPhase = STUB_MARSHAL;
  1487.         
  1488.         _StubMsg.BufferLength = 4U;
  1489.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  1490.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  1491.         
  1492.         }
  1493.     RpcFinally
  1494.         {
  1495.         }
  1496.     RpcEndFinally
  1497.     _pRpcMessage->BufferLength = 
  1498.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  1499.     
  1500. }
  1501.  
  1502.  
  1503. HRESULT STDMETHODCALLTYPE IPaperSink_Saved_Proxy( 
  1504.     IPaperSink __RPC_FAR * This)
  1505. {
  1506.  
  1507.     HRESULT _RetVal;
  1508.     
  1509.     RPC_MESSAGE _RpcMessage;
  1510.     
  1511.     MIDL_STUB_MESSAGE _StubMsg;
  1512.     
  1513.     RpcTryExcept
  1514.         {
  1515.         NdrProxyInitialize(
  1516.                       ( void __RPC_FAR *  )This,
  1517.                       ( PRPC_MESSAGE  )&_RpcMessage,
  1518.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1519.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  1520.                       6);
  1521.         
  1522.         
  1523.         
  1524.         RpcTryFinally
  1525.             {
  1526.             
  1527.             _StubMsg.BufferLength = 0U;
  1528.             NdrProxyGetBuffer(This, &_StubMsg);
  1529.             NdrProxySendReceive(This, &_StubMsg);
  1530.             
  1531.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1532.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
  1533.             
  1534.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  1535.             
  1536.             }
  1537.         RpcFinally
  1538.             {
  1539.             NdrProxyFreeBuffer(This, &_StubMsg);
  1540.             
  1541.             }
  1542.         RpcEndFinally
  1543.         
  1544.         }
  1545.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  1546.         {
  1547.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  1548.         }
  1549.     RpcEndExcept
  1550.     return _RetVal;
  1551. }
  1552.  
  1553. void __RPC_STUB IPaperSink_Saved_Stub(
  1554.     IRpcStubBuffer *This,
  1555.     IRpcChannelBuffer *_pRpcChannelBuffer,
  1556.     PRPC_MESSAGE _pRpcMessage,
  1557.     DWORD *_pdwStubPhase)
  1558. {
  1559.     HRESULT _RetVal;
  1560.     MIDL_STUB_MESSAGE _StubMsg;
  1561.     
  1562. NdrStubInitialize(
  1563.                      _pRpcMessage,
  1564.                      &_StubMsg,
  1565.                      &Object_StubDesc,
  1566.                      _pRpcChannelBuffer);
  1567.     RpcTryFinally
  1568.         {
  1569.         
  1570.         *_pdwStubPhase = STUB_CALL_SERVER;
  1571.         _RetVal = (((IPaperSink *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Saved((IPaperSink *) ((CStdStubBuffer *)This)->pvServerObject);
  1572.         
  1573.         *_pdwStubPhase = STUB_MARSHAL;
  1574.         
  1575.         _StubMsg.BufferLength = 4U;
  1576.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  1577.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  1578.         
  1579.         }
  1580.     RpcFinally
  1581.         {
  1582.         }
  1583.     RpcEndFinally
  1584.     _pRpcMessage->BufferLength = 
  1585.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  1586.     
  1587. }
  1588.  
  1589.  
  1590. HRESULT STDMETHODCALLTYPE IPaperSink_InkStart_Proxy( 
  1591.     IPaperSink __RPC_FAR * This,
  1592.     /* [in] */ SHORT nX,
  1593.     /* [in] */ SHORT nY,
  1594.     /* [in] */ SHORT nInkWidth,
  1595.     /* [in] */ COLORREF crInkColor)
  1596. {
  1597.  
  1598.     HRESULT _RetVal;
  1599.     
  1600.     RPC_MESSAGE _RpcMessage;
  1601.     
  1602.     MIDL_STUB_MESSAGE _StubMsg;
  1603.     
  1604.     RpcTryExcept
  1605.         {
  1606.         NdrProxyInitialize(
  1607.                       ( void __RPC_FAR *  )This,
  1608.                       ( PRPC_MESSAGE  )&_RpcMessage,
  1609.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1610.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  1611.                       7);
  1612.         
  1613.         
  1614.         
  1615.         RpcTryFinally
  1616.             {
  1617.             
  1618.             _StubMsg.BufferLength = 2U + 2U + 2U + 6U;
  1619.             NdrProxyGetBuffer(This, &_StubMsg);
  1620.             *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++ = nX;
  1621.             
  1622.             *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++ = nY;
  1623.             
  1624.             *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++ = nInkWidth;
  1625.             
  1626.             _StubMsg.Buffer += 2;
  1627.             *(( COLORREF __RPC_FAR * )_StubMsg.Buffer)++ = crInkColor;
  1628.             
  1629.             NdrProxySendReceive(This, &_StubMsg);
  1630.             
  1631.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1632.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[22] );
  1633.             
  1634.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  1635.             
  1636.             }
  1637.         RpcFinally
  1638.             {
  1639.             NdrProxyFreeBuffer(This, &_StubMsg);
  1640.             
  1641.             }
  1642.         RpcEndFinally
  1643.         
  1644.         }
  1645.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  1646.         {
  1647.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  1648.         }
  1649.     RpcEndExcept
  1650.     return _RetVal;
  1651. }
  1652.  
  1653. void __RPC_STUB IPaperSink_InkStart_Stub(
  1654.     IRpcStubBuffer *This,
  1655.     IRpcChannelBuffer *_pRpcChannelBuffer,
  1656.     PRPC_MESSAGE _pRpcMessage,
  1657.     DWORD *_pdwStubPhase)
  1658. {
  1659.     HRESULT _RetVal;
  1660.     MIDL_STUB_MESSAGE _StubMsg;
  1661.     COLORREF crInkColor;
  1662.     SHORT nInkWidth;
  1663.     SHORT nX;
  1664.     SHORT nY;
  1665.     
  1666. NdrStubInitialize(
  1667.                      _pRpcMessage,
  1668.                      &_StubMsg,
  1669.                      &Object_StubDesc,
  1670.                      _pRpcChannelBuffer);
  1671.     RpcTryFinally
  1672.         {
  1673.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1674.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[22] );
  1675.         
  1676.         nX = *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++;
  1677.         
  1678.         nY = *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++;
  1679.         
  1680.         nInkWidth = *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++;
  1681.         
  1682.         _StubMsg.Buffer += 2;
  1683.         crInkColor = *(( COLORREF __RPC_FAR * )_StubMsg.Buffer)++;
  1684.         
  1685.         
  1686.         *_pdwStubPhase = STUB_CALL_SERVER;
  1687.         _RetVal = (((IPaperSink *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> InkStart(
  1688.             (IPaperSink *) ((CStdStubBuffer *)This)->pvServerObject,
  1689.             nX,
  1690.             nY,
  1691.             nInkWidth,
  1692.             crInkColor);
  1693.         
  1694.         *_pdwStubPhase = STUB_MARSHAL;
  1695.         
  1696.         _StubMsg.BufferLength = 4U;
  1697.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  1698.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  1699.         
  1700.         }
  1701.     RpcFinally
  1702.         {
  1703.         }
  1704.     RpcEndFinally
  1705.     _pRpcMessage->BufferLength = 
  1706.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  1707.     
  1708. }
  1709.  
  1710.  
  1711. HRESULT STDMETHODCALLTYPE IPaperSink_InkDraw_Proxy( 
  1712.     IPaperSink __RPC_FAR * This,
  1713.     /* [in] */ SHORT nX,
  1714.     /* [in] */ SHORT nY)
  1715. {
  1716.  
  1717.     HRESULT _RetVal;
  1718.     
  1719.     RPC_MESSAGE _RpcMessage;
  1720.     
  1721.     MIDL_STUB_MESSAGE _StubMsg;
  1722.     
  1723.     RpcTryExcept
  1724.         {
  1725.         NdrProxyInitialize(
  1726.                       ( void __RPC_FAR *  )This,
  1727.                       ( PRPC_MESSAGE  )&_RpcMessage,
  1728.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1729.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  1730.                       8);
  1731.         
  1732.         
  1733.         
  1734.         RpcTryFinally
  1735.             {
  1736.             
  1737.             _StubMsg.BufferLength = 2U + 2U;
  1738.             NdrProxyGetBuffer(This, &_StubMsg);
  1739.             *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++ = nX;
  1740.             
  1741.             *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++ = nY;
  1742.             
  1743.             NdrProxySendReceive(This, &_StubMsg);
  1744.             
  1745.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1746.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[32] );
  1747.             
  1748.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  1749.             
  1750.             }
  1751.         RpcFinally
  1752.             {
  1753.             NdrProxyFreeBuffer(This, &_StubMsg);
  1754.             
  1755.             }
  1756.         RpcEndFinally
  1757.         
  1758.         }
  1759.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  1760.         {
  1761.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  1762.         }
  1763.     RpcEndExcept
  1764.     return _RetVal;
  1765. }
  1766.  
  1767. void __RPC_STUB IPaperSink_InkDraw_Stub(
  1768.     IRpcStubBuffer *This,
  1769.     IRpcChannelBuffer *_pRpcChannelBuffer,
  1770.     PRPC_MESSAGE _pRpcMessage,
  1771.     DWORD *_pdwStubPhase)
  1772. {
  1773.     HRESULT _RetVal;
  1774.     MIDL_STUB_MESSAGE _StubMsg;
  1775.     SHORT nX;
  1776.     SHORT nY;
  1777.     
  1778. NdrStubInitialize(
  1779.                      _pRpcMessage,
  1780.                      &_StubMsg,
  1781.                      &Object_StubDesc,
  1782.                      _pRpcChannelBuffer);
  1783.     RpcTryFinally
  1784.         {
  1785.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1786.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[32] );
  1787.         
  1788.         nX = *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++;
  1789.         
  1790.         nY = *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++;
  1791.         
  1792.         
  1793.         *_pdwStubPhase = STUB_CALL_SERVER;
  1794.         _RetVal = (((IPaperSink *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> InkDraw(
  1795.            (IPaperSink *) ((CStdStubBuffer *)This)->pvServerObject,
  1796.            nX,
  1797.            nY);
  1798.         
  1799.         *_pdwStubPhase = STUB_MARSHAL;
  1800.         
  1801.         _StubMsg.BufferLength = 4U;
  1802.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  1803.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  1804.         
  1805.         }
  1806.     RpcFinally
  1807.         {
  1808.         }
  1809.     RpcEndFinally
  1810.     _pRpcMessage->BufferLength = 
  1811.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  1812.     
  1813. }
  1814.  
  1815.  
  1816. HRESULT STDMETHODCALLTYPE IPaperSink_InkStop_Proxy( 
  1817.     IPaperSink __RPC_FAR * This,
  1818.     /* [in] */ SHORT nX,
  1819.     /* [in] */ SHORT nY)
  1820. {
  1821.  
  1822.     HRESULT _RetVal;
  1823.     
  1824.     RPC_MESSAGE _RpcMessage;
  1825.     
  1826.     MIDL_STUB_MESSAGE _StubMsg;
  1827.     
  1828.     RpcTryExcept
  1829.         {
  1830.         NdrProxyInitialize(
  1831.                       ( void __RPC_FAR *  )This,
  1832.                       ( PRPC_MESSAGE  )&_RpcMessage,
  1833.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1834.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  1835.                       9);
  1836.         
  1837.         
  1838.         
  1839.         RpcTryFinally
  1840.             {
  1841.             
  1842.             _StubMsg.BufferLength = 2U + 2U;
  1843.             NdrProxyGetBuffer(This, &_StubMsg);
  1844.             *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++ = nX;
  1845.             
  1846.             *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++ = nY;
  1847.             
  1848.             NdrProxySendReceive(This, &_StubMsg);
  1849.             
  1850.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1851.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[32] );
  1852.             
  1853.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  1854.             
  1855.             }
  1856.         RpcFinally
  1857.             {
  1858.             NdrProxyFreeBuffer(This, &_StubMsg);
  1859.             
  1860.             }
  1861.         RpcEndFinally
  1862.         
  1863.         }
  1864.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  1865.         {
  1866.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  1867.         }
  1868.     RpcEndExcept
  1869.     return _RetVal;
  1870. }
  1871.  
  1872. void __RPC_STUB IPaperSink_InkStop_Stub(
  1873.     IRpcStubBuffer *This,
  1874.     IRpcChannelBuffer *_pRpcChannelBuffer,
  1875.     PRPC_MESSAGE _pRpcMessage,
  1876.     DWORD *_pdwStubPhase)
  1877. {
  1878.     HRESULT _RetVal;
  1879.     MIDL_STUB_MESSAGE _StubMsg;
  1880.     SHORT nX;
  1881.     SHORT nY;
  1882.     
  1883. NdrStubInitialize(
  1884.                      _pRpcMessage,
  1885.                      &_StubMsg,
  1886.                      &Object_StubDesc,
  1887.                      _pRpcChannelBuffer);
  1888.     RpcTryFinally
  1889.         {
  1890.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1891.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[32] );
  1892.         
  1893.         nX = *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++;
  1894.         
  1895.         nY = *(( SHORT __RPC_FAR * )_StubMsg.Buffer)++;
  1896.         
  1897.         
  1898.         *_pdwStubPhase = STUB_CALL_SERVER;
  1899.         _RetVal = (((IPaperSink *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> InkStop(
  1900.            (IPaperSink *) ((CStdStubBuffer *)This)->pvServerObject,
  1901.            nX,
  1902.            nY);
  1903.         
  1904.         *_pdwStubPhase = STUB_MARSHAL;
  1905.         
  1906.         _StubMsg.BufferLength = 4U;
  1907.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  1908.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  1909.         
  1910.         }
  1911.     RpcFinally
  1912.         {
  1913.         }
  1914.     RpcEndFinally
  1915.     _pRpcMessage->BufferLength = 
  1916.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  1917.     
  1918. }
  1919.  
  1920.  
  1921. HRESULT STDMETHODCALLTYPE IPaperSink_Erased_Proxy( 
  1922.     IPaperSink __RPC_FAR * This)
  1923. {
  1924.  
  1925.     HRESULT _RetVal;
  1926.     
  1927.     RPC_MESSAGE _RpcMessage;
  1928.     
  1929.     MIDL_STUB_MESSAGE _StubMsg;
  1930.     
  1931.     RpcTryExcept
  1932.         {
  1933.         NdrProxyInitialize(
  1934.                       ( void __RPC_FAR *  )This,
  1935.                       ( PRPC_MESSAGE  )&_RpcMessage,
  1936.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  1937.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  1938.                       10);
  1939.         
  1940.         
  1941.         
  1942.         RpcTryFinally
  1943.             {
  1944.             
  1945.             _StubMsg.BufferLength = 0U;
  1946.             NdrProxyGetBuffer(This, &_StubMsg);
  1947.             NdrProxySendReceive(This, &_StubMsg);
  1948.             
  1949.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  1950.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
  1951.             
  1952.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  1953.             
  1954.             }
  1955.         RpcFinally
  1956.             {
  1957.             NdrProxyFreeBuffer(This, &_StubMsg);
  1958.             
  1959.             }
  1960.         RpcEndFinally
  1961.         
  1962.         }
  1963.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  1964.         {
  1965.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  1966.         }
  1967.     RpcEndExcept
  1968.     return _RetVal;
  1969. }
  1970.  
  1971. void __RPC_STUB IPaperSink_Erased_Stub(
  1972.     IRpcStubBuffer *This,
  1973.     IRpcChannelBuffer *_pRpcChannelBuffer,
  1974.     PRPC_MESSAGE _pRpcMessage,
  1975.     DWORD *_pdwStubPhase)
  1976. {
  1977.     HRESULT _RetVal;
  1978.     MIDL_STUB_MESSAGE _StubMsg;
  1979.     
  1980. NdrStubInitialize(
  1981.                      _pRpcMessage,
  1982.                      &_StubMsg,
  1983.                      &Object_StubDesc,
  1984.                      _pRpcChannelBuffer);
  1985.     RpcTryFinally
  1986.         {
  1987.         
  1988.         *_pdwStubPhase = STUB_CALL_SERVER;
  1989.         _RetVal = (((IPaperSink *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Erased((IPaperSink *) ((CStdStubBuffer *)This)->pvServerObject);
  1990.         
  1991.         *_pdwStubPhase = STUB_MARSHAL;
  1992.         
  1993.         _StubMsg.BufferLength = 4U;
  1994.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  1995.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  1996.         
  1997.         }
  1998.     RpcFinally
  1999.         {
  2000.         }
  2001.     RpcEndFinally
  2002.     _pRpcMessage->BufferLength = 
  2003.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  2004.     
  2005. }
  2006.  
  2007.  
  2008. HRESULT STDMETHODCALLTYPE IPaperSink_Resized_Proxy( 
  2009.     IPaperSink __RPC_FAR * This,
  2010.     /* [in] */ LONG lWidth,
  2011.     /* [in] */ LONG lHeight)
  2012. {
  2013.  
  2014.     HRESULT _RetVal;
  2015.     
  2016.     RPC_MESSAGE _RpcMessage;
  2017.     
  2018.     MIDL_STUB_MESSAGE _StubMsg;
  2019.     
  2020.     RpcTryExcept
  2021.         {
  2022.         NdrProxyInitialize(
  2023.                       ( void __RPC_FAR *  )This,
  2024.                       ( PRPC_MESSAGE  )&_RpcMessage,
  2025.                       ( PMIDL_STUB_MESSAGE  )&_StubMsg,
  2026.                       ( PMIDL_STUB_DESC  )&Object_StubDesc,
  2027.                       11);
  2028.         
  2029.         
  2030.         
  2031.         RpcTryFinally
  2032.             {
  2033.             
  2034.             _StubMsg.BufferLength = 4U + 4U;
  2035.             NdrProxyGetBuffer(This, &_StubMsg);
  2036.             *(( LONG __RPC_FAR * )_StubMsg.Buffer)++ = lWidth;
  2037.             
  2038.             *(( LONG __RPC_FAR * )_StubMsg.Buffer)++ = lHeight;
  2039.             
  2040.             NdrProxySendReceive(This, &_StubMsg);
  2041.             
  2042.             if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  2043.                 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[62] );
  2044.             
  2045.             _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
  2046.             
  2047.             }
  2048.         RpcFinally
  2049.             {
  2050.             NdrProxyFreeBuffer(This, &_StubMsg);
  2051.             
  2052.             }
  2053.         RpcEndFinally
  2054.         
  2055.         }
  2056.     RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
  2057.         {
  2058.         _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
  2059.         }
  2060.     RpcEndExcept
  2061.     return _RetVal;
  2062. }
  2063.  
  2064. void __RPC_STUB IPaperSink_Resized_Stub(
  2065.     IRpcStubBuffer *This,
  2066.     IRpcChannelBuffer *_pRpcChannelBuffer,
  2067.     PRPC_MESSAGE _pRpcMessage,
  2068.     DWORD *_pdwStubPhase)
  2069. {
  2070.     HRESULT _RetVal;
  2071.     MIDL_STUB_MESSAGE _StubMsg;
  2072.     LONG lHeight;
  2073.     LONG lWidth;
  2074.     
  2075. NdrStubInitialize(
  2076.                      _pRpcMessage,
  2077.                      &_StubMsg,
  2078.                      &Object_StubDesc,
  2079.                      _pRpcChannelBuffer);
  2080.     RpcTryFinally
  2081.         {
  2082.         if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
  2083.             NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[62] );
  2084.         
  2085.         lWidth = *(( LONG __RPC_FAR * )_StubMsg.Buffer)++;
  2086.         
  2087.         lHeight = *(( LONG __RPC_FAR * )_StubMsg.Buffer)++;
  2088.         
  2089.         
  2090.         *_pdwStubPhase = STUB_CALL_SERVER;
  2091.         _RetVal = (((IPaperSink *) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Resized(
  2092.            (IPaperSink *) ((CStdStubBuffer *)This)->pvServerObject,
  2093.            lWidth,
  2094.            lHeight);
  2095.         
  2096.         *_pdwStubPhase = STUB_MARSHAL;
  2097.         
  2098.         _StubMsg.BufferLength = 4U;
  2099.         NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
  2100.         *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
  2101.         
  2102.         }
  2103.     RpcFinally
  2104.         {
  2105.         }
  2106.     RpcEndFinally
  2107.     _pRpcMessage->BufferLength = 
  2108.         (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
  2109.     
  2110. }
  2111.  
  2112.  
  2113. static const MIDL_STUB_DESC Object_StubDesc = 
  2114.     {
  2115.     0,
  2116.     NdrOleAllocate,
  2117.     NdrOleFree,
  2118.     0,
  2119.     0,
  2120.     0,
  2121.     0,
  2122.     0,
  2123.     __MIDL_TypeFormatString.Format,
  2124.     0, /* -error bounds_check flag */
  2125.     0x10001, /* Ndr library version */
  2126.     0,
  2127.     0x303006e, /* MIDL Version 3.3.110 */
  2128.     0,
  2129.     0,
  2130.     0,  /* Reserved1 */
  2131.     0,  /* Reserved2 */
  2132.     0,  /* Reserved3 */
  2133.     0,  /* Reserved4 */
  2134.     0   /* Reserved5 */
  2135.     };
  2136.  
  2137. const CINTERFACE_PROXY_VTABLE(12) _IPaperSinkProxyVtbl = 
  2138. {
  2139.     &IID_IPaperSink,
  2140.     IUnknown_QueryInterface_Proxy,
  2141.     IUnknown_AddRef_Proxy,
  2142.     IUnknown_Release_Proxy ,
  2143.     IPaperSink_Locked_Proxy ,
  2144.     IPaperSink_Unlocked_Proxy ,
  2145.     IPaperSink_Loaded_Proxy ,
  2146.     IPaperSink_Saved_Proxy ,
  2147.     IPaperSink_InkStart_Proxy ,
  2148.     IPaperSink_InkDraw_Proxy ,
  2149.     IPaperSink_InkStop_Proxy ,
  2150.     IPaperSink_Erased_Proxy ,
  2151.     IPaperSink_Resized_Proxy
  2152. };
  2153.  
  2154.  
  2155. static const PRPC_STUB_FUNCTION IPaperSink_table[] =
  2156. {
  2157.     IPaperSink_Locked_Stub,
  2158.     IPaperSink_Unlocked_Stub,
  2159.     IPaperSink_Loaded_Stub,
  2160.     IPaperSink_Saved_Stub,
  2161.     IPaperSink_InkStart_Stub,
  2162.     IPaperSink_InkDraw_Stub,
  2163.     IPaperSink_InkStop_Stub,
  2164.     IPaperSink_Erased_Stub,
  2165.     IPaperSink_Resized_Stub
  2166. };
  2167.  
  2168. const CInterfaceStubVtbl _IPaperSinkStubVtbl =
  2169. {
  2170.     &IID_IPaperSink,
  2171.     0,
  2172.     12,
  2173.     &IPaperSink_table[-3],
  2174.     CStdStubBuffer_METHODS
  2175. };
  2176.  
  2177.  
  2178. /* Standard interface: __MIDL_itf_papint_0008, ver. 0.0,
  2179.    GUID={0x00000000,0x0000,0x0000,{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}} */
  2180.  
  2181. #pragma data_seg(".rdata")
  2182.  
  2183. #if !defined(__RPC_WIN32__)
  2184. #error  Invalid build platform for this stub.
  2185. #endif
  2186.  
  2187. static const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString =
  2188.     {
  2189.         0,
  2190.         {
  2191.             
  2192.             0x50,        /* FC_IN_OUT_PARAM */
  2193. #ifndef _ALPHA_
  2194.             0x1,        /* x86, MIPS & PPC Stack size = 1 */
  2195. #else
  2196.             0x2,        /* Alpha Stack size = 2 */
  2197. #endif
  2198. /*  2 */    NdrFcShort( 0x0 ),    /* Type Offset=0 */
  2199. /*  4 */    
  2200.             0x51,        /* FC_OUT_PARAM */
  2201. #ifndef _ALPHA_
  2202.             0x1,        /* x86, MIPS & PPC Stack size = 1 */
  2203. #else
  2204.             0x2,        /* Alpha Stack size = 2 */
  2205. #endif
  2206. /*  6 */    NdrFcShort( 0xe ),    /* Type Offset=14 */
  2207. /*  8 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  2208.             0x8,        /* FC_LONG */
  2209. /* 10 */    0x4e,        /* FC_IN_PARAM_BASETYPE */
  2210.             0x8,        /* FC_LONG */
  2211. /* 12 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  2212.             0x8,        /* FC_LONG */
  2213. /* 14 */    
  2214.             0x51,        /* FC_OUT_PARAM */
  2215. #ifndef _ALPHA_
  2216.             0x1,        /* x86, MIPS & PPC Stack size = 1 */
  2217. #else
  2218.             0x2,        /* Alpha Stack size = 2 */
  2219. #endif
  2220. /* 16 */    NdrFcShort( 0x12 ),    /* Type Offset=18 */
  2221. /* 18 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  2222.             0x8,        /* FC_LONG */
  2223. /* 20 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  2224.             0x8,        /* FC_LONG */
  2225. /* 22 */    0x4e,        /* FC_IN_PARAM_BASETYPE */
  2226.             0x6,        /* FC_SHORT */
  2227. /* 24 */    0x4e,        /* FC_IN_PARAM_BASETYPE */
  2228.             0x6,        /* FC_SHORT */
  2229. /* 26 */    0x4e,        /* FC_IN_PARAM_BASETYPE */
  2230.             0x6,        /* FC_SHORT */
  2231. /* 28 */    0x4e,        /* FC_IN_PARAM_BASETYPE */
  2232.             0x8,        /* FC_LONG */
  2233. /* 30 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  2234.             0x8,        /* FC_LONG */
  2235. /* 32 */    0x4e,        /* FC_IN_PARAM_BASETYPE */
  2236.             0x6,        /* FC_SHORT */
  2237. /* 34 */    0x4e,        /* FC_IN_PARAM_BASETYPE */
  2238.             0x6,        /* FC_SHORT */
  2239. /* 36 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  2240.             0x8,        /* FC_LONG */
  2241. /* 38 */    0x4e,        /* FC_IN_PARAM_BASETYPE */
  2242.             0x8,        /* FC_LONG */
  2243. /* 40 */    
  2244.             0x51,        /* FC_OUT_PARAM */
  2245. #ifndef _ALPHA_
  2246.             0x1,        /* x86, MIPS & PPC Stack size = 1 */
  2247. #else
  2248.             0x2,        /* Alpha Stack size = 2 */
  2249. #endif
  2250. /* 42 */    NdrFcShort( 0x16 ),    /* Type Offset=22 */
  2251. /* 44 */    
  2252.             0x51,        /* FC_OUT_PARAM */
  2253. #ifndef _ALPHA_
  2254.             0x1,        /* x86, MIPS & PPC Stack size = 1 */
  2255. #else
  2256.             0x2,        /* Alpha Stack size = 2 */
  2257. #endif
  2258. /* 46 */    NdrFcShort( 0x16 ),    /* Type Offset=22 */
  2259. /* 48 */    
  2260.             0x51,        /* FC_OUT_PARAM */
  2261. #ifndef _ALPHA_
  2262.             0x1,        /* x86, MIPS & PPC Stack size = 1 */
  2263. #else
  2264.             0x2,        /* Alpha Stack size = 2 */
  2265. #endif
  2266. /* 50 */    NdrFcShort( 0x16 ),    /* Type Offset=22 */
  2267. /* 52 */    
  2268.             0x51,        /* FC_OUT_PARAM */
  2269. #ifndef _ALPHA_
  2270.             0x1,        /* x86, MIPS & PPC Stack size = 1 */
  2271. #else
  2272.             0x2,        /* Alpha Stack size = 2 */
  2273. #endif
  2274. /* 54 */    NdrFcShort( 0x16 ),    /* Type Offset=22 */
  2275. /* 56 */    
  2276.             0x51,        /* FC_OUT_PARAM */
  2277. #ifndef _ALPHA_
  2278.             0x1,        /* x86, MIPS & PPC Stack size = 1 */
  2279. #else
  2280.             0x2,        /* Alpha Stack size = 2 */
  2281. #endif
  2282. /* 58 */    NdrFcShort( 0xe ),    /* Type Offset=14 */
  2283. /* 60 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  2284.             0x8,        /* FC_LONG */
  2285. /* 62 */    0x4e,        /* FC_IN_PARAM_BASETYPE */
  2286.             0x8,        /* FC_LONG */
  2287. /* 64 */    0x4e,        /* FC_IN_PARAM_BASETYPE */
  2288.             0x8,        /* FC_LONG */
  2289. /* 66 */    0x53,        /* FC_RETURN_PARAM_BASETYPE */
  2290.             0x8,        /* FC_LONG */
  2291.  
  2292.             0x0
  2293.         }
  2294.     };
  2295.  
  2296. static const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString =
  2297.     {
  2298.         0,
  2299.         {
  2300.             0x11, 0x0,    /* FC_RP */
  2301. /*  2 */    NdrFcShort( 0x2 ),    /* Offset= 2 (4) */
  2302. /*  4 */    
  2303.             0x15,        /* FC_STRUCT */
  2304.             0x3,        /* 3 */
  2305. /*  6 */    NdrFcShort( 0x10 ),    /* 16 */
  2306. /*  8 */    0x8,        /* FC_LONG */
  2307.             0x8,        /* FC_LONG */
  2308. /* 10 */    0x8,        /* FC_LONG */
  2309.             0x8,        /* FC_LONG */
  2310. /* 12 */    0x5c,        /* FC_PAD */
  2311.             0x5b,        /* FC_END */
  2312. /* 14 */    
  2313.             0x11, 0xc,    /* FC_RP [alloced_on_stack] [simple_pointer] */
  2314. /* 16 */    0x8,        /* FC_LONG */
  2315.             0x5c,        /* FC_PAD */
  2316. /* 18 */    
  2317.             0x11, 0x4,    /* FC_RP [alloced_on_stack] */
  2318. /* 20 */    NdrFcShort( 0xfffffff0 ),    /* Offset= -16 (4) */
  2319. /* 22 */    
  2320.             0x11, 0xc,    /* FC_RP [alloced_on_stack] [simple_pointer] */
  2321. /* 24 */    0x6,        /* FC_SHORT */
  2322.             0x5c,        /* FC_PAD */
  2323.  
  2324.             0x0
  2325.         }
  2326.     };
  2327.  
  2328. const CInterfaceProxyVtbl * _papint_ProxyVtblList[] = 
  2329. {
  2330.     ( CInterfaceProxyVtbl *) &_ISharePaperProxyVtbl,
  2331.     ( CInterfaceProxyVtbl *) &_IPaperSinkProxyVtbl,
  2332.     0
  2333. };
  2334.  
  2335. const CInterfaceStubVtbl * _papint_StubVtblList[] = 
  2336. {
  2337.     ( CInterfaceStubVtbl *) &_ISharePaperStubVtbl,
  2338.     ( CInterfaceStubVtbl *) &_IPaperSinkStubVtbl,
  2339.     0
  2340. };
  2341.  
  2342. PCInterfaceName const _papint_InterfaceNamesList[] = 
  2343. {
  2344.     "ISharePaper",
  2345.     "IPaperSink",
  2346.     0
  2347. };
  2348.  
  2349.  
  2350. #define _papint_CHECK_IID(n)    IID_GENERIC_CHECK_IID( _papint, pIID, n)
  2351.  
  2352. int __stdcall _papint_IID_Lookup( const IID * pIID, int * pIndex )
  2353. {
  2354.     IID_BS_LOOKUP_SETUP
  2355.  
  2356.     IID_BS_LOOKUP_INITIAL_TEST( _papint, 2, 1 )
  2357.     IID_BS_LOOKUP_RETURN_RESULT( _papint, 2, *pIndex )
  2358.     
  2359. }
  2360.  
  2361. const ExtendedProxyFileInfo papint_ProxyFileInfo = 
  2362. {
  2363.     (PCInterfaceProxyVtblList *) & _papint_ProxyVtblList,
  2364.     (PCInterfaceStubVtblList *) & _papint_StubVtblList,
  2365.     (const PCInterfaceName * ) & _papint_InterfaceNamesList,
  2366.     0, // no delegation
  2367.     & _papint_IID_Lookup, 
  2368.     2,
  2369.     1
  2370. };
  2371.