00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #ifndef __REDQ_RPCPROXY_H_VERSION__
00016 #define __REQUIRED_RPCPROXY_H_VERSION__ 440
00017 #endif
00018
00019
00020 #include "rpcproxy.h"
00021 #ifndef __RPCPROXY_H_VERSION__
00022 #error this stub requires an updated version of <rpcproxy.h>
00023 #endif // __RPCPROXY_H_VERSION__
00024
00025
00026 #include "Fdm.h"
00027
00028 #define TYPE_FORMAT_STRING_SIZE 99
00029 #define PROC_FORMAT_STRING_SIZE 63
00030
00031 typedef struct _MIDL_TYPE_FORMAT_STRING
00032 {
00033 short Pad;
00034 unsigned char Format[ TYPE_FORMAT_STRING_SIZE ];
00035 } MIDL_TYPE_FORMAT_STRING;
00036
00037 typedef struct _MIDL_PROC_FORMAT_STRING
00038 {
00039 short Pad;
00040 unsigned char Format[ PROC_FORMAT_STRING_SIZE ];
00041 } MIDL_PROC_FORMAT_STRING;
00042
00043
00044 extern const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString;
00045 extern const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString;
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060 extern const MIDL_STUB_DESC Object_StubDesc;
00061
00062
00063 #pragma code_seg(".orpc")
00064
00065 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_get_Url_Proxy(
00066 IWGUrlReceiver __RPC_FAR * This,
00067 BSTR __RPC_FAR *pVal)
00068 {
00069
00070 HRESULT _RetVal;
00071
00072 RPC_MESSAGE _RpcMessage;
00073
00074 MIDL_STUB_MESSAGE _StubMsg;
00075
00076 if(pVal)
00077 {
00078 MIDL_memset(
00079 pVal,
00080 0,
00081 sizeof( BSTR ));
00082 }
00083 RpcTryExcept
00084 {
00085 NdrProxyInitialize(
00086 ( void __RPC_FAR * )This,
00087 ( PRPC_MESSAGE )&_RpcMessage,
00088 ( PMIDL_STUB_MESSAGE )&_StubMsg,
00089 ( PMIDL_STUB_DESC )&Object_StubDesc,
00090 7);
00091
00092
00093
00094 if(!pVal)
00095 {
00096 RpcRaiseException(RPC_X_NULL_REF_POINTER);
00097 }
00098 RpcTryFinally
00099 {
00100
00101 _StubMsg.BufferLength = 0U;
00102 NdrProxyGetBuffer(This, &_StubMsg);
00103 NdrProxySendReceive(This, &_StubMsg);
00104
00105 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
00106 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
00107
00108 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
00109 (unsigned char __RPC_FAR * __RPC_FAR *)&pVal,
00110 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30],
00111 (unsigned char)0 );
00112
00113 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
00114 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
00115
00116 }
00117 RpcFinally
00118 {
00119 NdrProxyFreeBuffer(This, &_StubMsg);
00120
00121 }
00122 RpcEndFinally
00123
00124 }
00125 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
00126 {
00127 NdrClearOutParameters(
00128 ( PMIDL_STUB_MESSAGE )&_StubMsg,
00129 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[2],
00130 ( void __RPC_FAR * )pVal);
00131 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
00132 }
00133 RpcEndExcept
00134 return _RetVal;
00135 }
00136
00137 void __RPC_STUB IWGUrlReceiver_get_Url_Stub(
00138 IRpcStubBuffer *This,
00139 IRpcChannelBuffer *_pRpcChannelBuffer,
00140 PRPC_MESSAGE _pRpcMessage,
00141 DWORD *_pdwStubPhase)
00142 {
00143 BSTR _M0;
00144 HRESULT _RetVal;
00145 MIDL_STUB_MESSAGE _StubMsg;
00146 BSTR __RPC_FAR *pVal;
00147
00148 NdrStubInitialize(
00149 _pRpcMessage,
00150 &_StubMsg,
00151 &Object_StubDesc,
00152 _pRpcChannelBuffer);
00153 ( BSTR __RPC_FAR * )pVal = 0;
00154 RpcTryFinally
00155 {
00156 pVal = &_M0;
00157 MIDL_memset(
00158 pVal,
00159 0,
00160 sizeof( BSTR ));
00161
00162 *_pdwStubPhase = STUB_CALL_SERVER;
00163 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_Url((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,pVal);
00164
00165 *_pdwStubPhase = STUB_MARSHAL;
00166
00167 _StubMsg.BufferLength = 8U + 11U;
00168 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
00169 (unsigned char __RPC_FAR *)pVal,
00170 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
00171
00172 _StubMsg.BufferLength += 16;
00173
00174 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
00175 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
00176 (unsigned char __RPC_FAR *)pVal,
00177 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
00178
00179 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
00180 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
00181
00182 }
00183 RpcFinally
00184 {
00185 NdrPointerFree( &_StubMsg,
00186 (unsigned char __RPC_FAR *)pVal,
00187 &__MIDL_TypeFormatString.Format[2] );
00188
00189 }
00190 RpcEndFinally
00191 _pRpcMessage->BufferLength =
00192 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
00193
00194 }
00195
00196
00197 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_put_Url_Proxy(
00198 IWGUrlReceiver __RPC_FAR * This,
00199 BSTR newVal)
00200 {
00201
00202 HRESULT _RetVal;
00203
00204 RPC_MESSAGE _RpcMessage;
00205
00206 MIDL_STUB_MESSAGE _StubMsg;
00207
00208 RpcTryExcept
00209 {
00210 NdrProxyInitialize(
00211 ( void __RPC_FAR * )This,
00212 ( PRPC_MESSAGE )&_RpcMessage,
00213 ( PMIDL_STUB_MESSAGE )&_StubMsg,
00214 ( PMIDL_STUB_DESC )&Object_StubDesc,
00215 8);
00216
00217
00218
00219 RpcTryFinally
00220 {
00221
00222 _StubMsg.BufferLength = 8U;
00223 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
00224 (unsigned char __RPC_FAR *)&newVal,
00225 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
00226
00227 NdrProxyGetBuffer(This, &_StubMsg);
00228 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
00229 (unsigned char __RPC_FAR *)&newVal,
00230 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
00231
00232 NdrProxySendReceive(This, &_StubMsg);
00233
00234 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
00235 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
00236
00237 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
00238
00239 }
00240 RpcFinally
00241 {
00242 NdrProxyFreeBuffer(This, &_StubMsg);
00243
00244 }
00245 RpcEndFinally
00246
00247 }
00248 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
00249 {
00250 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
00251 }
00252 RpcEndExcept
00253 return _RetVal;
00254 }
00255
00256 void __RPC_STUB IWGUrlReceiver_put_Url_Stub(
00257 IRpcStubBuffer *This,
00258 IRpcChannelBuffer *_pRpcChannelBuffer,
00259 PRPC_MESSAGE _pRpcMessage,
00260 DWORD *_pdwStubPhase)
00261 {
00262 HRESULT _RetVal;
00263 MIDL_STUB_MESSAGE _StubMsg;
00264 void __RPC_FAR *_p_newVal;
00265 BSTR newVal;
00266
00267 NdrStubInitialize(
00268 _pRpcMessage,
00269 &_StubMsg,
00270 &Object_StubDesc,
00271 _pRpcChannelBuffer);
00272 _p_newVal = &newVal;
00273 MIDL_memset(
00274 _p_newVal,
00275 0,
00276 sizeof( BSTR ));
00277 RpcTryFinally
00278 {
00279 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
00280 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
00281
00282 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
00283 (unsigned char __RPC_FAR * __RPC_FAR *)&_p_newVal,
00284 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44],
00285 (unsigned char)0 );
00286
00287
00288 *_pdwStubPhase = STUB_CALL_SERVER;
00289 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_Url((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
00290
00291 *_pdwStubPhase = STUB_MARSHAL;
00292
00293 _StubMsg.BufferLength = 4U;
00294 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
00295 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
00296
00297 }
00298 RpcFinally
00299 {
00300 NdrUserMarshalFree( &_StubMsg,
00301 (unsigned char __RPC_FAR *)&newVal,
00302 &__MIDL_TypeFormatString.Format[44] );
00303
00304 }
00305 RpcEndFinally
00306 _pRpcMessage->BufferLength =
00307 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
00308
00309 }
00310
00311
00312 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_ShowAddDownloadDialog_Proxy(
00313 IWGUrlReceiver __RPC_FAR * This)
00314 {
00315
00316 HRESULT _RetVal;
00317
00318 RPC_MESSAGE _RpcMessage;
00319
00320 MIDL_STUB_MESSAGE _StubMsg;
00321
00322 RpcTryExcept
00323 {
00324 NdrProxyInitialize(
00325 ( void __RPC_FAR * )This,
00326 ( PRPC_MESSAGE )&_RpcMessage,
00327 ( PMIDL_STUB_MESSAGE )&_StubMsg,
00328 ( PMIDL_STUB_DESC )&Object_StubDesc,
00329 9);
00330
00331
00332
00333 RpcTryFinally
00334 {
00335
00336 _StubMsg.BufferLength = 0U;
00337 NdrProxyGetBuffer(This, &_StubMsg);
00338 NdrProxySendReceive(This, &_StubMsg);
00339
00340 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
00341 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[12] );
00342
00343 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
00344
00345 }
00346 RpcFinally
00347 {
00348 NdrProxyFreeBuffer(This, &_StubMsg);
00349
00350 }
00351 RpcEndFinally
00352
00353 }
00354 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
00355 {
00356 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
00357 }
00358 RpcEndExcept
00359 return _RetVal;
00360 }
00361
00362 void __RPC_STUB IWGUrlReceiver_ShowAddDownloadDialog_Stub(
00363 IRpcStubBuffer *This,
00364 IRpcChannelBuffer *_pRpcChannelBuffer,
00365 PRPC_MESSAGE _pRpcMessage,
00366 DWORD *_pdwStubPhase)
00367 {
00368 HRESULT _RetVal;
00369 MIDL_STUB_MESSAGE _StubMsg;
00370
00371 NdrStubInitialize(
00372 _pRpcMessage,
00373 &_StubMsg,
00374 &Object_StubDesc,
00375 _pRpcChannelBuffer);
00376 RpcTryFinally
00377 {
00378
00379 *_pdwStubPhase = STUB_CALL_SERVER;
00380 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> ShowAddDownloadDialog((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject);
00381
00382 *_pdwStubPhase = STUB_MARSHAL;
00383
00384 _StubMsg.BufferLength = 4U;
00385 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
00386 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
00387
00388 }
00389 RpcFinally
00390 {
00391 }
00392 RpcEndFinally
00393 _pRpcMessage->BufferLength =
00394 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
00395
00396 }
00397
00398
00399 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_ShowAddPageDownloadDialog_Proxy(
00400 IWGUrlReceiver __RPC_FAR * This)
00401 {
00402
00403 HRESULT _RetVal;
00404
00405 RPC_MESSAGE _RpcMessage;
00406
00407 MIDL_STUB_MESSAGE _StubMsg;
00408
00409 RpcTryExcept
00410 {
00411 NdrProxyInitialize(
00412 ( void __RPC_FAR * )This,
00413 ( PRPC_MESSAGE )&_RpcMessage,
00414 ( PMIDL_STUB_MESSAGE )&_StubMsg,
00415 ( PMIDL_STUB_DESC )&Object_StubDesc,
00416 10);
00417
00418
00419
00420 RpcTryFinally
00421 {
00422
00423 _StubMsg.BufferLength = 0U;
00424 NdrProxyGetBuffer(This, &_StubMsg);
00425 NdrProxySendReceive(This, &_StubMsg);
00426
00427 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
00428 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[12] );
00429
00430 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
00431
00432 }
00433 RpcFinally
00434 {
00435 NdrProxyFreeBuffer(This, &_StubMsg);
00436
00437 }
00438 RpcEndFinally
00439
00440 }
00441 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
00442 {
00443 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
00444 }
00445 RpcEndExcept
00446 return _RetVal;
00447 }
00448
00449 void __RPC_STUB IWGUrlReceiver_ShowAddPageDownloadDialog_Stub(
00450 IRpcStubBuffer *This,
00451 IRpcChannelBuffer *_pRpcChannelBuffer,
00452 PRPC_MESSAGE _pRpcMessage,
00453 DWORD *_pdwStubPhase)
00454 {
00455 HRESULT _RetVal;
00456 MIDL_STUB_MESSAGE _StubMsg;
00457
00458 NdrStubInitialize(
00459 _pRpcMessage,
00460 &_StubMsg,
00461 &Object_StubDesc,
00462 _pRpcChannelBuffer);
00463 RpcTryFinally
00464 {
00465
00466 *_pdwStubPhase = STUB_CALL_SERVER;
00467 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> ShowAddPageDownloadDialog((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject);
00468
00469 *_pdwStubPhase = STUB_MARSHAL;
00470
00471 _StubMsg.BufferLength = 4U;
00472 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
00473 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
00474
00475 }
00476 RpcFinally
00477 {
00478 }
00479 RpcEndFinally
00480 _pRpcMessage->BufferLength =
00481 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
00482
00483 }
00484
00485
00486 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_get_Comment_Proxy(
00487 IWGUrlReceiver __RPC_FAR * This,
00488 BSTR __RPC_FAR *pVal)
00489 {
00490
00491 HRESULT _RetVal;
00492
00493 RPC_MESSAGE _RpcMessage;
00494
00495 MIDL_STUB_MESSAGE _StubMsg;
00496
00497 if(pVal)
00498 {
00499 MIDL_memset(
00500 pVal,
00501 0,
00502 sizeof( BSTR ));
00503 }
00504 RpcTryExcept
00505 {
00506 NdrProxyInitialize(
00507 ( void __RPC_FAR * )This,
00508 ( PRPC_MESSAGE )&_RpcMessage,
00509 ( PMIDL_STUB_MESSAGE )&_StubMsg,
00510 ( PMIDL_STUB_DESC )&Object_StubDesc,
00511 11);
00512
00513
00514
00515 if(!pVal)
00516 {
00517 RpcRaiseException(RPC_X_NULL_REF_POINTER);
00518 }
00519 RpcTryFinally
00520 {
00521
00522 _StubMsg.BufferLength = 0U;
00523 NdrProxyGetBuffer(This, &_StubMsg);
00524 NdrProxySendReceive(This, &_StubMsg);
00525
00526 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
00527 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
00528
00529 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
00530 (unsigned char __RPC_FAR * __RPC_FAR *)&pVal,
00531 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30],
00532 (unsigned char)0 );
00533
00534 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
00535 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
00536
00537 }
00538 RpcFinally
00539 {
00540 NdrProxyFreeBuffer(This, &_StubMsg);
00541
00542 }
00543 RpcEndFinally
00544
00545 }
00546 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
00547 {
00548 NdrClearOutParameters(
00549 ( PMIDL_STUB_MESSAGE )&_StubMsg,
00550 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[2],
00551 ( void __RPC_FAR * )pVal);
00552 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
00553 }
00554 RpcEndExcept
00555 return _RetVal;
00556 }
00557
00558 void __RPC_STUB IWGUrlReceiver_get_Comment_Stub(
00559 IRpcStubBuffer *This,
00560 IRpcChannelBuffer *_pRpcChannelBuffer,
00561 PRPC_MESSAGE _pRpcMessage,
00562 DWORD *_pdwStubPhase)
00563 {
00564 BSTR _M1;
00565 HRESULT _RetVal;
00566 MIDL_STUB_MESSAGE _StubMsg;
00567 BSTR __RPC_FAR *pVal;
00568
00569 NdrStubInitialize(
00570 _pRpcMessage,
00571 &_StubMsg,
00572 &Object_StubDesc,
00573 _pRpcChannelBuffer);
00574 ( BSTR __RPC_FAR * )pVal = 0;
00575 RpcTryFinally
00576 {
00577 pVal = &_M1;
00578 MIDL_memset(
00579 pVal,
00580 0,
00581 sizeof( BSTR ));
00582
00583 *_pdwStubPhase = STUB_CALL_SERVER;
00584 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_Comment((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,pVal);
00585
00586 *_pdwStubPhase = STUB_MARSHAL;
00587
00588 _StubMsg.BufferLength = 8U + 11U;
00589 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
00590 (unsigned char __RPC_FAR *)pVal,
00591 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
00592
00593 _StubMsg.BufferLength += 16;
00594
00595 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
00596 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
00597 (unsigned char __RPC_FAR *)pVal,
00598 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
00599
00600 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
00601 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
00602
00603 }
00604 RpcFinally
00605 {
00606 NdrPointerFree( &_StubMsg,
00607 (unsigned char __RPC_FAR *)pVal,
00608 &__MIDL_TypeFormatString.Format[2] );
00609
00610 }
00611 RpcEndFinally
00612 _pRpcMessage->BufferLength =
00613 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
00614
00615 }
00616
00617
00618 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_put_Comment_Proxy(
00619 IWGUrlReceiver __RPC_FAR * This,
00620 BSTR newVal)
00621 {
00622
00623 HRESULT _RetVal;
00624
00625 RPC_MESSAGE _RpcMessage;
00626
00627 MIDL_STUB_MESSAGE _StubMsg;
00628
00629 RpcTryExcept
00630 {
00631 NdrProxyInitialize(
00632 ( void __RPC_FAR * )This,
00633 ( PRPC_MESSAGE )&_RpcMessage,
00634 ( PMIDL_STUB_MESSAGE )&_StubMsg,
00635 ( PMIDL_STUB_DESC )&Object_StubDesc,
00636 12);
00637
00638
00639
00640 RpcTryFinally
00641 {
00642
00643 _StubMsg.BufferLength = 8U;
00644 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
00645 (unsigned char __RPC_FAR *)&newVal,
00646 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
00647
00648 NdrProxyGetBuffer(This, &_StubMsg);
00649 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
00650 (unsigned char __RPC_FAR *)&newVal,
00651 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
00652
00653 NdrProxySendReceive(This, &_StubMsg);
00654
00655 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
00656 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
00657
00658 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
00659
00660 }
00661 RpcFinally
00662 {
00663 NdrProxyFreeBuffer(This, &_StubMsg);
00664
00665 }
00666 RpcEndFinally
00667
00668 }
00669 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
00670 {
00671 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
00672 }
00673 RpcEndExcept
00674 return _RetVal;
00675 }
00676
00677 void __RPC_STUB IWGUrlReceiver_put_Comment_Stub(
00678 IRpcStubBuffer *This,
00679 IRpcChannelBuffer *_pRpcChannelBuffer,
00680 PRPC_MESSAGE _pRpcMessage,
00681 DWORD *_pdwStubPhase)
00682 {
00683 HRESULT _RetVal;
00684 MIDL_STUB_MESSAGE _StubMsg;
00685 void __RPC_FAR *_p_newVal;
00686 BSTR newVal;
00687
00688 NdrStubInitialize(
00689 _pRpcMessage,
00690 &_StubMsg,
00691 &Object_StubDesc,
00692 _pRpcChannelBuffer);
00693 _p_newVal = &newVal;
00694 MIDL_memset(
00695 _p_newVal,
00696 0,
00697 sizeof( BSTR ));
00698 RpcTryFinally
00699 {
00700 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
00701 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
00702
00703 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
00704 (unsigned char __RPC_FAR * __RPC_FAR *)&_p_newVal,
00705 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44],
00706 (unsigned char)0 );
00707
00708
00709 *_pdwStubPhase = STUB_CALL_SERVER;
00710 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_Comment((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
00711
00712 *_pdwStubPhase = STUB_MARSHAL;
00713
00714 _StubMsg.BufferLength = 4U;
00715 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
00716 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
00717
00718 }
00719 RpcFinally
00720 {
00721 NdrUserMarshalFree( &_StubMsg,
00722 (unsigned char __RPC_FAR *)&newVal,
00723 &__MIDL_TypeFormatString.Format[44] );
00724
00725 }
00726 RpcEndFinally
00727 _pRpcMessage->BufferLength =
00728 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
00729
00730 }
00731
00732
00733 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_get_Referer_Proxy(
00734 IWGUrlReceiver __RPC_FAR * This,
00735 BSTR __RPC_FAR *pVal)
00736 {
00737
00738 HRESULT _RetVal;
00739
00740 RPC_MESSAGE _RpcMessage;
00741
00742 MIDL_STUB_MESSAGE _StubMsg;
00743
00744 if(pVal)
00745 {
00746 MIDL_memset(
00747 pVal,
00748 0,
00749 sizeof( BSTR ));
00750 }
00751 RpcTryExcept
00752 {
00753 NdrProxyInitialize(
00754 ( void __RPC_FAR * )This,
00755 ( PRPC_MESSAGE )&_RpcMessage,
00756 ( PMIDL_STUB_MESSAGE )&_StubMsg,
00757 ( PMIDL_STUB_DESC )&Object_StubDesc,
00758 13);
00759
00760
00761
00762 if(!pVal)
00763 {
00764 RpcRaiseException(RPC_X_NULL_REF_POINTER);
00765 }
00766 RpcTryFinally
00767 {
00768
00769 _StubMsg.BufferLength = 0U;
00770 NdrProxyGetBuffer(This, &_StubMsg);
00771 NdrProxySendReceive(This, &_StubMsg);
00772
00773 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
00774 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
00775
00776 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
00777 (unsigned char __RPC_FAR * __RPC_FAR *)&pVal,
00778 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30],
00779 (unsigned char)0 );
00780
00781 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
00782 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
00783
00784 }
00785 RpcFinally
00786 {
00787 NdrProxyFreeBuffer(This, &_StubMsg);
00788
00789 }
00790 RpcEndFinally
00791
00792 }
00793 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
00794 {
00795 NdrClearOutParameters(
00796 ( PMIDL_STUB_MESSAGE )&_StubMsg,
00797 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[2],
00798 ( void __RPC_FAR * )pVal);
00799 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
00800 }
00801 RpcEndExcept
00802 return _RetVal;
00803 }
00804
00805 void __RPC_STUB IWGUrlReceiver_get_Referer_Stub(
00806 IRpcStubBuffer *This,
00807 IRpcChannelBuffer *_pRpcChannelBuffer,
00808 PRPC_MESSAGE _pRpcMessage,
00809 DWORD *_pdwStubPhase)
00810 {
00811 BSTR _M2;
00812 HRESULT _RetVal;
00813 MIDL_STUB_MESSAGE _StubMsg;
00814 BSTR __RPC_FAR *pVal;
00815
00816 NdrStubInitialize(
00817 _pRpcMessage,
00818 &_StubMsg,
00819 &Object_StubDesc,
00820 _pRpcChannelBuffer);
00821 ( BSTR __RPC_FAR * )pVal = 0;
00822 RpcTryFinally
00823 {
00824 pVal = &_M2;
00825 MIDL_memset(
00826 pVal,
00827 0,
00828 sizeof( BSTR ));
00829
00830 *_pdwStubPhase = STUB_CALL_SERVER;
00831 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_Referer((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,pVal);
00832
00833 *_pdwStubPhase = STUB_MARSHAL;
00834
00835 _StubMsg.BufferLength = 8U + 11U;
00836 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
00837 (unsigned char __RPC_FAR *)pVal,
00838 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
00839
00840 _StubMsg.BufferLength += 16;
00841
00842 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
00843 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
00844 (unsigned char __RPC_FAR *)pVal,
00845 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
00846
00847 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
00848 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
00849
00850 }
00851 RpcFinally
00852 {
00853 NdrPointerFree( &_StubMsg,
00854 (unsigned char __RPC_FAR *)pVal,
00855 &__MIDL_TypeFormatString.Format[2] );
00856
00857 }
00858 RpcEndFinally
00859 _pRpcMessage->BufferLength =
00860 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
00861
00862 }
00863
00864
00865 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_put_Referer_Proxy(
00866 IWGUrlReceiver __RPC_FAR * This,
00867 BSTR newVal)
00868 {
00869
00870 HRESULT _RetVal;
00871
00872 RPC_MESSAGE _RpcMessage;
00873
00874 MIDL_STUB_MESSAGE _StubMsg;
00875
00876 RpcTryExcept
00877 {
00878 NdrProxyInitialize(
00879 ( void __RPC_FAR * )This,
00880 ( PRPC_MESSAGE )&_RpcMessage,
00881 ( PMIDL_STUB_MESSAGE )&_StubMsg,
00882 ( PMIDL_STUB_DESC )&Object_StubDesc,
00883 14);
00884
00885
00886
00887 RpcTryFinally
00888 {
00889
00890 _StubMsg.BufferLength = 8U;
00891 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
00892 (unsigned char __RPC_FAR *)&newVal,
00893 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
00894
00895 NdrProxyGetBuffer(This, &_StubMsg);
00896 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
00897 (unsigned char __RPC_FAR *)&newVal,
00898 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
00899
00900 NdrProxySendReceive(This, &_StubMsg);
00901
00902 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
00903 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
00904
00905 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
00906
00907 }
00908 RpcFinally
00909 {
00910 NdrProxyFreeBuffer(This, &_StubMsg);
00911
00912 }
00913 RpcEndFinally
00914
00915 }
00916 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
00917 {
00918 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
00919 }
00920 RpcEndExcept
00921 return _RetVal;
00922 }
00923
00924 void __RPC_STUB IWGUrlReceiver_put_Referer_Stub(
00925 IRpcStubBuffer *This,
00926 IRpcChannelBuffer *_pRpcChannelBuffer,
00927 PRPC_MESSAGE _pRpcMessage,
00928 DWORD *_pdwStubPhase)
00929 {
00930 HRESULT _RetVal;
00931 MIDL_STUB_MESSAGE _StubMsg;
00932 void __RPC_FAR *_p_newVal;
00933 BSTR newVal;
00934
00935 NdrStubInitialize(
00936 _pRpcMessage,
00937 &_StubMsg,
00938 &Object_StubDesc,
00939 _pRpcChannelBuffer);
00940 _p_newVal = &newVal;
00941 MIDL_memset(
00942 _p_newVal,
00943 0,
00944 sizeof( BSTR ));
00945 RpcTryFinally
00946 {
00947 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
00948 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
00949
00950 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
00951 (unsigned char __RPC_FAR * __RPC_FAR *)&_p_newVal,
00952 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44],
00953 (unsigned char)0 );
00954
00955
00956 *_pdwStubPhase = STUB_CALL_SERVER;
00957 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_Referer((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
00958
00959 *_pdwStubPhase = STUB_MARSHAL;
00960
00961 _StubMsg.BufferLength = 4U;
00962 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
00963 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
00964
00965 }
00966 RpcFinally
00967 {
00968 NdrUserMarshalFree( &_StubMsg,
00969 (unsigned char __RPC_FAR *)&newVal,
00970 &__MIDL_TypeFormatString.Format[44] );
00971
00972 }
00973 RpcEndFinally
00974 _pRpcMessage->BufferLength =
00975 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
00976
00977 }
00978
00979
00980 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_AddDownload_Proxy(
00981 IWGUrlReceiver __RPC_FAR * This)
00982 {
00983
00984 HRESULT _RetVal;
00985
00986 RPC_MESSAGE _RpcMessage;
00987
00988 MIDL_STUB_MESSAGE _StubMsg;
00989
00990 RpcTryExcept
00991 {
00992 NdrProxyInitialize(
00993 ( void __RPC_FAR * )This,
00994 ( PRPC_MESSAGE )&_RpcMessage,
00995 ( PMIDL_STUB_MESSAGE )&_StubMsg,
00996 ( PMIDL_STUB_DESC )&Object_StubDesc,
00997 15);
00998
00999
01000
01001 RpcTryFinally
01002 {
01003
01004 _StubMsg.BufferLength = 0U;
01005 NdrProxyGetBuffer(This, &_StubMsg);
01006 NdrProxySendReceive(This, &_StubMsg);
01007
01008 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
01009 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[12] );
01010
01011 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
01012
01013 }
01014 RpcFinally
01015 {
01016 NdrProxyFreeBuffer(This, &_StubMsg);
01017
01018 }
01019 RpcEndFinally
01020
01021 }
01022 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
01023 {
01024 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
01025 }
01026 RpcEndExcept
01027 return _RetVal;
01028 }
01029
01030 void __RPC_STUB IWGUrlReceiver_AddDownload_Stub(
01031 IRpcStubBuffer *This,
01032 IRpcChannelBuffer *_pRpcChannelBuffer,
01033 PRPC_MESSAGE _pRpcMessage,
01034 DWORD *_pdwStubPhase)
01035 {
01036 HRESULT _RetVal;
01037 MIDL_STUB_MESSAGE _StubMsg;
01038
01039 NdrStubInitialize(
01040 _pRpcMessage,
01041 &_StubMsg,
01042 &Object_StubDesc,
01043 _pRpcChannelBuffer);
01044 RpcTryFinally
01045 {
01046
01047 *_pdwStubPhase = STUB_CALL_SERVER;
01048 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> AddDownload((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject);
01049
01050 *_pdwStubPhase = STUB_MARSHAL;
01051
01052 _StubMsg.BufferLength = 4U;
01053 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
01054 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
01055
01056 }
01057 RpcFinally
01058 {
01059 }
01060 RpcEndFinally
01061 _pRpcMessage->BufferLength =
01062 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
01063
01064 }
01065
01066
01067 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_get_CheckExtension_Proxy(
01068 IWGUrlReceiver __RPC_FAR * This,
01069 BOOL __RPC_FAR *pVal)
01070 {
01071
01072 HRESULT _RetVal;
01073
01074 RPC_MESSAGE _RpcMessage;
01075
01076 MIDL_STUB_MESSAGE _StubMsg;
01077
01078 RpcTryExcept
01079 {
01080 NdrProxyInitialize(
01081 ( void __RPC_FAR * )This,
01082 ( PRPC_MESSAGE )&_RpcMessage,
01083 ( PMIDL_STUB_MESSAGE )&_StubMsg,
01084 ( PMIDL_STUB_DESC )&Object_StubDesc,
01085 16);
01086
01087
01088
01089 if(!pVal)
01090 {
01091 RpcRaiseException(RPC_X_NULL_REF_POINTER);
01092 }
01093 RpcTryFinally
01094 {
01095
01096 _StubMsg.BufferLength = 0U;
01097 NdrProxyGetBuffer(This, &_StubMsg);
01098 NdrProxySendReceive(This, &_StubMsg);
01099
01100 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
01101 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[14] );
01102
01103 *pVal = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
01104
01105 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
01106
01107 }
01108 RpcFinally
01109 {
01110 NdrProxyFreeBuffer(This, &_StubMsg);
01111
01112 }
01113 RpcEndFinally
01114
01115 }
01116 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
01117 {
01118 NdrClearOutParameters(
01119 ( PMIDL_STUB_MESSAGE )&_StubMsg,
01120 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[54],
01121 ( void __RPC_FAR * )pVal);
01122 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
01123 }
01124 RpcEndExcept
01125 return _RetVal;
01126 }
01127
01128 void __RPC_STUB IWGUrlReceiver_get_CheckExtension_Stub(
01129 IRpcStubBuffer *This,
01130 IRpcChannelBuffer *_pRpcChannelBuffer,
01131 PRPC_MESSAGE _pRpcMessage,
01132 DWORD *_pdwStubPhase)
01133 {
01134 BOOL _M3;
01135 HRESULT _RetVal;
01136 MIDL_STUB_MESSAGE _StubMsg;
01137 BOOL __RPC_FAR *pVal;
01138
01139 NdrStubInitialize(
01140 _pRpcMessage,
01141 &_StubMsg,
01142 &Object_StubDesc,
01143 _pRpcChannelBuffer);
01144 ( BOOL __RPC_FAR * )pVal = 0;
01145 RpcTryFinally
01146 {
01147 pVal = &_M3;
01148
01149 *_pdwStubPhase = STUB_CALL_SERVER;
01150 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_CheckExtension((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,pVal);
01151
01152 *_pdwStubPhase = STUB_MARSHAL;
01153
01154 _StubMsg.BufferLength = 4U + 4U;
01155 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
01156 *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = *pVal;
01157
01158 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
01159
01160 }
01161 RpcFinally
01162 {
01163 }
01164 RpcEndFinally
01165 _pRpcMessage->BufferLength =
01166 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
01167
01168 }
01169
01170
01171 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_put_CheckExtension_Proxy(
01172 IWGUrlReceiver __RPC_FAR * This,
01173 BOOL newVal)
01174 {
01175
01176 HRESULT _RetVal;
01177
01178 RPC_MESSAGE _RpcMessage;
01179
01180 MIDL_STUB_MESSAGE _StubMsg;
01181
01182 RpcTryExcept
01183 {
01184 NdrProxyInitialize(
01185 ( void __RPC_FAR * )This,
01186 ( PRPC_MESSAGE )&_RpcMessage,
01187 ( PMIDL_STUB_MESSAGE )&_StubMsg,
01188 ( PMIDL_STUB_DESC )&Object_StubDesc,
01189 17);
01190
01191
01192
01193 RpcTryFinally
01194 {
01195
01196 _StubMsg.BufferLength = 4U;
01197 NdrProxyGetBuffer(This, &_StubMsg);
01198 *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = newVal;
01199
01200 NdrProxySendReceive(This, &_StubMsg);
01201
01202 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
01203 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
01204
01205 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
01206
01207 }
01208 RpcFinally
01209 {
01210 NdrProxyFreeBuffer(This, &_StubMsg);
01211
01212 }
01213 RpcEndFinally
01214
01215 }
01216 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
01217 {
01218 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
01219 }
01220 RpcEndExcept
01221 return _RetVal;
01222 }
01223
01224 void __RPC_STUB IWGUrlReceiver_put_CheckExtension_Stub(
01225 IRpcStubBuffer *This,
01226 IRpcChannelBuffer *_pRpcChannelBuffer,
01227 PRPC_MESSAGE _pRpcMessage,
01228 DWORD *_pdwStubPhase)
01229 {
01230 HRESULT _RetVal;
01231 MIDL_STUB_MESSAGE _StubMsg;
01232 BOOL newVal;
01233
01234 NdrStubInitialize(
01235 _pRpcMessage,
01236 &_StubMsg,
01237 &Object_StubDesc,
01238 _pRpcChannelBuffer);
01239 RpcTryFinally
01240 {
01241 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
01242 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
01243
01244 newVal = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
01245
01246
01247 *_pdwStubPhase = STUB_CALL_SERVER;
01248 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_CheckExtension((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
01249
01250 *_pdwStubPhase = STUB_MARSHAL;
01251
01252 _StubMsg.BufferLength = 4U;
01253 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
01254 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
01255
01256 }
01257 RpcFinally
01258 {
01259 }
01260 RpcEndFinally
01261 _pRpcMessage->BufferLength =
01262 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
01263
01264 }
01265
01266
01267 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_get_IgnoreSize_Proxy(
01268 IWGUrlReceiver __RPC_FAR * This,
01269 BOOL __RPC_FAR *pVal)
01270 {
01271
01272 HRESULT _RetVal;
01273
01274 RPC_MESSAGE _RpcMessage;
01275
01276 MIDL_STUB_MESSAGE _StubMsg;
01277
01278 RpcTryExcept
01279 {
01280 NdrProxyInitialize(
01281 ( void __RPC_FAR * )This,
01282 ( PRPC_MESSAGE )&_RpcMessage,
01283 ( PMIDL_STUB_MESSAGE )&_StubMsg,
01284 ( PMIDL_STUB_DESC )&Object_StubDesc,
01285 18);
01286
01287
01288
01289 if(!pVal)
01290 {
01291 RpcRaiseException(RPC_X_NULL_REF_POINTER);
01292 }
01293 RpcTryFinally
01294 {
01295
01296 _StubMsg.BufferLength = 0U;
01297 NdrProxyGetBuffer(This, &_StubMsg);
01298 NdrProxySendReceive(This, &_StubMsg);
01299
01300 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
01301 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[14] );
01302
01303 *pVal = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
01304
01305 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
01306
01307 }
01308 RpcFinally
01309 {
01310 NdrProxyFreeBuffer(This, &_StubMsg);
01311
01312 }
01313 RpcEndFinally
01314
01315 }
01316 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
01317 {
01318 NdrClearOutParameters(
01319 ( PMIDL_STUB_MESSAGE )&_StubMsg,
01320 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[54],
01321 ( void __RPC_FAR * )pVal);
01322 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
01323 }
01324 RpcEndExcept
01325 return _RetVal;
01326 }
01327
01328 void __RPC_STUB IWGUrlReceiver_get_IgnoreSize_Stub(
01329 IRpcStubBuffer *This,
01330 IRpcChannelBuffer *_pRpcChannelBuffer,
01331 PRPC_MESSAGE _pRpcMessage,
01332 DWORD *_pdwStubPhase)
01333 {
01334 BOOL _M4;
01335 HRESULT _RetVal;
01336 MIDL_STUB_MESSAGE _StubMsg;
01337 BOOL __RPC_FAR *pVal;
01338
01339 NdrStubInitialize(
01340 _pRpcMessage,
01341 &_StubMsg,
01342 &Object_StubDesc,
01343 _pRpcChannelBuffer);
01344 ( BOOL __RPC_FAR * )pVal = 0;
01345 RpcTryFinally
01346 {
01347 pVal = &_M4;
01348
01349 *_pdwStubPhase = STUB_CALL_SERVER;
01350 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_IgnoreSize((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,pVal);
01351
01352 *_pdwStubPhase = STUB_MARSHAL;
01353
01354 _StubMsg.BufferLength = 4U + 4U;
01355 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
01356 *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = *pVal;
01357
01358 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
01359
01360 }
01361 RpcFinally
01362 {
01363 }
01364 RpcEndFinally
01365 _pRpcMessage->BufferLength =
01366 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
01367
01368 }
01369
01370
01371 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_put_IgnoreSize_Proxy(
01372 IWGUrlReceiver __RPC_FAR * This,
01373 BOOL newVal)
01374 {
01375
01376 HRESULT _RetVal;
01377
01378 RPC_MESSAGE _RpcMessage;
01379
01380 MIDL_STUB_MESSAGE _StubMsg;
01381
01382 RpcTryExcept
01383 {
01384 NdrProxyInitialize(
01385 ( void __RPC_FAR * )This,
01386 ( PRPC_MESSAGE )&_RpcMessage,
01387 ( PMIDL_STUB_MESSAGE )&_StubMsg,
01388 ( PMIDL_STUB_DESC )&Object_StubDesc,
01389 19);
01390
01391
01392
01393 RpcTryFinally
01394 {
01395
01396 _StubMsg.BufferLength = 4U;
01397 NdrProxyGetBuffer(This, &_StubMsg);
01398 *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = newVal;
01399
01400 NdrProxySendReceive(This, &_StubMsg);
01401
01402 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
01403 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
01404
01405 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
01406
01407 }
01408 RpcFinally
01409 {
01410 NdrProxyFreeBuffer(This, &_StubMsg);
01411
01412 }
01413 RpcEndFinally
01414
01415 }
01416 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
01417 {
01418 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
01419 }
01420 RpcEndExcept
01421 return _RetVal;
01422 }
01423
01424 void __RPC_STUB IWGUrlReceiver_put_IgnoreSize_Stub(
01425 IRpcStubBuffer *This,
01426 IRpcChannelBuffer *_pRpcChannelBuffer,
01427 PRPC_MESSAGE _pRpcMessage,
01428 DWORD *_pdwStubPhase)
01429 {
01430 HRESULT _RetVal;
01431 MIDL_STUB_MESSAGE _StubMsg;
01432 BOOL newVal;
01433
01434 NdrStubInitialize(
01435 _pRpcMessage,
01436 &_StubMsg,
01437 &Object_StubDesc,
01438 _pRpcChannelBuffer);
01439 RpcTryFinally
01440 {
01441 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
01442 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
01443
01444 newVal = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
01445
01446
01447 *_pdwStubPhase = STUB_CALL_SERVER;
01448 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_IgnoreSize((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
01449
01450 *_pdwStubPhase = STUB_MARSHAL;
01451
01452 _StubMsg.BufferLength = 4U;
01453 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
01454 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
01455
01456 }
01457 RpcFinally
01458 {
01459 }
01460 RpcEndFinally
01461 _pRpcMessage->BufferLength =
01462 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
01463
01464 }
01465
01466
01467 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_get_UseSkipExtsList_Proxy(
01468 IWGUrlReceiver __RPC_FAR * This,
01469 BOOL __RPC_FAR *pVal)
01470 {
01471
01472 HRESULT _RetVal;
01473
01474 RPC_MESSAGE _RpcMessage;
01475
01476 MIDL_STUB_MESSAGE _StubMsg;
01477
01478 RpcTryExcept
01479 {
01480 NdrProxyInitialize(
01481 ( void __RPC_FAR * )This,
01482 ( PRPC_MESSAGE )&_RpcMessage,
01483 ( PMIDL_STUB_MESSAGE )&_StubMsg,
01484 ( PMIDL_STUB_DESC )&Object_StubDesc,
01485 20);
01486
01487
01488
01489 if(!pVal)
01490 {
01491 RpcRaiseException(RPC_X_NULL_REF_POINTER);
01492 }
01493 RpcTryFinally
01494 {
01495
01496 _StubMsg.BufferLength = 0U;
01497 NdrProxyGetBuffer(This, &_StubMsg);
01498 NdrProxySendReceive(This, &_StubMsg);
01499
01500 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
01501 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[14] );
01502
01503 *pVal = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
01504
01505 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
01506
01507 }
01508 RpcFinally
01509 {
01510 NdrProxyFreeBuffer(This, &_StubMsg);
01511
01512 }
01513 RpcEndFinally
01514
01515 }
01516 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
01517 {
01518 NdrClearOutParameters(
01519 ( PMIDL_STUB_MESSAGE )&_StubMsg,
01520 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[54],
01521 ( void __RPC_FAR * )pVal);
01522 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
01523 }
01524 RpcEndExcept
01525 return _RetVal;
01526 }
01527
01528 void __RPC_STUB IWGUrlReceiver_get_UseSkipExtsList_Stub(
01529 IRpcStubBuffer *This,
01530 IRpcChannelBuffer *_pRpcChannelBuffer,
01531 PRPC_MESSAGE _pRpcMessage,
01532 DWORD *_pdwStubPhase)
01533 {
01534 BOOL _M5;
01535 HRESULT _RetVal;
01536 MIDL_STUB_MESSAGE _StubMsg;
01537 BOOL __RPC_FAR *pVal;
01538
01539 NdrStubInitialize(
01540 _pRpcMessage,
01541 &_StubMsg,
01542 &Object_StubDesc,
01543 _pRpcChannelBuffer);
01544 ( BOOL __RPC_FAR * )pVal = 0;
01545 RpcTryFinally
01546 {
01547 pVal = &_M5;
01548
01549 *_pdwStubPhase = STUB_CALL_SERVER;
01550 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_UseSkipExtsList((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,pVal);
01551
01552 *_pdwStubPhase = STUB_MARSHAL;
01553
01554 _StubMsg.BufferLength = 4U + 4U;
01555 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
01556 *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = *pVal;
01557
01558 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
01559
01560 }
01561 RpcFinally
01562 {
01563 }
01564 RpcEndFinally
01565 _pRpcMessage->BufferLength =
01566 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
01567
01568 }
01569
01570
01571 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_put_UseSkipExtsList_Proxy(
01572 IWGUrlReceiver __RPC_FAR * This,
01573 BOOL newVal)
01574 {
01575
01576 HRESULT _RetVal;
01577
01578 RPC_MESSAGE _RpcMessage;
01579
01580 MIDL_STUB_MESSAGE _StubMsg;
01581
01582 RpcTryExcept
01583 {
01584 NdrProxyInitialize(
01585 ( void __RPC_FAR * )This,
01586 ( PRPC_MESSAGE )&_RpcMessage,
01587 ( PMIDL_STUB_MESSAGE )&_StubMsg,
01588 ( PMIDL_STUB_DESC )&Object_StubDesc,
01589 21);
01590
01591
01592
01593 RpcTryFinally
01594 {
01595
01596 _StubMsg.BufferLength = 4U;
01597 NdrProxyGetBuffer(This, &_StubMsg);
01598 *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = newVal;
01599
01600 NdrProxySendReceive(This, &_StubMsg);
01601
01602 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
01603 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
01604
01605 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
01606
01607 }
01608 RpcFinally
01609 {
01610 NdrProxyFreeBuffer(This, &_StubMsg);
01611
01612 }
01613 RpcEndFinally
01614
01615 }
01616 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
01617 {
01618 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
01619 }
01620 RpcEndExcept
01621 return _RetVal;
01622 }
01623
01624 void __RPC_STUB IWGUrlReceiver_put_UseSkipExtsList_Stub(
01625 IRpcStubBuffer *This,
01626 IRpcChannelBuffer *_pRpcChannelBuffer,
01627 PRPC_MESSAGE _pRpcMessage,
01628 DWORD *_pdwStubPhase)
01629 {
01630 HRESULT _RetVal;
01631 MIDL_STUB_MESSAGE _StubMsg;
01632 BOOL newVal;
01633
01634 NdrStubInitialize(
01635 _pRpcMessage,
01636 &_StubMsg,
01637 &Object_StubDesc,
01638 _pRpcChannelBuffer);
01639 RpcTryFinally
01640 {
01641 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
01642 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
01643
01644 newVal = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
01645
01646
01647 *_pdwStubPhase = STUB_CALL_SERVER;
01648 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_UseSkipExtsList((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
01649
01650 *_pdwStubPhase = STUB_MARSHAL;
01651
01652 _StubMsg.BufferLength = 4U;
01653 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
01654 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
01655
01656 }
01657 RpcFinally
01658 {
01659 }
01660 RpcEndFinally
01661 _pRpcMessage->BufferLength =
01662 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
01663
01664 }
01665
01666
01667 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_get_UIState_Proxy(
01668 IWGUrlReceiver __RPC_FAR * This,
01669 BSTR __RPC_FAR *pVal)
01670 {
01671
01672 HRESULT _RetVal;
01673
01674 RPC_MESSAGE _RpcMessage;
01675
01676 MIDL_STUB_MESSAGE _StubMsg;
01677
01678 if(pVal)
01679 {
01680 MIDL_memset(
01681 pVal,
01682 0,
01683 sizeof( BSTR ));
01684 }
01685 RpcTryExcept
01686 {
01687 NdrProxyInitialize(
01688 ( void __RPC_FAR * )This,
01689 ( PRPC_MESSAGE )&_RpcMessage,
01690 ( PMIDL_STUB_MESSAGE )&_StubMsg,
01691 ( PMIDL_STUB_DESC )&Object_StubDesc,
01692 22);
01693
01694
01695
01696 if(!pVal)
01697 {
01698 RpcRaiseException(RPC_X_NULL_REF_POINTER);
01699 }
01700 RpcTryFinally
01701 {
01702
01703 _StubMsg.BufferLength = 0U;
01704 NdrProxyGetBuffer(This, &_StubMsg);
01705 NdrProxySendReceive(This, &_StubMsg);
01706
01707 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
01708 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
01709
01710 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
01711 (unsigned char __RPC_FAR * __RPC_FAR *)&pVal,
01712 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30],
01713 (unsigned char)0 );
01714
01715 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
01716 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
01717
01718 }
01719 RpcFinally
01720 {
01721 NdrProxyFreeBuffer(This, &_StubMsg);
01722
01723 }
01724 RpcEndFinally
01725
01726 }
01727 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
01728 {
01729 NdrClearOutParameters(
01730 ( PMIDL_STUB_MESSAGE )&_StubMsg,
01731 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[2],
01732 ( void __RPC_FAR * )pVal);
01733 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
01734 }
01735 RpcEndExcept
01736 return _RetVal;
01737 }
01738
01739 void __RPC_STUB IWGUrlReceiver_get_UIState_Stub(
01740 IRpcStubBuffer *This,
01741 IRpcChannelBuffer *_pRpcChannelBuffer,
01742 PRPC_MESSAGE _pRpcMessage,
01743 DWORD *_pdwStubPhase)
01744 {
01745 BSTR _M6;
01746 HRESULT _RetVal;
01747 MIDL_STUB_MESSAGE _StubMsg;
01748 BSTR __RPC_FAR *pVal;
01749
01750 NdrStubInitialize(
01751 _pRpcMessage,
01752 &_StubMsg,
01753 &Object_StubDesc,
01754 _pRpcChannelBuffer);
01755 ( BSTR __RPC_FAR * )pVal = 0;
01756 RpcTryFinally
01757 {
01758 pVal = &_M6;
01759 MIDL_memset(
01760 pVal,
01761 0,
01762 sizeof( BSTR ));
01763
01764 *_pdwStubPhase = STUB_CALL_SERVER;
01765 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_UIState((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,pVal);
01766
01767 *_pdwStubPhase = STUB_MARSHAL;
01768
01769 _StubMsg.BufferLength = 8U + 11U;
01770 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
01771 (unsigned char __RPC_FAR *)pVal,
01772 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
01773
01774 _StubMsg.BufferLength += 16;
01775
01776 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
01777 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
01778 (unsigned char __RPC_FAR *)pVal,
01779 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
01780
01781 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
01782 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
01783
01784 }
01785 RpcFinally
01786 {
01787 NdrPointerFree( &_StubMsg,
01788 (unsigned char __RPC_FAR *)pVal,
01789 &__MIDL_TypeFormatString.Format[2] );
01790
01791 }
01792 RpcEndFinally
01793 _pRpcMessage->BufferLength =
01794 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
01795
01796 }
01797
01798
01799 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_get_ForceSilent_Proxy(
01800 IWGUrlReceiver __RPC_FAR * This,
01801 BOOL __RPC_FAR *pVal)
01802 {
01803
01804 HRESULT _RetVal;
01805
01806 RPC_MESSAGE _RpcMessage;
01807
01808 MIDL_STUB_MESSAGE _StubMsg;
01809
01810 RpcTryExcept
01811 {
01812 NdrProxyInitialize(
01813 ( void __RPC_FAR * )This,
01814 ( PRPC_MESSAGE )&_RpcMessage,
01815 ( PMIDL_STUB_MESSAGE )&_StubMsg,
01816 ( PMIDL_STUB_DESC )&Object_StubDesc,
01817 23);
01818
01819
01820
01821 if(!pVal)
01822 {
01823 RpcRaiseException(RPC_X_NULL_REF_POINTER);
01824 }
01825 RpcTryFinally
01826 {
01827
01828 _StubMsg.BufferLength = 0U;
01829 NdrProxyGetBuffer(This, &_StubMsg);
01830 NdrProxySendReceive(This, &_StubMsg);
01831
01832 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
01833 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[14] );
01834
01835 *pVal = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
01836
01837 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
01838
01839 }
01840 RpcFinally
01841 {
01842 NdrProxyFreeBuffer(This, &_StubMsg);
01843
01844 }
01845 RpcEndFinally
01846
01847 }
01848 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
01849 {
01850 NdrClearOutParameters(
01851 ( PMIDL_STUB_MESSAGE )&_StubMsg,
01852 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[54],
01853 ( void __RPC_FAR * )pVal);
01854 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
01855 }
01856 RpcEndExcept
01857 return _RetVal;
01858 }
01859
01860 void __RPC_STUB IWGUrlReceiver_get_ForceSilent_Stub(
01861 IRpcStubBuffer *This,
01862 IRpcChannelBuffer *_pRpcChannelBuffer,
01863 PRPC_MESSAGE _pRpcMessage,
01864 DWORD *_pdwStubPhase)
01865 {
01866 BOOL _M7;
01867 HRESULT _RetVal;
01868 MIDL_STUB_MESSAGE _StubMsg;
01869 BOOL __RPC_FAR *pVal;
01870
01871 NdrStubInitialize(
01872 _pRpcMessage,
01873 &_StubMsg,
01874 &Object_StubDesc,
01875 _pRpcChannelBuffer);
01876 ( BOOL __RPC_FAR * )pVal = 0;
01877 RpcTryFinally
01878 {
01879 pVal = &_M7;
01880
01881 *_pdwStubPhase = STUB_CALL_SERVER;
01882 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_ForceSilent((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,pVal);
01883
01884 *_pdwStubPhase = STUB_MARSHAL;
01885
01886 _StubMsg.BufferLength = 4U + 4U;
01887 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
01888 *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = *pVal;
01889
01890 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
01891
01892 }
01893 RpcFinally
01894 {
01895 }
01896 RpcEndFinally
01897 _pRpcMessage->BufferLength =
01898 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
01899
01900 }
01901
01902
01903 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_put_ForceSilent_Proxy(
01904 IWGUrlReceiver __RPC_FAR * This,
01905 BOOL newVal)
01906 {
01907
01908 HRESULT _RetVal;
01909
01910 RPC_MESSAGE _RpcMessage;
01911
01912 MIDL_STUB_MESSAGE _StubMsg;
01913
01914 RpcTryExcept
01915 {
01916 NdrProxyInitialize(
01917 ( void __RPC_FAR * )This,
01918 ( PRPC_MESSAGE )&_RpcMessage,
01919 ( PMIDL_STUB_MESSAGE )&_StubMsg,
01920 ( PMIDL_STUB_DESC )&Object_StubDesc,
01921 24);
01922
01923
01924
01925 RpcTryFinally
01926 {
01927
01928 _StubMsg.BufferLength = 4U;
01929 NdrProxyGetBuffer(This, &_StubMsg);
01930 *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = newVal;
01931
01932 NdrProxySendReceive(This, &_StubMsg);
01933
01934 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
01935 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
01936
01937 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
01938
01939 }
01940 RpcFinally
01941 {
01942 NdrProxyFreeBuffer(This, &_StubMsg);
01943
01944 }
01945 RpcEndFinally
01946
01947 }
01948 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
01949 {
01950 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
01951 }
01952 RpcEndExcept
01953 return _RetVal;
01954 }
01955
01956 void __RPC_STUB IWGUrlReceiver_put_ForceSilent_Stub(
01957 IRpcStubBuffer *This,
01958 IRpcChannelBuffer *_pRpcChannelBuffer,
01959 PRPC_MESSAGE _pRpcMessage,
01960 DWORD *_pdwStubPhase)
01961 {
01962 HRESULT _RetVal;
01963 MIDL_STUB_MESSAGE _StubMsg;
01964 BOOL newVal;
01965
01966 NdrStubInitialize(
01967 _pRpcMessage,
01968 &_StubMsg,
01969 &Object_StubDesc,
01970 _pRpcChannelBuffer);
01971 RpcTryFinally
01972 {
01973 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
01974 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
01975
01976 newVal = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
01977
01978
01979 *_pdwStubPhase = STUB_CALL_SERVER;
01980 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_ForceSilent((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
01981
01982 *_pdwStubPhase = STUB_MARSHAL;
01983
01984 _StubMsg.BufferLength = 4U;
01985 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
01986 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
01987
01988 }
01989 RpcFinally
01990 {
01991 }
01992 RpcEndFinally
01993 _pRpcMessage->BufferLength =
01994 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
01995
01996 }
01997
01998
01999 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_get_Cookies_Proxy(
02000 IWGUrlReceiver __RPC_FAR * This,
02001 BSTR __RPC_FAR *pVal)
02002 {
02003
02004 HRESULT _RetVal;
02005
02006 RPC_MESSAGE _RpcMessage;
02007
02008 MIDL_STUB_MESSAGE _StubMsg;
02009
02010 if(pVal)
02011 {
02012 MIDL_memset(
02013 pVal,
02014 0,
02015 sizeof( BSTR ));
02016 }
02017 RpcTryExcept
02018 {
02019 NdrProxyInitialize(
02020 ( void __RPC_FAR * )This,
02021 ( PRPC_MESSAGE )&_RpcMessage,
02022 ( PMIDL_STUB_MESSAGE )&_StubMsg,
02023 ( PMIDL_STUB_DESC )&Object_StubDesc,
02024 25);
02025
02026
02027
02028 if(!pVal)
02029 {
02030 RpcRaiseException(RPC_X_NULL_REF_POINTER);
02031 }
02032 RpcTryFinally
02033 {
02034
02035 _StubMsg.BufferLength = 0U;
02036 NdrProxyGetBuffer(This, &_StubMsg);
02037 NdrProxySendReceive(This, &_StubMsg);
02038
02039 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
02040 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
02041
02042 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
02043 (unsigned char __RPC_FAR * __RPC_FAR *)&pVal,
02044 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30],
02045 (unsigned char)0 );
02046
02047 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
02048 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
02049
02050 }
02051 RpcFinally
02052 {
02053 NdrProxyFreeBuffer(This, &_StubMsg);
02054
02055 }
02056 RpcEndFinally
02057
02058 }
02059 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
02060 {
02061 NdrClearOutParameters(
02062 ( PMIDL_STUB_MESSAGE )&_StubMsg,
02063 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[2],
02064 ( void __RPC_FAR * )pVal);
02065 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
02066 }
02067 RpcEndExcept
02068 return _RetVal;
02069 }
02070
02071 void __RPC_STUB IWGUrlReceiver_get_Cookies_Stub(
02072 IRpcStubBuffer *This,
02073 IRpcChannelBuffer *_pRpcChannelBuffer,
02074 PRPC_MESSAGE _pRpcMessage,
02075 DWORD *_pdwStubPhase)
02076 {
02077 BSTR _M8;
02078 HRESULT _RetVal;
02079 MIDL_STUB_MESSAGE _StubMsg;
02080 BSTR __RPC_FAR *pVal;
02081
02082 NdrStubInitialize(
02083 _pRpcMessage,
02084 &_StubMsg,
02085 &Object_StubDesc,
02086 _pRpcChannelBuffer);
02087 ( BSTR __RPC_FAR * )pVal = 0;
02088 RpcTryFinally
02089 {
02090 pVal = &_M8;
02091 MIDL_memset(
02092 pVal,
02093 0,
02094 sizeof( BSTR ));
02095
02096 *_pdwStubPhase = STUB_CALL_SERVER;
02097 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_Cookies((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,pVal);
02098
02099 *_pdwStubPhase = STUB_MARSHAL;
02100
02101 _StubMsg.BufferLength = 8U + 11U;
02102 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
02103 (unsigned char __RPC_FAR *)pVal,
02104 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
02105
02106 _StubMsg.BufferLength += 16;
02107
02108 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
02109 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
02110 (unsigned char __RPC_FAR *)pVal,
02111 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
02112
02113 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
02114 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
02115
02116 }
02117 RpcFinally
02118 {
02119 NdrPointerFree( &_StubMsg,
02120 (unsigned char __RPC_FAR *)pVal,
02121 &__MIDL_TypeFormatString.Format[2] );
02122
02123 }
02124 RpcEndFinally
02125 _pRpcMessage->BufferLength =
02126 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
02127
02128 }
02129
02130
02131 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_put_Cookies_Proxy(
02132 IWGUrlReceiver __RPC_FAR * This,
02133 BSTR newVal)
02134 {
02135
02136 HRESULT _RetVal;
02137
02138 RPC_MESSAGE _RpcMessage;
02139
02140 MIDL_STUB_MESSAGE _StubMsg;
02141
02142 RpcTryExcept
02143 {
02144 NdrProxyInitialize(
02145 ( void __RPC_FAR * )This,
02146 ( PRPC_MESSAGE )&_RpcMessage,
02147 ( PMIDL_STUB_MESSAGE )&_StubMsg,
02148 ( PMIDL_STUB_DESC )&Object_StubDesc,
02149 26);
02150
02151
02152
02153 RpcTryFinally
02154 {
02155
02156 _StubMsg.BufferLength = 8U;
02157 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
02158 (unsigned char __RPC_FAR *)&newVal,
02159 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
02160
02161 NdrProxyGetBuffer(This, &_StubMsg);
02162 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
02163 (unsigned char __RPC_FAR *)&newVal,
02164 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
02165
02166 NdrProxySendReceive(This, &_StubMsg);
02167
02168 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
02169 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
02170
02171 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
02172
02173 }
02174 RpcFinally
02175 {
02176 NdrProxyFreeBuffer(This, &_StubMsg);
02177
02178 }
02179 RpcEndFinally
02180
02181 }
02182 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
02183 {
02184 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
02185 }
02186 RpcEndExcept
02187 return _RetVal;
02188 }
02189
02190 void __RPC_STUB IWGUrlReceiver_put_Cookies_Stub(
02191 IRpcStubBuffer *This,
02192 IRpcChannelBuffer *_pRpcChannelBuffer,
02193 PRPC_MESSAGE _pRpcMessage,
02194 DWORD *_pdwStubPhase)
02195 {
02196 HRESULT _RetVal;
02197 MIDL_STUB_MESSAGE _StubMsg;
02198 void __RPC_FAR *_p_newVal;
02199 BSTR newVal;
02200
02201 NdrStubInitialize(
02202 _pRpcMessage,
02203 &_StubMsg,
02204 &Object_StubDesc,
02205 _pRpcChannelBuffer);
02206 _p_newVal = &newVal;
02207 MIDL_memset(
02208 _p_newVal,
02209 0,
02210 sizeof( BSTR ));
02211 RpcTryFinally
02212 {
02213 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
02214 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
02215
02216 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
02217 (unsigned char __RPC_FAR * __RPC_FAR *)&_p_newVal,
02218 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44],
02219 (unsigned char)0 );
02220
02221
02222 *_pdwStubPhase = STUB_CALL_SERVER;
02223 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_Cookies((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
02224
02225 *_pdwStubPhase = STUB_MARSHAL;
02226
02227 _StubMsg.BufferLength = 4U;
02228 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
02229 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
02230
02231 }
02232 RpcFinally
02233 {
02234 NdrUserMarshalFree( &_StubMsg,
02235 (unsigned char __RPC_FAR *)&newVal,
02236 &__MIDL_TypeFormatString.Format[44] );
02237
02238 }
02239 RpcEndFinally
02240 _pRpcMessage->BufferLength =
02241 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
02242
02243 }
02244
02245
02246 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_get_PostData_Proxy(
02247 IWGUrlReceiver __RPC_FAR * This,
02248 BSTR __RPC_FAR *pVal)
02249 {
02250
02251 HRESULT _RetVal;
02252
02253 RPC_MESSAGE _RpcMessage;
02254
02255 MIDL_STUB_MESSAGE _StubMsg;
02256
02257 if(pVal)
02258 {
02259 MIDL_memset(
02260 pVal,
02261 0,
02262 sizeof( BSTR ));
02263 }
02264 RpcTryExcept
02265 {
02266 NdrProxyInitialize(
02267 ( void __RPC_FAR * )This,
02268 ( PRPC_MESSAGE )&_RpcMessage,
02269 ( PMIDL_STUB_MESSAGE )&_StubMsg,
02270 ( PMIDL_STUB_DESC )&Object_StubDesc,
02271 27);
02272
02273
02274
02275 if(!pVal)
02276 {
02277 RpcRaiseException(RPC_X_NULL_REF_POINTER);
02278 }
02279 RpcTryFinally
02280 {
02281
02282 _StubMsg.BufferLength = 0U;
02283 NdrProxyGetBuffer(This, &_StubMsg);
02284 NdrProxySendReceive(This, &_StubMsg);
02285
02286 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
02287 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
02288
02289 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
02290 (unsigned char __RPC_FAR * __RPC_FAR *)&pVal,
02291 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30],
02292 (unsigned char)0 );
02293
02294 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
02295 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
02296
02297 }
02298 RpcFinally
02299 {
02300 NdrProxyFreeBuffer(This, &_StubMsg);
02301
02302 }
02303 RpcEndFinally
02304
02305 }
02306 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
02307 {
02308 NdrClearOutParameters(
02309 ( PMIDL_STUB_MESSAGE )&_StubMsg,
02310 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[2],
02311 ( void __RPC_FAR * )pVal);
02312 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
02313 }
02314 RpcEndExcept
02315 return _RetVal;
02316 }
02317
02318 void __RPC_STUB IWGUrlReceiver_get_PostData_Stub(
02319 IRpcStubBuffer *This,
02320 IRpcChannelBuffer *_pRpcChannelBuffer,
02321 PRPC_MESSAGE _pRpcMessage,
02322 DWORD *_pdwStubPhase)
02323 {
02324 BSTR _M9;
02325 HRESULT _RetVal;
02326 MIDL_STUB_MESSAGE _StubMsg;
02327 BSTR __RPC_FAR *pVal;
02328
02329 NdrStubInitialize(
02330 _pRpcMessage,
02331 &_StubMsg,
02332 &Object_StubDesc,
02333 _pRpcChannelBuffer);
02334 ( BSTR __RPC_FAR * )pVal = 0;
02335 RpcTryFinally
02336 {
02337 pVal = &_M9;
02338 MIDL_memset(
02339 pVal,
02340 0,
02341 sizeof( BSTR ));
02342
02343 *_pdwStubPhase = STUB_CALL_SERVER;
02344 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_PostData((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,pVal);
02345
02346 *_pdwStubPhase = STUB_MARSHAL;
02347
02348 _StubMsg.BufferLength = 8U + 11U;
02349 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
02350 (unsigned char __RPC_FAR *)pVal,
02351 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
02352
02353 _StubMsg.BufferLength += 16;
02354
02355 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
02356 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
02357 (unsigned char __RPC_FAR *)pVal,
02358 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
02359
02360 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
02361 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
02362
02363 }
02364 RpcFinally
02365 {
02366 NdrPointerFree( &_StubMsg,
02367 (unsigned char __RPC_FAR *)pVal,
02368 &__MIDL_TypeFormatString.Format[2] );
02369
02370 }
02371 RpcEndFinally
02372 _pRpcMessage->BufferLength =
02373 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
02374
02375 }
02376
02377
02378 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_put_PostData_Proxy(
02379 IWGUrlReceiver __RPC_FAR * This,
02380 BSTR newVal)
02381 {
02382
02383 HRESULT _RetVal;
02384
02385 RPC_MESSAGE _RpcMessage;
02386
02387 MIDL_STUB_MESSAGE _StubMsg;
02388
02389 RpcTryExcept
02390 {
02391 NdrProxyInitialize(
02392 ( void __RPC_FAR * )This,
02393 ( PRPC_MESSAGE )&_RpcMessage,
02394 ( PMIDL_STUB_MESSAGE )&_StubMsg,
02395 ( PMIDL_STUB_DESC )&Object_StubDesc,
02396 28);
02397
02398
02399
02400 RpcTryFinally
02401 {
02402
02403 _StubMsg.BufferLength = 8U;
02404 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
02405 (unsigned char __RPC_FAR *)&newVal,
02406 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
02407
02408 NdrProxyGetBuffer(This, &_StubMsg);
02409 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
02410 (unsigned char __RPC_FAR *)&newVal,
02411 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
02412
02413 NdrProxySendReceive(This, &_StubMsg);
02414
02415 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
02416 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
02417
02418 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
02419
02420 }
02421 RpcFinally
02422 {
02423 NdrProxyFreeBuffer(This, &_StubMsg);
02424
02425 }
02426 RpcEndFinally
02427
02428 }
02429 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
02430 {
02431 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
02432 }
02433 RpcEndExcept
02434 return _RetVal;
02435 }
02436
02437 void __RPC_STUB IWGUrlReceiver_put_PostData_Stub(
02438 IRpcStubBuffer *This,
02439 IRpcChannelBuffer *_pRpcChannelBuffer,
02440 PRPC_MESSAGE _pRpcMessage,
02441 DWORD *_pdwStubPhase)
02442 {
02443 HRESULT _RetVal;
02444 MIDL_STUB_MESSAGE _StubMsg;
02445 void __RPC_FAR *_p_newVal;
02446 BSTR newVal;
02447
02448 NdrStubInitialize(
02449 _pRpcMessage,
02450 &_StubMsg,
02451 &Object_StubDesc,
02452 _pRpcChannelBuffer);
02453 _p_newVal = &newVal;
02454 MIDL_memset(
02455 _p_newVal,
02456 0,
02457 sizeof( BSTR ));
02458 RpcTryFinally
02459 {
02460 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
02461 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
02462
02463 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
02464 (unsigned char __RPC_FAR * __RPC_FAR *)&_p_newVal,
02465 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44],
02466 (unsigned char)0 );
02467
02468
02469 *_pdwStubPhase = STUB_CALL_SERVER;
02470 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_PostData((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
02471
02472 *_pdwStubPhase = STUB_MARSHAL;
02473
02474 _StubMsg.BufferLength = 4U;
02475 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
02476 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
02477
02478 }
02479 RpcFinally
02480 {
02481 NdrUserMarshalFree( &_StubMsg,
02482 (unsigned char __RPC_FAR *)&newVal,
02483 &__MIDL_TypeFormatString.Format[44] );
02484
02485 }
02486 RpcEndFinally
02487 _pRpcMessage->BufferLength =
02488 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
02489
02490 }
02491
02492
02493 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_get_ForceSilentEx_Proxy(
02494 IWGUrlReceiver __RPC_FAR * This,
02495 BOOL __RPC_FAR *pVal)
02496 {
02497
02498 HRESULT _RetVal;
02499
02500 RPC_MESSAGE _RpcMessage;
02501
02502 MIDL_STUB_MESSAGE _StubMsg;
02503
02504 RpcTryExcept
02505 {
02506 NdrProxyInitialize(
02507 ( void __RPC_FAR * )This,
02508 ( PRPC_MESSAGE )&_RpcMessage,
02509 ( PMIDL_STUB_MESSAGE )&_StubMsg,
02510 ( PMIDL_STUB_DESC )&Object_StubDesc,
02511 29);
02512
02513
02514
02515 if(!pVal)
02516 {
02517 RpcRaiseException(RPC_X_NULL_REF_POINTER);
02518 }
02519 RpcTryFinally
02520 {
02521
02522 _StubMsg.BufferLength = 0U;
02523 NdrProxyGetBuffer(This, &_StubMsg);
02524 NdrProxySendReceive(This, &_StubMsg);
02525
02526 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
02527 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[14] );
02528
02529 *pVal = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
02530
02531 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
02532
02533 }
02534 RpcFinally
02535 {
02536 NdrProxyFreeBuffer(This, &_StubMsg);
02537
02538 }
02539 RpcEndFinally
02540
02541 }
02542 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
02543 {
02544 NdrClearOutParameters(
02545 ( PMIDL_STUB_MESSAGE )&_StubMsg,
02546 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[54],
02547 ( void __RPC_FAR * )pVal);
02548 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
02549 }
02550 RpcEndExcept
02551 return _RetVal;
02552 }
02553
02554 void __RPC_STUB IWGUrlReceiver_get_ForceSilentEx_Stub(
02555 IRpcStubBuffer *This,
02556 IRpcChannelBuffer *_pRpcChannelBuffer,
02557 PRPC_MESSAGE _pRpcMessage,
02558 DWORD *_pdwStubPhase)
02559 {
02560 BOOL _M10;
02561 HRESULT _RetVal;
02562 MIDL_STUB_MESSAGE _StubMsg;
02563 BOOL __RPC_FAR *pVal;
02564
02565 NdrStubInitialize(
02566 _pRpcMessage,
02567 &_StubMsg,
02568 &Object_StubDesc,
02569 _pRpcChannelBuffer);
02570 ( BOOL __RPC_FAR * )pVal = 0;
02571 RpcTryFinally
02572 {
02573 pVal = &_M10;
02574
02575 *_pdwStubPhase = STUB_CALL_SERVER;
02576 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_ForceSilentEx((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,pVal);
02577
02578 *_pdwStubPhase = STUB_MARSHAL;
02579
02580 _StubMsg.BufferLength = 4U + 4U;
02581 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
02582 *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = *pVal;
02583
02584 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
02585
02586 }
02587 RpcFinally
02588 {
02589 }
02590 RpcEndFinally
02591 _pRpcMessage->BufferLength =
02592 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
02593
02594 }
02595
02596
02597 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_put_ForceSilentEx_Proxy(
02598 IWGUrlReceiver __RPC_FAR * This,
02599 BOOL newVal)
02600 {
02601
02602 HRESULT _RetVal;
02603
02604 RPC_MESSAGE _RpcMessage;
02605
02606 MIDL_STUB_MESSAGE _StubMsg;
02607
02608 RpcTryExcept
02609 {
02610 NdrProxyInitialize(
02611 ( void __RPC_FAR * )This,
02612 ( PRPC_MESSAGE )&_RpcMessage,
02613 ( PMIDL_STUB_MESSAGE )&_StubMsg,
02614 ( PMIDL_STUB_DESC )&Object_StubDesc,
02615 30);
02616
02617
02618
02619 RpcTryFinally
02620 {
02621
02622 _StubMsg.BufferLength = 4U;
02623 NdrProxyGetBuffer(This, &_StubMsg);
02624 *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = newVal;
02625
02626 NdrProxySendReceive(This, &_StubMsg);
02627
02628 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
02629 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
02630
02631 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
02632
02633 }
02634 RpcFinally
02635 {
02636 NdrProxyFreeBuffer(This, &_StubMsg);
02637
02638 }
02639 RpcEndFinally
02640
02641 }
02642 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
02643 {
02644 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
02645 }
02646 RpcEndExcept
02647 return _RetVal;
02648 }
02649
02650 void __RPC_STUB IWGUrlReceiver_put_ForceSilentEx_Stub(
02651 IRpcStubBuffer *This,
02652 IRpcChannelBuffer *_pRpcChannelBuffer,
02653 PRPC_MESSAGE _pRpcMessage,
02654 DWORD *_pdwStubPhase)
02655 {
02656 HRESULT _RetVal;
02657 MIDL_STUB_MESSAGE _StubMsg;
02658 BOOL newVal;
02659
02660 NdrStubInitialize(
02661 _pRpcMessage,
02662 &_StubMsg,
02663 &Object_StubDesc,
02664 _pRpcChannelBuffer);
02665 RpcTryFinally
02666 {
02667 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
02668 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
02669
02670 newVal = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
02671
02672
02673 *_pdwStubPhase = STUB_CALL_SERVER;
02674 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_ForceSilentEx((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
02675
02676 *_pdwStubPhase = STUB_MARSHAL;
02677
02678 _StubMsg.BufferLength = 4U;
02679 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
02680 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
02681
02682 }
02683 RpcFinally
02684 {
02685 }
02686 RpcEndFinally
02687 _pRpcMessage->BufferLength =
02688 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
02689
02690 }
02691
02692
02693 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_get_ForceDownloadAutoStart_Proxy(
02694 IWGUrlReceiver __RPC_FAR * This,
02695 BOOL __RPC_FAR *pVal)
02696 {
02697
02698 HRESULT _RetVal;
02699
02700 RPC_MESSAGE _RpcMessage;
02701
02702 MIDL_STUB_MESSAGE _StubMsg;
02703
02704 RpcTryExcept
02705 {
02706 NdrProxyInitialize(
02707 ( void __RPC_FAR * )This,
02708 ( PRPC_MESSAGE )&_RpcMessage,
02709 ( PMIDL_STUB_MESSAGE )&_StubMsg,
02710 ( PMIDL_STUB_DESC )&Object_StubDesc,
02711 31);
02712
02713
02714
02715 if(!pVal)
02716 {
02717 RpcRaiseException(RPC_X_NULL_REF_POINTER);
02718 }
02719 RpcTryFinally
02720 {
02721
02722 _StubMsg.BufferLength = 0U;
02723 NdrProxyGetBuffer(This, &_StubMsg);
02724 NdrProxySendReceive(This, &_StubMsg);
02725
02726 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
02727 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[14] );
02728
02729 *pVal = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
02730
02731 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
02732
02733 }
02734 RpcFinally
02735 {
02736 NdrProxyFreeBuffer(This, &_StubMsg);
02737
02738 }
02739 RpcEndFinally
02740
02741 }
02742 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
02743 {
02744 NdrClearOutParameters(
02745 ( PMIDL_STUB_MESSAGE )&_StubMsg,
02746 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[54],
02747 ( void __RPC_FAR * )pVal);
02748 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
02749 }
02750 RpcEndExcept
02751 return _RetVal;
02752 }
02753
02754 void __RPC_STUB IWGUrlReceiver_get_ForceDownloadAutoStart_Stub(
02755 IRpcStubBuffer *This,
02756 IRpcChannelBuffer *_pRpcChannelBuffer,
02757 PRPC_MESSAGE _pRpcMessage,
02758 DWORD *_pdwStubPhase)
02759 {
02760 BOOL _M11;
02761 HRESULT _RetVal;
02762 MIDL_STUB_MESSAGE _StubMsg;
02763 BOOL __RPC_FAR *pVal;
02764
02765 NdrStubInitialize(
02766 _pRpcMessage,
02767 &_StubMsg,
02768 &Object_StubDesc,
02769 _pRpcChannelBuffer);
02770 ( BOOL __RPC_FAR * )pVal = 0;
02771 RpcTryFinally
02772 {
02773 pVal = &_M11;
02774
02775 *_pdwStubPhase = STUB_CALL_SERVER;
02776 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_ForceDownloadAutoStart((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,pVal);
02777
02778 *_pdwStubPhase = STUB_MARSHAL;
02779
02780 _StubMsg.BufferLength = 4U + 4U;
02781 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
02782 *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = *pVal;
02783
02784 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
02785
02786 }
02787 RpcFinally
02788 {
02789 }
02790 RpcEndFinally
02791 _pRpcMessage->BufferLength =
02792 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
02793
02794 }
02795
02796
02797 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_put_ForceDownloadAutoStart_Proxy(
02798 IWGUrlReceiver __RPC_FAR * This,
02799 BOOL newVal)
02800 {
02801
02802 HRESULT _RetVal;
02803
02804 RPC_MESSAGE _RpcMessage;
02805
02806 MIDL_STUB_MESSAGE _StubMsg;
02807
02808 RpcTryExcept
02809 {
02810 NdrProxyInitialize(
02811 ( void __RPC_FAR * )This,
02812 ( PRPC_MESSAGE )&_RpcMessage,
02813 ( PMIDL_STUB_MESSAGE )&_StubMsg,
02814 ( PMIDL_STUB_DESC )&Object_StubDesc,
02815 32);
02816
02817
02818
02819 RpcTryFinally
02820 {
02821
02822 _StubMsg.BufferLength = 4U;
02823 NdrProxyGetBuffer(This, &_StubMsg);
02824 *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = newVal;
02825
02826 NdrProxySendReceive(This, &_StubMsg);
02827
02828 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
02829 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
02830
02831 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
02832
02833 }
02834 RpcFinally
02835 {
02836 NdrProxyFreeBuffer(This, &_StubMsg);
02837
02838 }
02839 RpcEndFinally
02840
02841 }
02842 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
02843 {
02844 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
02845 }
02846 RpcEndExcept
02847 return _RetVal;
02848 }
02849
02850 void __RPC_STUB IWGUrlReceiver_put_ForceDownloadAutoStart_Stub(
02851 IRpcStubBuffer *This,
02852 IRpcChannelBuffer *_pRpcChannelBuffer,
02853 PRPC_MESSAGE _pRpcMessage,
02854 DWORD *_pdwStubPhase)
02855 {
02856 HRESULT _RetVal;
02857 MIDL_STUB_MESSAGE _StubMsg;
02858 BOOL newVal;
02859
02860 NdrStubInitialize(
02861 _pRpcMessage,
02862 &_StubMsg,
02863 &Object_StubDesc,
02864 _pRpcChannelBuffer);
02865 RpcTryFinally
02866 {
02867 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
02868 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
02869
02870 newVal = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
02871
02872
02873 *_pdwStubPhase = STUB_CALL_SERVER;
02874 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_ForceDownloadAutoStart((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
02875
02876 *_pdwStubPhase = STUB_MARSHAL;
02877
02878 _StubMsg.BufferLength = 4U;
02879 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
02880 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
02881
02882 }
02883 RpcFinally
02884 {
02885 }
02886 RpcEndFinally
02887 _pRpcMessage->BufferLength =
02888 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
02889
02890 }
02891
02892
02893 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_get_DisableMaliciousChecking_Proxy(
02894 IWGUrlReceiver __RPC_FAR * This,
02895 BOOL __RPC_FAR *pVal)
02896 {
02897
02898 HRESULT _RetVal;
02899
02900 RPC_MESSAGE _RpcMessage;
02901
02902 MIDL_STUB_MESSAGE _StubMsg;
02903
02904 RpcTryExcept
02905 {
02906 NdrProxyInitialize(
02907 ( void __RPC_FAR * )This,
02908 ( PRPC_MESSAGE )&_RpcMessage,
02909 ( PMIDL_STUB_MESSAGE )&_StubMsg,
02910 ( PMIDL_STUB_DESC )&Object_StubDesc,
02911 33);
02912
02913
02914
02915 if(!pVal)
02916 {
02917 RpcRaiseException(RPC_X_NULL_REF_POINTER);
02918 }
02919 RpcTryFinally
02920 {
02921
02922 _StubMsg.BufferLength = 0U;
02923 NdrProxyGetBuffer(This, &_StubMsg);
02924 NdrProxySendReceive(This, &_StubMsg);
02925
02926 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
02927 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[14] );
02928
02929 *pVal = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
02930
02931 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
02932
02933 }
02934 RpcFinally
02935 {
02936 NdrProxyFreeBuffer(This, &_StubMsg);
02937
02938 }
02939 RpcEndFinally
02940
02941 }
02942 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
02943 {
02944 NdrClearOutParameters(
02945 ( PMIDL_STUB_MESSAGE )&_StubMsg,
02946 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[54],
02947 ( void __RPC_FAR * )pVal);
02948 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
02949 }
02950 RpcEndExcept
02951 return _RetVal;
02952 }
02953
02954 void __RPC_STUB IWGUrlReceiver_get_DisableMaliciousChecking_Stub(
02955 IRpcStubBuffer *This,
02956 IRpcChannelBuffer *_pRpcChannelBuffer,
02957 PRPC_MESSAGE _pRpcMessage,
02958 DWORD *_pdwStubPhase)
02959 {
02960 BOOL _M12;
02961 HRESULT _RetVal;
02962 MIDL_STUB_MESSAGE _StubMsg;
02963 BOOL __RPC_FAR *pVal;
02964
02965 NdrStubInitialize(
02966 _pRpcMessage,
02967 &_StubMsg,
02968 &Object_StubDesc,
02969 _pRpcChannelBuffer);
02970 ( BOOL __RPC_FAR * )pVal = 0;
02971 RpcTryFinally
02972 {
02973 pVal = &_M12;
02974
02975 *_pdwStubPhase = STUB_CALL_SERVER;
02976 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_DisableMaliciousChecking((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,pVal);
02977
02978 *_pdwStubPhase = STUB_MARSHAL;
02979
02980 _StubMsg.BufferLength = 4U + 4U;
02981 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
02982 *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = *pVal;
02983
02984 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
02985
02986 }
02987 RpcFinally
02988 {
02989 }
02990 RpcEndFinally
02991 _pRpcMessage->BufferLength =
02992 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
02993
02994 }
02995
02996
02997 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_put_DisableMaliciousChecking_Proxy(
02998 IWGUrlReceiver __RPC_FAR * This,
02999 BOOL newVal)
03000 {
03001
03002 HRESULT _RetVal;
03003
03004 RPC_MESSAGE _RpcMessage;
03005
03006 MIDL_STUB_MESSAGE _StubMsg;
03007
03008 RpcTryExcept
03009 {
03010 NdrProxyInitialize(
03011 ( void __RPC_FAR * )This,
03012 ( PRPC_MESSAGE )&_RpcMessage,
03013 ( PMIDL_STUB_MESSAGE )&_StubMsg,
03014 ( PMIDL_STUB_DESC )&Object_StubDesc,
03015 34);
03016
03017
03018
03019 RpcTryFinally
03020 {
03021
03022 _StubMsg.BufferLength = 4U;
03023 NdrProxyGetBuffer(This, &_StubMsg);
03024 *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = newVal;
03025
03026 NdrProxySendReceive(This, &_StubMsg);
03027
03028 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
03029 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
03030
03031 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
03032
03033 }
03034 RpcFinally
03035 {
03036 NdrProxyFreeBuffer(This, &_StubMsg);
03037
03038 }
03039 RpcEndFinally
03040
03041 }
03042 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
03043 {
03044 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
03045 }
03046 RpcEndExcept
03047 return _RetVal;
03048 }
03049
03050 void __RPC_STUB IWGUrlReceiver_put_DisableMaliciousChecking_Stub(
03051 IRpcStubBuffer *This,
03052 IRpcChannelBuffer *_pRpcChannelBuffer,
03053 PRPC_MESSAGE _pRpcMessage,
03054 DWORD *_pdwStubPhase)
03055 {
03056 HRESULT _RetVal;
03057 MIDL_STUB_MESSAGE _StubMsg;
03058 BOOL newVal;
03059
03060 NdrStubInitialize(
03061 _pRpcMessage,
03062 &_StubMsg,
03063 &Object_StubDesc,
03064 _pRpcChannelBuffer);
03065 RpcTryFinally
03066 {
03067 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
03068 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
03069
03070 newVal = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
03071
03072
03073 *_pdwStubPhase = STUB_CALL_SERVER;
03074 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_DisableMaliciousChecking((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
03075
03076 *_pdwStubPhase = STUB_MARSHAL;
03077
03078 _StubMsg.BufferLength = 4U;
03079 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
03080 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
03081
03082 }
03083 RpcFinally
03084 {
03085 }
03086 RpcEndFinally
03087 _pRpcMessage->BufferLength =
03088 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
03089
03090 }
03091
03092
03093 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_get_DisableURLExistsCheck_Proxy(
03094 IWGUrlReceiver __RPC_FAR * This,
03095 BOOL __RPC_FAR *pVal)
03096 {
03097
03098 HRESULT _RetVal;
03099
03100 RPC_MESSAGE _RpcMessage;
03101
03102 MIDL_STUB_MESSAGE _StubMsg;
03103
03104 RpcTryExcept
03105 {
03106 NdrProxyInitialize(
03107 ( void __RPC_FAR * )This,
03108 ( PRPC_MESSAGE )&_RpcMessage,
03109 ( PMIDL_STUB_MESSAGE )&_StubMsg,
03110 ( PMIDL_STUB_DESC )&Object_StubDesc,
03111 35);
03112
03113
03114
03115 if(!pVal)
03116 {
03117 RpcRaiseException(RPC_X_NULL_REF_POINTER);
03118 }
03119 RpcTryFinally
03120 {
03121
03122 _StubMsg.BufferLength = 0U;
03123 NdrProxyGetBuffer(This, &_StubMsg);
03124 NdrProxySendReceive(This, &_StubMsg);
03125
03126 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
03127 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[14] );
03128
03129 *pVal = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
03130
03131 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
03132
03133 }
03134 RpcFinally
03135 {
03136 NdrProxyFreeBuffer(This, &_StubMsg);
03137
03138 }
03139 RpcEndFinally
03140
03141 }
03142 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
03143 {
03144 NdrClearOutParameters(
03145 ( PMIDL_STUB_MESSAGE )&_StubMsg,
03146 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[54],
03147 ( void __RPC_FAR * )pVal);
03148 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
03149 }
03150 RpcEndExcept
03151 return _RetVal;
03152 }
03153
03154 void __RPC_STUB IWGUrlReceiver_get_DisableURLExistsCheck_Stub(
03155 IRpcStubBuffer *This,
03156 IRpcChannelBuffer *_pRpcChannelBuffer,
03157 PRPC_MESSAGE _pRpcMessage,
03158 DWORD *_pdwStubPhase)
03159 {
03160 BOOL _M13;
03161 HRESULT _RetVal;
03162 MIDL_STUB_MESSAGE _StubMsg;
03163 BOOL __RPC_FAR *pVal;
03164
03165 NdrStubInitialize(
03166 _pRpcMessage,
03167 &_StubMsg,
03168 &Object_StubDesc,
03169 _pRpcChannelBuffer);
03170 ( BOOL __RPC_FAR * )pVal = 0;
03171 RpcTryFinally
03172 {
03173 pVal = &_M13;
03174
03175 *_pdwStubPhase = STUB_CALL_SERVER;
03176 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_DisableURLExistsCheck((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,pVal);
03177
03178 *_pdwStubPhase = STUB_MARSHAL;
03179
03180 _StubMsg.BufferLength = 4U + 4U;
03181 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
03182 *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = *pVal;
03183
03184 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
03185
03186 }
03187 RpcFinally
03188 {
03189 }
03190 RpcEndFinally
03191 _pRpcMessage->BufferLength =
03192 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
03193
03194 }
03195
03196
03197 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_put_DisableURLExistsCheck_Proxy(
03198 IWGUrlReceiver __RPC_FAR * This,
03199 BOOL newVal)
03200 {
03201
03202 HRESULT _RetVal;
03203
03204 RPC_MESSAGE _RpcMessage;
03205
03206 MIDL_STUB_MESSAGE _StubMsg;
03207
03208 RpcTryExcept
03209 {
03210 NdrProxyInitialize(
03211 ( void __RPC_FAR * )This,
03212 ( PRPC_MESSAGE )&_RpcMessage,
03213 ( PMIDL_STUB_MESSAGE )&_StubMsg,
03214 ( PMIDL_STUB_DESC )&Object_StubDesc,
03215 36);
03216
03217
03218
03219 RpcTryFinally
03220 {
03221
03222 _StubMsg.BufferLength = 4U;
03223 NdrProxyGetBuffer(This, &_StubMsg);
03224 *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = newVal;
03225
03226 NdrProxySendReceive(This, &_StubMsg);
03227
03228 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
03229 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
03230
03231 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
03232
03233 }
03234 RpcFinally
03235 {
03236 NdrProxyFreeBuffer(This, &_StubMsg);
03237
03238 }
03239 RpcEndFinally
03240
03241 }
03242 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
03243 {
03244 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
03245 }
03246 RpcEndExcept
03247 return _RetVal;
03248 }
03249
03250 void __RPC_STUB IWGUrlReceiver_put_DisableURLExistsCheck_Stub(
03251 IRpcStubBuffer *This,
03252 IRpcChannelBuffer *_pRpcChannelBuffer,
03253 PRPC_MESSAGE _pRpcMessage,
03254 DWORD *_pdwStubPhase)
03255 {
03256 HRESULT _RetVal;
03257 MIDL_STUB_MESSAGE _StubMsg;
03258 BOOL newVal;
03259
03260 NdrStubInitialize(
03261 _pRpcMessage,
03262 &_StubMsg,
03263 &Object_StubDesc,
03264 _pRpcChannelBuffer);
03265 RpcTryFinally
03266 {
03267 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
03268 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
03269
03270 newVal = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
03271
03272
03273 *_pdwStubPhase = STUB_CALL_SERVER;
03274 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_DisableURLExistsCheck((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
03275
03276 *_pdwStubPhase = STUB_MARSHAL;
03277
03278 _StubMsg.BufferLength = 4U;
03279 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
03280 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
03281
03282 }
03283 RpcFinally
03284 {
03285 }
03286 RpcEndFinally
03287 _pRpcMessage->BufferLength =
03288 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
03289
03290 }
03291
03292
03293 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_get_FileName_Proxy(
03294 IWGUrlReceiver __RPC_FAR * This,
03295 BSTR __RPC_FAR *pVal)
03296 {
03297
03298 HRESULT _RetVal;
03299
03300 RPC_MESSAGE _RpcMessage;
03301
03302 MIDL_STUB_MESSAGE _StubMsg;
03303
03304 if(pVal)
03305 {
03306 MIDL_memset(
03307 pVal,
03308 0,
03309 sizeof( BSTR ));
03310 }
03311 RpcTryExcept
03312 {
03313 NdrProxyInitialize(
03314 ( void __RPC_FAR * )This,
03315 ( PRPC_MESSAGE )&_RpcMessage,
03316 ( PMIDL_STUB_MESSAGE )&_StubMsg,
03317 ( PMIDL_STUB_DESC )&Object_StubDesc,
03318 37);
03319
03320
03321
03322 if(!pVal)
03323 {
03324 RpcRaiseException(RPC_X_NULL_REF_POINTER);
03325 }
03326 RpcTryFinally
03327 {
03328
03329 _StubMsg.BufferLength = 0U;
03330 NdrProxyGetBuffer(This, &_StubMsg);
03331 NdrProxySendReceive(This, &_StubMsg);
03332
03333 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
03334 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
03335
03336 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
03337 (unsigned char __RPC_FAR * __RPC_FAR *)&pVal,
03338 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30],
03339 (unsigned char)0 );
03340
03341 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
03342 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
03343
03344 }
03345 RpcFinally
03346 {
03347 NdrProxyFreeBuffer(This, &_StubMsg);
03348
03349 }
03350 RpcEndFinally
03351
03352 }
03353 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
03354 {
03355 NdrClearOutParameters(
03356 ( PMIDL_STUB_MESSAGE )&_StubMsg,
03357 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[2],
03358 ( void __RPC_FAR * )pVal);
03359 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
03360 }
03361 RpcEndExcept
03362 return _RetVal;
03363 }
03364
03365 void __RPC_STUB IWGUrlReceiver_get_FileName_Stub(
03366 IRpcStubBuffer *This,
03367 IRpcChannelBuffer *_pRpcChannelBuffer,
03368 PRPC_MESSAGE _pRpcMessage,
03369 DWORD *_pdwStubPhase)
03370 {
03371 BSTR _M14;
03372 HRESULT _RetVal;
03373 MIDL_STUB_MESSAGE _StubMsg;
03374 BSTR __RPC_FAR *pVal;
03375
03376 NdrStubInitialize(
03377 _pRpcMessage,
03378 &_StubMsg,
03379 &Object_StubDesc,
03380 _pRpcChannelBuffer);
03381 ( BSTR __RPC_FAR * )pVal = 0;
03382 RpcTryFinally
03383 {
03384 pVal = &_M14;
03385 MIDL_memset(
03386 pVal,
03387 0,
03388 sizeof( BSTR ));
03389
03390 *_pdwStubPhase = STUB_CALL_SERVER;
03391 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_FileName((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,pVal);
03392
03393 *_pdwStubPhase = STUB_MARSHAL;
03394
03395 _StubMsg.BufferLength = 8U + 11U;
03396 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
03397 (unsigned char __RPC_FAR *)pVal,
03398 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
03399
03400 _StubMsg.BufferLength += 16;
03401
03402 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
03403 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
03404 (unsigned char __RPC_FAR *)pVal,
03405 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
03406
03407 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
03408 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
03409
03410 }
03411 RpcFinally
03412 {
03413 NdrPointerFree( &_StubMsg,
03414 (unsigned char __RPC_FAR *)pVal,
03415 &__MIDL_TypeFormatString.Format[2] );
03416
03417 }
03418 RpcEndFinally
03419 _pRpcMessage->BufferLength =
03420 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
03421
03422 }
03423
03424
03425 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_put_FileName_Proxy(
03426 IWGUrlReceiver __RPC_FAR * This,
03427 BSTR newVal)
03428 {
03429
03430 HRESULT _RetVal;
03431
03432 RPC_MESSAGE _RpcMessage;
03433
03434 MIDL_STUB_MESSAGE _StubMsg;
03435
03436 RpcTryExcept
03437 {
03438 NdrProxyInitialize(
03439 ( void __RPC_FAR * )This,
03440 ( PRPC_MESSAGE )&_RpcMessage,
03441 ( PMIDL_STUB_MESSAGE )&_StubMsg,
03442 ( PMIDL_STUB_DESC )&Object_StubDesc,
03443 38);
03444
03445
03446
03447 RpcTryFinally
03448 {
03449
03450 _StubMsg.BufferLength = 8U;
03451 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
03452 (unsigned char __RPC_FAR *)&newVal,
03453 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
03454
03455 NdrProxyGetBuffer(This, &_StubMsg);
03456 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
03457 (unsigned char __RPC_FAR *)&newVal,
03458 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
03459
03460 NdrProxySendReceive(This, &_StubMsg);
03461
03462 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
03463 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
03464
03465 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
03466
03467 }
03468 RpcFinally
03469 {
03470 NdrProxyFreeBuffer(This, &_StubMsg);
03471
03472 }
03473 RpcEndFinally
03474
03475 }
03476 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
03477 {
03478 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
03479 }
03480 RpcEndExcept
03481 return _RetVal;
03482 }
03483
03484 void __RPC_STUB IWGUrlReceiver_put_FileName_Stub(
03485 IRpcStubBuffer *This,
03486 IRpcChannelBuffer *_pRpcChannelBuffer,
03487 PRPC_MESSAGE _pRpcMessage,
03488 DWORD *_pdwStubPhase)
03489 {
03490 HRESULT _RetVal;
03491 MIDL_STUB_MESSAGE _StubMsg;
03492 void __RPC_FAR *_p_newVal;
03493 BSTR newVal;
03494
03495 NdrStubInitialize(
03496 _pRpcMessage,
03497 &_StubMsg,
03498 &Object_StubDesc,
03499 _pRpcChannelBuffer);
03500 _p_newVal = &newVal;
03501 MIDL_memset(
03502 _p_newVal,
03503 0,
03504 sizeof( BSTR ));
03505 RpcTryFinally
03506 {
03507 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
03508 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
03509
03510 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
03511 (unsigned char __RPC_FAR * __RPC_FAR *)&_p_newVal,
03512 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44],
03513 (unsigned char)0 );
03514
03515
03516 *_pdwStubPhase = STUB_CALL_SERVER;
03517 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_FileName((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
03518
03519 *_pdwStubPhase = STUB_MARSHAL;
03520
03521 _StubMsg.BufferLength = 4U;
03522 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
03523 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
03524
03525 }
03526 RpcFinally
03527 {
03528 NdrUserMarshalFree( &_StubMsg,
03529 (unsigned char __RPC_FAR *)&newVal,
03530 &__MIDL_TypeFormatString.Format[44] );
03531
03532 }
03533 RpcEndFinally
03534 _pRpcMessage->BufferLength =
03535 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
03536
03537 }
03538
03539
03540 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_get_FlashVideoDownload_Proxy(
03541 IWGUrlReceiver __RPC_FAR * This,
03542 BOOL __RPC_FAR *pVal)
03543 {
03544
03545 HRESULT _RetVal;
03546
03547 RPC_MESSAGE _RpcMessage;
03548
03549 MIDL_STUB_MESSAGE _StubMsg;
03550
03551 RpcTryExcept
03552 {
03553 NdrProxyInitialize(
03554 ( void __RPC_FAR * )This,
03555 ( PRPC_MESSAGE )&_RpcMessage,
03556 ( PMIDL_STUB_MESSAGE )&_StubMsg,
03557 ( PMIDL_STUB_DESC )&Object_StubDesc,
03558 39);
03559
03560
03561
03562 if(!pVal)
03563 {
03564 RpcRaiseException(RPC_X_NULL_REF_POINTER);
03565 }
03566 RpcTryFinally
03567 {
03568
03569 _StubMsg.BufferLength = 0U;
03570 NdrProxyGetBuffer(This, &_StubMsg);
03571 NdrProxySendReceive(This, &_StubMsg);
03572
03573 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
03574 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[14] );
03575
03576 *pVal = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
03577
03578 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
03579
03580 }
03581 RpcFinally
03582 {
03583 NdrProxyFreeBuffer(This, &_StubMsg);
03584
03585 }
03586 RpcEndFinally
03587
03588 }
03589 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
03590 {
03591 NdrClearOutParameters(
03592 ( PMIDL_STUB_MESSAGE )&_StubMsg,
03593 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[54],
03594 ( void __RPC_FAR * )pVal);
03595 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
03596 }
03597 RpcEndExcept
03598 return _RetVal;
03599 }
03600
03601 void __RPC_STUB IWGUrlReceiver_get_FlashVideoDownload_Stub(
03602 IRpcStubBuffer *This,
03603 IRpcChannelBuffer *_pRpcChannelBuffer,
03604 PRPC_MESSAGE _pRpcMessage,
03605 DWORD *_pdwStubPhase)
03606 {
03607 BOOL _M15;
03608 HRESULT _RetVal;
03609 MIDL_STUB_MESSAGE _StubMsg;
03610 BOOL __RPC_FAR *pVal;
03611
03612 NdrStubInitialize(
03613 _pRpcMessage,
03614 &_StubMsg,
03615 &Object_StubDesc,
03616 _pRpcChannelBuffer);
03617 ( BOOL __RPC_FAR * )pVal = 0;
03618 RpcTryFinally
03619 {
03620 pVal = &_M15;
03621
03622 *_pdwStubPhase = STUB_CALL_SERVER;
03623 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_FlashVideoDownload((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,pVal);
03624
03625 *_pdwStubPhase = STUB_MARSHAL;
03626
03627 _StubMsg.BufferLength = 4U + 4U;
03628 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
03629 *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = *pVal;
03630
03631 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
03632
03633 }
03634 RpcFinally
03635 {
03636 }
03637 RpcEndFinally
03638 _pRpcMessage->BufferLength =
03639 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
03640
03641 }
03642
03643
03644 HRESULT STDMETHODCALLTYPE IWGUrlReceiver_put_FlashVideoDownload_Proxy(
03645 IWGUrlReceiver __RPC_FAR * This,
03646 BOOL newVal)
03647 {
03648
03649 HRESULT _RetVal;
03650
03651 RPC_MESSAGE _RpcMessage;
03652
03653 MIDL_STUB_MESSAGE _StubMsg;
03654
03655 RpcTryExcept
03656 {
03657 NdrProxyInitialize(
03658 ( void __RPC_FAR * )This,
03659 ( PRPC_MESSAGE )&_RpcMessage,
03660 ( PMIDL_STUB_MESSAGE )&_StubMsg,
03661 ( PMIDL_STUB_DESC )&Object_StubDesc,
03662 40);
03663
03664
03665
03666 RpcTryFinally
03667 {
03668
03669 _StubMsg.BufferLength = 4U;
03670 NdrProxyGetBuffer(This, &_StubMsg);
03671 *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = newVal;
03672
03673 NdrProxySendReceive(This, &_StubMsg);
03674
03675 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
03676 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
03677
03678 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
03679
03680 }
03681 RpcFinally
03682 {
03683 NdrProxyFreeBuffer(This, &_StubMsg);
03684
03685 }
03686 RpcEndFinally
03687
03688 }
03689 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
03690 {
03691 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
03692 }
03693 RpcEndExcept
03694 return _RetVal;
03695 }
03696
03697 void __RPC_STUB IWGUrlReceiver_put_FlashVideoDownload_Stub(
03698 IRpcStubBuffer *This,
03699 IRpcChannelBuffer *_pRpcChannelBuffer,
03700 PRPC_MESSAGE _pRpcMessage,
03701 DWORD *_pdwStubPhase)
03702 {
03703 HRESULT _RetVal;
03704 MIDL_STUB_MESSAGE _StubMsg;
03705 BOOL newVal;
03706
03707 NdrStubInitialize(
03708 _pRpcMessage,
03709 &_StubMsg,
03710 &Object_StubDesc,
03711 _pRpcChannelBuffer);
03712 RpcTryFinally
03713 {
03714 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
03715 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
03716
03717 newVal = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
03718
03719
03720 *_pdwStubPhase = STUB_CALL_SERVER;
03721 _RetVal = (((IWGUrlReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_FlashVideoDownload((IWGUrlReceiver *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
03722
03723 *_pdwStubPhase = STUB_MARSHAL;
03724
03725 _StubMsg.BufferLength = 4U;
03726 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
03727 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
03728
03729 }
03730 RpcFinally
03731 {
03732 }
03733 RpcEndFinally
03734 _pRpcMessage->BufferLength =
03735 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
03736
03737 }
03738
03739 CINTERFACE_PROXY_VTABLE(41) _IWGUrlReceiverProxyVtbl =
03740 {
03741 &IID_IWGUrlReceiver,
03742 IUnknown_QueryInterface_Proxy,
03743 IUnknown_AddRef_Proxy,
03744 IUnknown_Release_Proxy ,
03745 0 ,
03746 0 ,
03747 0 ,
03748 0 ,
03749 IWGUrlReceiver_get_Url_Proxy ,
03750 IWGUrlReceiver_put_Url_Proxy ,
03751 IWGUrlReceiver_ShowAddDownloadDialog_Proxy ,
03752 IWGUrlReceiver_ShowAddPageDownloadDialog_Proxy ,
03753 IWGUrlReceiver_get_Comment_Proxy ,
03754 IWGUrlReceiver_put_Comment_Proxy ,
03755 IWGUrlReceiver_get_Referer_Proxy ,
03756 IWGUrlReceiver_put_Referer_Proxy ,
03757 IWGUrlReceiver_AddDownload_Proxy ,
03758 IWGUrlReceiver_get_CheckExtension_Proxy ,
03759 IWGUrlReceiver_put_CheckExtension_Proxy ,
03760 IWGUrlReceiver_get_IgnoreSize_Proxy ,
03761 IWGUrlReceiver_put_IgnoreSize_Proxy ,
03762 IWGUrlReceiver_get_UseSkipExtsList_Proxy ,
03763 IWGUrlReceiver_put_UseSkipExtsList_Proxy ,
03764 IWGUrlReceiver_get_UIState_Proxy ,
03765 IWGUrlReceiver_get_ForceSilent_Proxy ,
03766 IWGUrlReceiver_put_ForceSilent_Proxy ,
03767 IWGUrlReceiver_get_Cookies_Proxy ,
03768 IWGUrlReceiver_put_Cookies_Proxy ,
03769 IWGUrlReceiver_get_PostData_Proxy ,
03770 IWGUrlReceiver_put_PostData_Proxy ,
03771 IWGUrlReceiver_get_ForceSilentEx_Proxy ,
03772 IWGUrlReceiver_put_ForceSilentEx_Proxy ,
03773 IWGUrlReceiver_get_ForceDownloadAutoStart_Proxy ,
03774 IWGUrlReceiver_put_ForceDownloadAutoStart_Proxy ,
03775 IWGUrlReceiver_get_DisableMaliciousChecking_Proxy ,
03776 IWGUrlReceiver_put_DisableMaliciousChecking_Proxy ,
03777 IWGUrlReceiver_get_DisableURLExistsCheck_Proxy ,
03778 IWGUrlReceiver_put_DisableURLExistsCheck_Proxy ,
03779 IWGUrlReceiver_get_FileName_Proxy ,
03780 IWGUrlReceiver_put_FileName_Proxy ,
03781 IWGUrlReceiver_get_FlashVideoDownload_Proxy ,
03782 IWGUrlReceiver_put_FlashVideoDownload_Proxy
03783 };
03784
03785
03786 static const PRPC_STUB_FUNCTION IWGUrlReceiver_table[] =
03787 {
03788 STUB_FORWARDING_FUNCTION,
03789 STUB_FORWARDING_FUNCTION,
03790 STUB_FORWARDING_FUNCTION,
03791 STUB_FORWARDING_FUNCTION,
03792 IWGUrlReceiver_get_Url_Stub,
03793 IWGUrlReceiver_put_Url_Stub,
03794 IWGUrlReceiver_ShowAddDownloadDialog_Stub,
03795 IWGUrlReceiver_ShowAddPageDownloadDialog_Stub,
03796 IWGUrlReceiver_get_Comment_Stub,
03797 IWGUrlReceiver_put_Comment_Stub,
03798 IWGUrlReceiver_get_Referer_Stub,
03799 IWGUrlReceiver_put_Referer_Stub,
03800 IWGUrlReceiver_AddDownload_Stub,
03801 IWGUrlReceiver_get_CheckExtension_Stub,
03802 IWGUrlReceiver_put_CheckExtension_Stub,
03803 IWGUrlReceiver_get_IgnoreSize_Stub,
03804 IWGUrlReceiver_put_IgnoreSize_Stub,
03805 IWGUrlReceiver_get_UseSkipExtsList_Stub,
03806 IWGUrlReceiver_put_UseSkipExtsList_Stub,
03807 IWGUrlReceiver_get_UIState_Stub,
03808 IWGUrlReceiver_get_ForceSilent_Stub,
03809 IWGUrlReceiver_put_ForceSilent_Stub,
03810 IWGUrlReceiver_get_Cookies_Stub,
03811 IWGUrlReceiver_put_Cookies_Stub,
03812 IWGUrlReceiver_get_PostData_Stub,
03813 IWGUrlReceiver_put_PostData_Stub,
03814 IWGUrlReceiver_get_ForceSilentEx_Stub,
03815 IWGUrlReceiver_put_ForceSilentEx_Stub,
03816 IWGUrlReceiver_get_ForceDownloadAutoStart_Stub,
03817 IWGUrlReceiver_put_ForceDownloadAutoStart_Stub,
03818 IWGUrlReceiver_get_DisableMaliciousChecking_Stub,
03819 IWGUrlReceiver_put_DisableMaliciousChecking_Stub,
03820 IWGUrlReceiver_get_DisableURLExistsCheck_Stub,
03821 IWGUrlReceiver_put_DisableURLExistsCheck_Stub,
03822 IWGUrlReceiver_get_FileName_Stub,
03823 IWGUrlReceiver_put_FileName_Stub,
03824 IWGUrlReceiver_get_FlashVideoDownload_Stub,
03825 IWGUrlReceiver_put_FlashVideoDownload_Stub
03826 };
03827
03828 CInterfaceStubVtbl _IWGUrlReceiverStubVtbl =
03829 {
03830 &IID_IWGUrlReceiver,
03831 0,
03832 41,
03833 &IWGUrlReceiver_table[-3],
03834 CStdStubBuffer_DELEGATING_METHODS
03835 };
03836
03837
03838
03839
03840
03841
03842 extern const MIDL_STUB_DESC Object_StubDesc;
03843
03844
03845 #pragma code_seg(".orpc")
03846
03847 HRESULT STDMETHODCALLTYPE IWGUrlListReceiver_get_Url_Proxy(
03848 IWGUrlListReceiver __RPC_FAR * This,
03849 BSTR __RPC_FAR *pVal)
03850 {
03851
03852 HRESULT _RetVal;
03853
03854 RPC_MESSAGE _RpcMessage;
03855
03856 MIDL_STUB_MESSAGE _StubMsg;
03857
03858 if(pVal)
03859 {
03860 MIDL_memset(
03861 pVal,
03862 0,
03863 sizeof( BSTR ));
03864 }
03865 RpcTryExcept
03866 {
03867 NdrProxyInitialize(
03868 ( void __RPC_FAR * )This,
03869 ( PRPC_MESSAGE )&_RpcMessage,
03870 ( PMIDL_STUB_MESSAGE )&_StubMsg,
03871 ( PMIDL_STUB_DESC )&Object_StubDesc,
03872 7);
03873
03874
03875
03876 if(!pVal)
03877 {
03878 RpcRaiseException(RPC_X_NULL_REF_POINTER);
03879 }
03880 RpcTryFinally
03881 {
03882
03883 _StubMsg.BufferLength = 0U;
03884 NdrProxyGetBuffer(This, &_StubMsg);
03885 NdrProxySendReceive(This, &_StubMsg);
03886
03887 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
03888 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
03889
03890 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
03891 (unsigned char __RPC_FAR * __RPC_FAR *)&pVal,
03892 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30],
03893 (unsigned char)0 );
03894
03895 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
03896 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
03897
03898 }
03899 RpcFinally
03900 {
03901 NdrProxyFreeBuffer(This, &_StubMsg);
03902
03903 }
03904 RpcEndFinally
03905
03906 }
03907 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
03908 {
03909 NdrClearOutParameters(
03910 ( PMIDL_STUB_MESSAGE )&_StubMsg,
03911 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[2],
03912 ( void __RPC_FAR * )pVal);
03913 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
03914 }
03915 RpcEndExcept
03916 return _RetVal;
03917 }
03918
03919 void __RPC_STUB IWGUrlListReceiver_get_Url_Stub(
03920 IRpcStubBuffer *This,
03921 IRpcChannelBuffer *_pRpcChannelBuffer,
03922 PRPC_MESSAGE _pRpcMessage,
03923 DWORD *_pdwStubPhase)
03924 {
03925 BSTR _M16;
03926 HRESULT _RetVal;
03927 MIDL_STUB_MESSAGE _StubMsg;
03928 BSTR __RPC_FAR *pVal;
03929
03930 NdrStubInitialize(
03931 _pRpcMessage,
03932 &_StubMsg,
03933 &Object_StubDesc,
03934 _pRpcChannelBuffer);
03935 ( BSTR __RPC_FAR * )pVal = 0;
03936 RpcTryFinally
03937 {
03938 pVal = &_M16;
03939 MIDL_memset(
03940 pVal,
03941 0,
03942 sizeof( BSTR ));
03943
03944 *_pdwStubPhase = STUB_CALL_SERVER;
03945 _RetVal = (((IWGUrlListReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_Url((IWGUrlListReceiver *) ((CStdStubBuffer *)This)->pvServerObject,pVal);
03946
03947 *_pdwStubPhase = STUB_MARSHAL;
03948
03949 _StubMsg.BufferLength = 8U + 11U;
03950 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
03951 (unsigned char __RPC_FAR *)pVal,
03952 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
03953
03954 _StubMsg.BufferLength += 16;
03955
03956 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
03957 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
03958 (unsigned char __RPC_FAR *)pVal,
03959 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
03960
03961 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
03962 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
03963
03964 }
03965 RpcFinally
03966 {
03967 NdrPointerFree( &_StubMsg,
03968 (unsigned char __RPC_FAR *)pVal,
03969 &__MIDL_TypeFormatString.Format[2] );
03970
03971 }
03972 RpcEndFinally
03973 _pRpcMessage->BufferLength =
03974 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
03975
03976 }
03977
03978
03979 HRESULT STDMETHODCALLTYPE IWGUrlListReceiver_put_Url_Proxy(
03980 IWGUrlListReceiver __RPC_FAR * This,
03981 BSTR newVal)
03982 {
03983
03984 HRESULT _RetVal;
03985
03986 RPC_MESSAGE _RpcMessage;
03987
03988 MIDL_STUB_MESSAGE _StubMsg;
03989
03990 RpcTryExcept
03991 {
03992 NdrProxyInitialize(
03993 ( void __RPC_FAR * )This,
03994 ( PRPC_MESSAGE )&_RpcMessage,
03995 ( PMIDL_STUB_MESSAGE )&_StubMsg,
03996 ( PMIDL_STUB_DESC )&Object_StubDesc,
03997 8);
03998
03999
04000
04001 RpcTryFinally
04002 {
04003
04004 _StubMsg.BufferLength = 8U;
04005 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
04006 (unsigned char __RPC_FAR *)&newVal,
04007 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
04008
04009 NdrProxyGetBuffer(This, &_StubMsg);
04010 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
04011 (unsigned char __RPC_FAR *)&newVal,
04012 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
04013
04014 NdrProxySendReceive(This, &_StubMsg);
04015
04016 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
04017 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
04018
04019 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
04020
04021 }
04022 RpcFinally
04023 {
04024 NdrProxyFreeBuffer(This, &_StubMsg);
04025
04026 }
04027 RpcEndFinally
04028
04029 }
04030 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
04031 {
04032 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
04033 }
04034 RpcEndExcept
04035 return _RetVal;
04036 }
04037
04038 void __RPC_STUB IWGUrlListReceiver_put_Url_Stub(
04039 IRpcStubBuffer *This,
04040 IRpcChannelBuffer *_pRpcChannelBuffer,
04041 PRPC_MESSAGE _pRpcMessage,
04042 DWORD *_pdwStubPhase)
04043 {
04044 HRESULT _RetVal;
04045 MIDL_STUB_MESSAGE _StubMsg;
04046 void __RPC_FAR *_p_newVal;
04047 BSTR newVal;
04048
04049 NdrStubInitialize(
04050 _pRpcMessage,
04051 &_StubMsg,
04052 &Object_StubDesc,
04053 _pRpcChannelBuffer);
04054 _p_newVal = &newVal;
04055 MIDL_memset(
04056 _p_newVal,
04057 0,
04058 sizeof( BSTR ));
04059 RpcTryFinally
04060 {
04061 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
04062 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
04063
04064 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
04065 (unsigned char __RPC_FAR * __RPC_FAR *)&_p_newVal,
04066 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44],
04067 (unsigned char)0 );
04068
04069
04070 *_pdwStubPhase = STUB_CALL_SERVER;
04071 _RetVal = (((IWGUrlListReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_Url((IWGUrlListReceiver *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
04072
04073 *_pdwStubPhase = STUB_MARSHAL;
04074
04075 _StubMsg.BufferLength = 4U;
04076 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
04077 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
04078
04079 }
04080 RpcFinally
04081 {
04082 NdrUserMarshalFree( &_StubMsg,
04083 (unsigned char __RPC_FAR *)&newVal,
04084 &__MIDL_TypeFormatString.Format[44] );
04085
04086 }
04087 RpcEndFinally
04088 _pRpcMessage->BufferLength =
04089 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
04090
04091 }
04092
04093
04094 HRESULT STDMETHODCALLTYPE IWGUrlListReceiver_get_Comment_Proxy(
04095 IWGUrlListReceiver __RPC_FAR * This,
04096 BSTR __RPC_FAR *pVal)
04097 {
04098
04099 HRESULT _RetVal;
04100
04101 RPC_MESSAGE _RpcMessage;
04102
04103 MIDL_STUB_MESSAGE _StubMsg;
04104
04105 if(pVal)
04106 {
04107 MIDL_memset(
04108 pVal,
04109 0,
04110 sizeof( BSTR ));
04111 }
04112 RpcTryExcept
04113 {
04114 NdrProxyInitialize(
04115 ( void __RPC_FAR * )This,
04116 ( PRPC_MESSAGE )&_RpcMessage,
04117 ( PMIDL_STUB_MESSAGE )&_StubMsg,
04118 ( PMIDL_STUB_DESC )&Object_StubDesc,
04119 9);
04120
04121
04122
04123 if(!pVal)
04124 {
04125 RpcRaiseException(RPC_X_NULL_REF_POINTER);
04126 }
04127 RpcTryFinally
04128 {
04129
04130 _StubMsg.BufferLength = 0U;
04131 NdrProxyGetBuffer(This, &_StubMsg);
04132 NdrProxySendReceive(This, &_StubMsg);
04133
04134 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
04135 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
04136
04137 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
04138 (unsigned char __RPC_FAR * __RPC_FAR *)&pVal,
04139 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30],
04140 (unsigned char)0 );
04141
04142 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
04143 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
04144
04145 }
04146 RpcFinally
04147 {
04148 NdrProxyFreeBuffer(This, &_StubMsg);
04149
04150 }
04151 RpcEndFinally
04152
04153 }
04154 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
04155 {
04156 NdrClearOutParameters(
04157 ( PMIDL_STUB_MESSAGE )&_StubMsg,
04158 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[2],
04159 ( void __RPC_FAR * )pVal);
04160 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
04161 }
04162 RpcEndExcept
04163 return _RetVal;
04164 }
04165
04166 void __RPC_STUB IWGUrlListReceiver_get_Comment_Stub(
04167 IRpcStubBuffer *This,
04168 IRpcChannelBuffer *_pRpcChannelBuffer,
04169 PRPC_MESSAGE _pRpcMessage,
04170 DWORD *_pdwStubPhase)
04171 {
04172 BSTR _M17;
04173 HRESULT _RetVal;
04174 MIDL_STUB_MESSAGE _StubMsg;
04175 BSTR __RPC_FAR *pVal;
04176
04177 NdrStubInitialize(
04178 _pRpcMessage,
04179 &_StubMsg,
04180 &Object_StubDesc,
04181 _pRpcChannelBuffer);
04182 ( BSTR __RPC_FAR * )pVal = 0;
04183 RpcTryFinally
04184 {
04185 pVal = &_M17;
04186 MIDL_memset(
04187 pVal,
04188 0,
04189 sizeof( BSTR ));
04190
04191 *_pdwStubPhase = STUB_CALL_SERVER;
04192 _RetVal = (((IWGUrlListReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_Comment((IWGUrlListReceiver *) ((CStdStubBuffer *)This)->pvServerObject,pVal);
04193
04194 *_pdwStubPhase = STUB_MARSHAL;
04195
04196 _StubMsg.BufferLength = 8U + 11U;
04197 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
04198 (unsigned char __RPC_FAR *)pVal,
04199 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
04200
04201 _StubMsg.BufferLength += 16;
04202
04203 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
04204 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
04205 (unsigned char __RPC_FAR *)pVal,
04206 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
04207
04208 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
04209 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
04210
04211 }
04212 RpcFinally
04213 {
04214 NdrPointerFree( &_StubMsg,
04215 (unsigned char __RPC_FAR *)pVal,
04216 &__MIDL_TypeFormatString.Format[2] );
04217
04218 }
04219 RpcEndFinally
04220 _pRpcMessage->BufferLength =
04221 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
04222
04223 }
04224
04225
04226 HRESULT STDMETHODCALLTYPE IWGUrlListReceiver_put_Comment_Proxy(
04227 IWGUrlListReceiver __RPC_FAR * This,
04228 BSTR newVal)
04229 {
04230
04231 HRESULT _RetVal;
04232
04233 RPC_MESSAGE _RpcMessage;
04234
04235 MIDL_STUB_MESSAGE _StubMsg;
04236
04237 RpcTryExcept
04238 {
04239 NdrProxyInitialize(
04240 ( void __RPC_FAR * )This,
04241 ( PRPC_MESSAGE )&_RpcMessage,
04242 ( PMIDL_STUB_MESSAGE )&_StubMsg,
04243 ( PMIDL_STUB_DESC )&Object_StubDesc,
04244 10);
04245
04246
04247
04248 RpcTryFinally
04249 {
04250
04251 _StubMsg.BufferLength = 8U;
04252 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
04253 (unsigned char __RPC_FAR *)&newVal,
04254 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
04255
04256 NdrProxyGetBuffer(This, &_StubMsg);
04257 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
04258 (unsigned char __RPC_FAR *)&newVal,
04259 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
04260
04261 NdrProxySendReceive(This, &_StubMsg);
04262
04263 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
04264 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
04265
04266 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
04267
04268 }
04269 RpcFinally
04270 {
04271 NdrProxyFreeBuffer(This, &_StubMsg);
04272
04273 }
04274 RpcEndFinally
04275
04276 }
04277 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
04278 {
04279 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
04280 }
04281 RpcEndExcept
04282 return _RetVal;
04283 }
04284
04285 void __RPC_STUB IWGUrlListReceiver_put_Comment_Stub(
04286 IRpcStubBuffer *This,
04287 IRpcChannelBuffer *_pRpcChannelBuffer,
04288 PRPC_MESSAGE _pRpcMessage,
04289 DWORD *_pdwStubPhase)
04290 {
04291 HRESULT _RetVal;
04292 MIDL_STUB_MESSAGE _StubMsg;
04293 void __RPC_FAR *_p_newVal;
04294 BSTR newVal;
04295
04296 NdrStubInitialize(
04297 _pRpcMessage,
04298 &_StubMsg,
04299 &Object_StubDesc,
04300 _pRpcChannelBuffer);
04301 _p_newVal = &newVal;
04302 MIDL_memset(
04303 _p_newVal,
04304 0,
04305 sizeof( BSTR ));
04306 RpcTryFinally
04307 {
04308 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
04309 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
04310
04311 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
04312 (unsigned char __RPC_FAR * __RPC_FAR *)&_p_newVal,
04313 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44],
04314 (unsigned char)0 );
04315
04316
04317 *_pdwStubPhase = STUB_CALL_SERVER;
04318 _RetVal = (((IWGUrlListReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_Comment((IWGUrlListReceiver *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
04319
04320 *_pdwStubPhase = STUB_MARSHAL;
04321
04322 _StubMsg.BufferLength = 4U;
04323 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
04324 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
04325
04326 }
04327 RpcFinally
04328 {
04329 NdrUserMarshalFree( &_StubMsg,
04330 (unsigned char __RPC_FAR *)&newVal,
04331 &__MIDL_TypeFormatString.Format[44] );
04332
04333 }
04334 RpcEndFinally
04335 _pRpcMessage->BufferLength =
04336 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
04337
04338 }
04339
04340
04341 HRESULT STDMETHODCALLTYPE IWGUrlListReceiver_get_Referer_Proxy(
04342 IWGUrlListReceiver __RPC_FAR * This,
04343 BSTR __RPC_FAR *pVal)
04344 {
04345
04346 HRESULT _RetVal;
04347
04348 RPC_MESSAGE _RpcMessage;
04349
04350 MIDL_STUB_MESSAGE _StubMsg;
04351
04352 if(pVal)
04353 {
04354 MIDL_memset(
04355 pVal,
04356 0,
04357 sizeof( BSTR ));
04358 }
04359 RpcTryExcept
04360 {
04361 NdrProxyInitialize(
04362 ( void __RPC_FAR * )This,
04363 ( PRPC_MESSAGE )&_RpcMessage,
04364 ( PMIDL_STUB_MESSAGE )&_StubMsg,
04365 ( PMIDL_STUB_DESC )&Object_StubDesc,
04366 11);
04367
04368
04369
04370 if(!pVal)
04371 {
04372 RpcRaiseException(RPC_X_NULL_REF_POINTER);
04373 }
04374 RpcTryFinally
04375 {
04376
04377 _StubMsg.BufferLength = 0U;
04378 NdrProxyGetBuffer(This, &_StubMsg);
04379 NdrProxySendReceive(This, &_StubMsg);
04380
04381 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
04382 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
04383
04384 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
04385 (unsigned char __RPC_FAR * __RPC_FAR *)&pVal,
04386 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30],
04387 (unsigned char)0 );
04388
04389 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
04390 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
04391
04392 }
04393 RpcFinally
04394 {
04395 NdrProxyFreeBuffer(This, &_StubMsg);
04396
04397 }
04398 RpcEndFinally
04399
04400 }
04401 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
04402 {
04403 NdrClearOutParameters(
04404 ( PMIDL_STUB_MESSAGE )&_StubMsg,
04405 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[2],
04406 ( void __RPC_FAR * )pVal);
04407 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
04408 }
04409 RpcEndExcept
04410 return _RetVal;
04411 }
04412
04413 void __RPC_STUB IWGUrlListReceiver_get_Referer_Stub(
04414 IRpcStubBuffer *This,
04415 IRpcChannelBuffer *_pRpcChannelBuffer,
04416 PRPC_MESSAGE _pRpcMessage,
04417 DWORD *_pdwStubPhase)
04418 {
04419 BSTR _M18;
04420 HRESULT _RetVal;
04421 MIDL_STUB_MESSAGE _StubMsg;
04422 BSTR __RPC_FAR *pVal;
04423
04424 NdrStubInitialize(
04425 _pRpcMessage,
04426 &_StubMsg,
04427 &Object_StubDesc,
04428 _pRpcChannelBuffer);
04429 ( BSTR __RPC_FAR * )pVal = 0;
04430 RpcTryFinally
04431 {
04432 pVal = &_M18;
04433 MIDL_memset(
04434 pVal,
04435 0,
04436 sizeof( BSTR ));
04437
04438 *_pdwStubPhase = STUB_CALL_SERVER;
04439 _RetVal = (((IWGUrlListReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_Referer((IWGUrlListReceiver *) ((CStdStubBuffer *)This)->pvServerObject,pVal);
04440
04441 *_pdwStubPhase = STUB_MARSHAL;
04442
04443 _StubMsg.BufferLength = 8U + 11U;
04444 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
04445 (unsigned char __RPC_FAR *)pVal,
04446 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
04447
04448 _StubMsg.BufferLength += 16;
04449
04450 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
04451 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
04452 (unsigned char __RPC_FAR *)pVal,
04453 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
04454
04455 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
04456 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
04457
04458 }
04459 RpcFinally
04460 {
04461 NdrPointerFree( &_StubMsg,
04462 (unsigned char __RPC_FAR *)pVal,
04463 &__MIDL_TypeFormatString.Format[2] );
04464
04465 }
04466 RpcEndFinally
04467 _pRpcMessage->BufferLength =
04468 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
04469
04470 }
04471
04472
04473 HRESULT STDMETHODCALLTYPE IWGUrlListReceiver_put_Referer_Proxy(
04474 IWGUrlListReceiver __RPC_FAR * This,
04475 BSTR newVal)
04476 {
04477
04478 HRESULT _RetVal;
04479
04480 RPC_MESSAGE _RpcMessage;
04481
04482 MIDL_STUB_MESSAGE _StubMsg;
04483
04484 RpcTryExcept
04485 {
04486 NdrProxyInitialize(
04487 ( void __RPC_FAR * )This,
04488 ( PRPC_MESSAGE )&_RpcMessage,
04489 ( PMIDL_STUB_MESSAGE )&_StubMsg,
04490 ( PMIDL_STUB_DESC )&Object_StubDesc,
04491 12);
04492
04493
04494
04495 RpcTryFinally
04496 {
04497
04498 _StubMsg.BufferLength = 8U;
04499 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
04500 (unsigned char __RPC_FAR *)&newVal,
04501 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
04502
04503 NdrProxyGetBuffer(This, &_StubMsg);
04504 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
04505 (unsigned char __RPC_FAR *)&newVal,
04506 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
04507
04508 NdrProxySendReceive(This, &_StubMsg);
04509
04510 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
04511 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
04512
04513 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
04514
04515 }
04516 RpcFinally
04517 {
04518 NdrProxyFreeBuffer(This, &_StubMsg);
04519
04520 }
04521 RpcEndFinally
04522
04523 }
04524 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
04525 {
04526 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
04527 }
04528 RpcEndExcept
04529 return _RetVal;
04530 }
04531
04532 void __RPC_STUB IWGUrlListReceiver_put_Referer_Stub(
04533 IRpcStubBuffer *This,
04534 IRpcChannelBuffer *_pRpcChannelBuffer,
04535 PRPC_MESSAGE _pRpcMessage,
04536 DWORD *_pdwStubPhase)
04537 {
04538 HRESULT _RetVal;
04539 MIDL_STUB_MESSAGE _StubMsg;
04540 void __RPC_FAR *_p_newVal;
04541 BSTR newVal;
04542
04543 NdrStubInitialize(
04544 _pRpcMessage,
04545 &_StubMsg,
04546 &Object_StubDesc,
04547 _pRpcChannelBuffer);
04548 _p_newVal = &newVal;
04549 MIDL_memset(
04550 _p_newVal,
04551 0,
04552 sizeof( BSTR ));
04553 RpcTryFinally
04554 {
04555 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
04556 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
04557
04558 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
04559 (unsigned char __RPC_FAR * __RPC_FAR *)&_p_newVal,
04560 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44],
04561 (unsigned char)0 );
04562
04563
04564 *_pdwStubPhase = STUB_CALL_SERVER;
04565 _RetVal = (((IWGUrlListReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_Referer((IWGUrlListReceiver *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
04566
04567 *_pdwStubPhase = STUB_MARSHAL;
04568
04569 _StubMsg.BufferLength = 4U;
04570 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
04571 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
04572
04573 }
04574 RpcFinally
04575 {
04576 NdrUserMarshalFree( &_StubMsg,
04577 (unsigned char __RPC_FAR *)&newVal,
04578 &__MIDL_TypeFormatString.Format[44] );
04579
04580 }
04581 RpcEndFinally
04582 _pRpcMessage->BufferLength =
04583 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
04584
04585 }
04586
04587
04588 HRESULT STDMETHODCALLTYPE IWGUrlListReceiver_AddUrlToList_Proxy(
04589 IWGUrlListReceiver __RPC_FAR * This)
04590 {
04591
04592 HRESULT _RetVal;
04593
04594 RPC_MESSAGE _RpcMessage;
04595
04596 MIDL_STUB_MESSAGE _StubMsg;
04597
04598 RpcTryExcept
04599 {
04600 NdrProxyInitialize(
04601 ( void __RPC_FAR * )This,
04602 ( PRPC_MESSAGE )&_RpcMessage,
04603 ( PMIDL_STUB_MESSAGE )&_StubMsg,
04604 ( PMIDL_STUB_DESC )&Object_StubDesc,
04605 13);
04606
04607
04608
04609 RpcTryFinally
04610 {
04611
04612 _StubMsg.BufferLength = 0U;
04613 NdrProxyGetBuffer(This, &_StubMsg);
04614 NdrProxySendReceive(This, &_StubMsg);
04615
04616 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
04617 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[12] );
04618
04619 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
04620
04621 }
04622 RpcFinally
04623 {
04624 NdrProxyFreeBuffer(This, &_StubMsg);
04625
04626 }
04627 RpcEndFinally
04628
04629 }
04630 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
04631 {
04632 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
04633 }
04634 RpcEndExcept
04635 return _RetVal;
04636 }
04637
04638 void __RPC_STUB IWGUrlListReceiver_AddUrlToList_Stub(
04639 IRpcStubBuffer *This,
04640 IRpcChannelBuffer *_pRpcChannelBuffer,
04641 PRPC_MESSAGE _pRpcMessage,
04642 DWORD *_pdwStubPhase)
04643 {
04644 HRESULT _RetVal;
04645 MIDL_STUB_MESSAGE _StubMsg;
04646
04647 NdrStubInitialize(
04648 _pRpcMessage,
04649 &_StubMsg,
04650 &Object_StubDesc,
04651 _pRpcChannelBuffer);
04652 RpcTryFinally
04653 {
04654
04655 *_pdwStubPhase = STUB_CALL_SERVER;
04656 _RetVal = (((IWGUrlListReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> AddUrlToList((IWGUrlListReceiver *) ((CStdStubBuffer *)This)->pvServerObject);
04657
04658 *_pdwStubPhase = STUB_MARSHAL;
04659
04660 _StubMsg.BufferLength = 4U;
04661 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
04662 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
04663
04664 }
04665 RpcFinally
04666 {
04667 }
04668 RpcEndFinally
04669 _pRpcMessage->BufferLength =
04670 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
04671
04672 }
04673
04674
04675 HRESULT STDMETHODCALLTYPE IWGUrlListReceiver_ShowAddUrlListDialog_Proxy(
04676 IWGUrlListReceiver __RPC_FAR * This)
04677 {
04678
04679 HRESULT _RetVal;
04680
04681 RPC_MESSAGE _RpcMessage;
04682
04683 MIDL_STUB_MESSAGE _StubMsg;
04684
04685 RpcTryExcept
04686 {
04687 NdrProxyInitialize(
04688 ( void __RPC_FAR * )This,
04689 ( PRPC_MESSAGE )&_RpcMessage,
04690 ( PMIDL_STUB_MESSAGE )&_StubMsg,
04691 ( PMIDL_STUB_DESC )&Object_StubDesc,
04692 14);
04693
04694
04695
04696 RpcTryFinally
04697 {
04698
04699 _StubMsg.BufferLength = 0U;
04700 NdrProxyGetBuffer(This, &_StubMsg);
04701 NdrProxySendReceive(This, &_StubMsg);
04702
04703 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
04704 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[12] );
04705
04706 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
04707
04708 }
04709 RpcFinally
04710 {
04711 NdrProxyFreeBuffer(This, &_StubMsg);
04712
04713 }
04714 RpcEndFinally
04715
04716 }
04717 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
04718 {
04719 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
04720 }
04721 RpcEndExcept
04722 return _RetVal;
04723 }
04724
04725 void __RPC_STUB IWGUrlListReceiver_ShowAddUrlListDialog_Stub(
04726 IRpcStubBuffer *This,
04727 IRpcChannelBuffer *_pRpcChannelBuffer,
04728 PRPC_MESSAGE _pRpcMessage,
04729 DWORD *_pdwStubPhase)
04730 {
04731 HRESULT _RetVal;
04732 MIDL_STUB_MESSAGE _StubMsg;
04733
04734 NdrStubInitialize(
04735 _pRpcMessage,
04736 &_StubMsg,
04737 &Object_StubDesc,
04738 _pRpcChannelBuffer);
04739 RpcTryFinally
04740 {
04741
04742 *_pdwStubPhase = STUB_CALL_SERVER;
04743 _RetVal = (((IWGUrlListReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> ShowAddUrlListDialog((IWGUrlListReceiver *) ((CStdStubBuffer *)This)->pvServerObject);
04744
04745 *_pdwStubPhase = STUB_MARSHAL;
04746
04747 _StubMsg.BufferLength = 4U;
04748 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
04749 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
04750
04751 }
04752 RpcFinally
04753 {
04754 }
04755 RpcEndFinally
04756 _pRpcMessage->BufferLength =
04757 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
04758
04759 }
04760
04761
04762 HRESULT STDMETHODCALLTYPE IWGUrlListReceiver_GetUrlListFromDocumentSelection_Proxy(
04763 IWGUrlListReceiver __RPC_FAR * This,
04764 IDispatch __RPC_FAR *pDispatch)
04765 {
04766
04767 HRESULT _RetVal;
04768
04769 RPC_MESSAGE _RpcMessage;
04770
04771 MIDL_STUB_MESSAGE _StubMsg;
04772
04773 RpcTryExcept
04774 {
04775 NdrProxyInitialize(
04776 ( void __RPC_FAR * )This,
04777 ( PRPC_MESSAGE )&_RpcMessage,
04778 ( PMIDL_STUB_MESSAGE )&_StubMsg,
04779 ( PMIDL_STUB_DESC )&Object_StubDesc,
04780 15);
04781
04782
04783
04784 RpcTryFinally
04785 {
04786
04787 _StubMsg.BufferLength = 0U;
04788 NdrInterfacePointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
04789 (unsigned char __RPC_FAR *)pDispatch,
04790 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[58] );
04791
04792 NdrProxyGetBuffer(This, &_StubMsg);
04793 NdrInterfacePointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
04794 (unsigned char __RPC_FAR *)pDispatch,
04795 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[58] );
04796
04797 NdrProxySendReceive(This, &_StubMsg);
04798
04799 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
04800 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[24] );
04801
04802 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
04803
04804 }
04805 RpcFinally
04806 {
04807 NdrProxyFreeBuffer(This, &_StubMsg);
04808
04809 }
04810 RpcEndFinally
04811
04812 }
04813 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
04814 {
04815 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
04816 }
04817 RpcEndExcept
04818 return _RetVal;
04819 }
04820
04821 void __RPC_STUB IWGUrlListReceiver_GetUrlListFromDocumentSelection_Stub(
04822 IRpcStubBuffer *This,
04823 IRpcChannelBuffer *_pRpcChannelBuffer,
04824 PRPC_MESSAGE _pRpcMessage,
04825 DWORD *_pdwStubPhase)
04826 {
04827 HRESULT _RetVal;
04828 MIDL_STUB_MESSAGE _StubMsg;
04829 IDispatch __RPC_FAR *pDispatch;
04830
04831 NdrStubInitialize(
04832 _pRpcMessage,
04833 &_StubMsg,
04834 &Object_StubDesc,
04835 _pRpcChannelBuffer);
04836 pDispatch = 0;
04837 RpcTryFinally
04838 {
04839 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
04840 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[24] );
04841
04842 NdrInterfacePointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
04843 (unsigned char __RPC_FAR * __RPC_FAR *)&pDispatch,
04844 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[58],
04845 (unsigned char)0 );
04846
04847
04848 *_pdwStubPhase = STUB_CALL_SERVER;
04849 _RetVal = (((IWGUrlListReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> GetUrlListFromDocumentSelection((IWGUrlListReceiver *) ((CStdStubBuffer *)This)->pvServerObject,pDispatch);
04850
04851 *_pdwStubPhase = STUB_MARSHAL;
04852
04853 _StubMsg.BufferLength = 4U;
04854 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
04855 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
04856
04857 }
04858 RpcFinally
04859 {
04860 NdrInterfacePointerFree( &_StubMsg,
04861 (unsigned char __RPC_FAR *)pDispatch,
04862 &__MIDL_TypeFormatString.Format[58] );
04863
04864 }
04865 RpcEndFinally
04866 _pRpcMessage->BufferLength =
04867 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
04868
04869 }
04870
04871
04872 HRESULT STDMETHODCALLTYPE IWGUrlListReceiver_get_Cookies_Proxy(
04873 IWGUrlListReceiver __RPC_FAR * This,
04874 BSTR __RPC_FAR *pVal)
04875 {
04876
04877 HRESULT _RetVal;
04878
04879 RPC_MESSAGE _RpcMessage;
04880
04881 MIDL_STUB_MESSAGE _StubMsg;
04882
04883 if(pVal)
04884 {
04885 MIDL_memset(
04886 pVal,
04887 0,
04888 sizeof( BSTR ));
04889 }
04890 RpcTryExcept
04891 {
04892 NdrProxyInitialize(
04893 ( void __RPC_FAR * )This,
04894 ( PRPC_MESSAGE )&_RpcMessage,
04895 ( PMIDL_STUB_MESSAGE )&_StubMsg,
04896 ( PMIDL_STUB_DESC )&Object_StubDesc,
04897 16);
04898
04899
04900
04901 if(!pVal)
04902 {
04903 RpcRaiseException(RPC_X_NULL_REF_POINTER);
04904 }
04905 RpcTryFinally
04906 {
04907
04908 _StubMsg.BufferLength = 0U;
04909 NdrProxyGetBuffer(This, &_StubMsg);
04910 NdrProxySendReceive(This, &_StubMsg);
04911
04912 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
04913 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
04914
04915 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
04916 (unsigned char __RPC_FAR * __RPC_FAR *)&pVal,
04917 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30],
04918 (unsigned char)0 );
04919
04920 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
04921 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
04922
04923 }
04924 RpcFinally
04925 {
04926 NdrProxyFreeBuffer(This, &_StubMsg);
04927
04928 }
04929 RpcEndFinally
04930
04931 }
04932 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
04933 {
04934 NdrClearOutParameters(
04935 ( PMIDL_STUB_MESSAGE )&_StubMsg,
04936 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[2],
04937 ( void __RPC_FAR * )pVal);
04938 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
04939 }
04940 RpcEndExcept
04941 return _RetVal;
04942 }
04943
04944 void __RPC_STUB IWGUrlListReceiver_get_Cookies_Stub(
04945 IRpcStubBuffer *This,
04946 IRpcChannelBuffer *_pRpcChannelBuffer,
04947 PRPC_MESSAGE _pRpcMessage,
04948 DWORD *_pdwStubPhase)
04949 {
04950 BSTR _M19;
04951 HRESULT _RetVal;
04952 MIDL_STUB_MESSAGE _StubMsg;
04953 BSTR __RPC_FAR *pVal;
04954
04955 NdrStubInitialize(
04956 _pRpcMessage,
04957 &_StubMsg,
04958 &Object_StubDesc,
04959 _pRpcChannelBuffer);
04960 ( BSTR __RPC_FAR * )pVal = 0;
04961 RpcTryFinally
04962 {
04963 pVal = &_M19;
04964 MIDL_memset(
04965 pVal,
04966 0,
04967 sizeof( BSTR ));
04968
04969 *_pdwStubPhase = STUB_CALL_SERVER;
04970 _RetVal = (((IWGUrlListReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_Cookies((IWGUrlListReceiver *) ((CStdStubBuffer *)This)->pvServerObject,pVal);
04971
04972 *_pdwStubPhase = STUB_MARSHAL;
04973
04974 _StubMsg.BufferLength = 8U + 11U;
04975 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
04976 (unsigned char __RPC_FAR *)pVal,
04977 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
04978
04979 _StubMsg.BufferLength += 16;
04980
04981 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
04982 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
04983 (unsigned char __RPC_FAR *)pVal,
04984 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
04985
04986 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
04987 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
04988
04989 }
04990 RpcFinally
04991 {
04992 NdrPointerFree( &_StubMsg,
04993 (unsigned char __RPC_FAR *)pVal,
04994 &__MIDL_TypeFormatString.Format[2] );
04995
04996 }
04997 RpcEndFinally
04998 _pRpcMessage->BufferLength =
04999 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
05000
05001 }
05002
05003
05004 HRESULT STDMETHODCALLTYPE IWGUrlListReceiver_put_Cookies_Proxy(
05005 IWGUrlListReceiver __RPC_FAR * This,
05006 BSTR newVal)
05007 {
05008
05009 HRESULT _RetVal;
05010
05011 RPC_MESSAGE _RpcMessage;
05012
05013 MIDL_STUB_MESSAGE _StubMsg;
05014
05015 RpcTryExcept
05016 {
05017 NdrProxyInitialize(
05018 ( void __RPC_FAR * )This,
05019 ( PRPC_MESSAGE )&_RpcMessage,
05020 ( PMIDL_STUB_MESSAGE )&_StubMsg,
05021 ( PMIDL_STUB_DESC )&Object_StubDesc,
05022 17);
05023
05024
05025
05026 RpcTryFinally
05027 {
05028
05029 _StubMsg.BufferLength = 8U;
05030 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
05031 (unsigned char __RPC_FAR *)&newVal,
05032 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
05033
05034 NdrProxyGetBuffer(This, &_StubMsg);
05035 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
05036 (unsigned char __RPC_FAR *)&newVal,
05037 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
05038
05039 NdrProxySendReceive(This, &_StubMsg);
05040
05041 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
05042 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
05043
05044 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
05045
05046 }
05047 RpcFinally
05048 {
05049 NdrProxyFreeBuffer(This, &_StubMsg);
05050
05051 }
05052 RpcEndFinally
05053
05054 }
05055 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
05056 {
05057 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
05058 }
05059 RpcEndExcept
05060 return _RetVal;
05061 }
05062
05063 void __RPC_STUB IWGUrlListReceiver_put_Cookies_Stub(
05064 IRpcStubBuffer *This,
05065 IRpcChannelBuffer *_pRpcChannelBuffer,
05066 PRPC_MESSAGE _pRpcMessage,
05067 DWORD *_pdwStubPhase)
05068 {
05069 HRESULT _RetVal;
05070 MIDL_STUB_MESSAGE _StubMsg;
05071 void __RPC_FAR *_p_newVal;
05072 BSTR newVal;
05073
05074 NdrStubInitialize(
05075 _pRpcMessage,
05076 &_StubMsg,
05077 &Object_StubDesc,
05078 _pRpcChannelBuffer);
05079 _p_newVal = &newVal;
05080 MIDL_memset(
05081 _p_newVal,
05082 0,
05083 sizeof( BSTR ));
05084 RpcTryFinally
05085 {
05086 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
05087 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
05088
05089 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
05090 (unsigned char __RPC_FAR * __RPC_FAR *)&_p_newVal,
05091 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44],
05092 (unsigned char)0 );
05093
05094
05095 *_pdwStubPhase = STUB_CALL_SERVER;
05096 _RetVal = (((IWGUrlListReceiver*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_Cookies((IWGUrlListReceiver *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
05097
05098 *_pdwStubPhase = STUB_MARSHAL;
05099
05100 _StubMsg.BufferLength = 4U;
05101 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
05102 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
05103
05104 }
05105 RpcFinally
05106 {
05107 NdrUserMarshalFree( &_StubMsg,
05108 (unsigned char __RPC_FAR *)&newVal,
05109 &__MIDL_TypeFormatString.Format[44] );
05110
05111 }
05112 RpcEndFinally
05113 _pRpcMessage->BufferLength =
05114 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
05115
05116 }
05117
05118 CINTERFACE_PROXY_VTABLE(18) _IWGUrlListReceiverProxyVtbl =
05119 {
05120 &IID_IWGUrlListReceiver,
05121 IUnknown_QueryInterface_Proxy,
05122 IUnknown_AddRef_Proxy,
05123 IUnknown_Release_Proxy ,
05124 0 ,
05125 0 ,
05126 0 ,
05127 0 ,
05128 IWGUrlListReceiver_get_Url_Proxy ,
05129 IWGUrlListReceiver_put_Url_Proxy ,
05130 IWGUrlListReceiver_get_Comment_Proxy ,
05131 IWGUrlListReceiver_put_Comment_Proxy ,
05132 IWGUrlListReceiver_get_Referer_Proxy ,
05133 IWGUrlListReceiver_put_Referer_Proxy ,
05134 IWGUrlListReceiver_AddUrlToList_Proxy ,
05135 IWGUrlListReceiver_ShowAddUrlListDialog_Proxy ,
05136 IWGUrlListReceiver_GetUrlListFromDocumentSelection_Proxy ,
05137 IWGUrlListReceiver_get_Cookies_Proxy ,
05138 IWGUrlListReceiver_put_Cookies_Proxy
05139 };
05140
05141
05142 static const PRPC_STUB_FUNCTION IWGUrlListReceiver_table[] =
05143 {
05144 STUB_FORWARDING_FUNCTION,
05145 STUB_FORWARDING_FUNCTION,
05146 STUB_FORWARDING_FUNCTION,
05147 STUB_FORWARDING_FUNCTION,
05148 IWGUrlListReceiver_get_Url_Stub,
05149 IWGUrlListReceiver_put_Url_Stub,
05150 IWGUrlListReceiver_get_Comment_Stub,
05151 IWGUrlListReceiver_put_Comment_Stub,
05152 IWGUrlListReceiver_get_Referer_Stub,
05153 IWGUrlListReceiver_put_Referer_Stub,
05154 IWGUrlListReceiver_AddUrlToList_Stub,
05155 IWGUrlListReceiver_ShowAddUrlListDialog_Stub,
05156 IWGUrlListReceiver_GetUrlListFromDocumentSelection_Stub,
05157 IWGUrlListReceiver_get_Cookies_Stub,
05158 IWGUrlListReceiver_put_Cookies_Stub
05159 };
05160
05161 CInterfaceStubVtbl _IWGUrlListReceiverStubVtbl =
05162 {
05163 &IID_IWGUrlListReceiver,
05164 0,
05165 18,
05166 &IWGUrlListReceiver_table[-3],
05167 CStdStubBuffer_DELEGATING_METHODS
05168 };
05169
05170
05171
05172
05173
05174
05175 extern const MIDL_STUB_DESC Object_StubDesc;
05176
05177
05178 #pragma code_seg(".orpc")
05179
05180 HRESULT STDMETHODCALLTYPE IFDM_Shutdown_Proxy(
05181 IFDM __RPC_FAR * This,
05182 BOOL bAskUser)
05183 {
05184
05185 HRESULT _RetVal;
05186
05187 RPC_MESSAGE _RpcMessage;
05188
05189 MIDL_STUB_MESSAGE _StubMsg;
05190
05191 RpcTryExcept
05192 {
05193 NdrProxyInitialize(
05194 ( void __RPC_FAR * )This,
05195 ( PRPC_MESSAGE )&_RpcMessage,
05196 ( PMIDL_STUB_MESSAGE )&_StubMsg,
05197 ( PMIDL_STUB_DESC )&Object_StubDesc,
05198 7);
05199
05200
05201
05202 RpcTryFinally
05203 {
05204
05205 _StubMsg.BufferLength = 4U;
05206 NdrProxyGetBuffer(This, &_StubMsg);
05207 *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = bAskUser;
05208
05209 NdrProxySendReceive(This, &_StubMsg);
05210
05211 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
05212 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
05213
05214 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
05215
05216 }
05217 RpcFinally
05218 {
05219 NdrProxyFreeBuffer(This, &_StubMsg);
05220
05221 }
05222 RpcEndFinally
05223
05224 }
05225 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
05226 {
05227 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
05228 }
05229 RpcEndExcept
05230 return _RetVal;
05231 }
05232
05233 void __RPC_STUB IFDM_Shutdown_Stub(
05234 IRpcStubBuffer *This,
05235 IRpcChannelBuffer *_pRpcChannelBuffer,
05236 PRPC_MESSAGE _pRpcMessage,
05237 DWORD *_pdwStubPhase)
05238 {
05239 HRESULT _RetVal;
05240 MIDL_STUB_MESSAGE _StubMsg;
05241 BOOL bAskUser;
05242
05243 NdrStubInitialize(
05244 _pRpcMessage,
05245 &_StubMsg,
05246 &Object_StubDesc,
05247 _pRpcChannelBuffer);
05248 RpcTryFinally
05249 {
05250 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
05251 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
05252
05253 bAskUser = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
05254
05255
05256 *_pdwStubPhase = STUB_CALL_SERVER;
05257 _RetVal = (((IFDM*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> Shutdown((IFDM *) ((CStdStubBuffer *)This)->pvServerObject,bAskUser);
05258
05259 *_pdwStubPhase = STUB_MARSHAL;
05260
05261 _StubMsg.BufferLength = 4U;
05262 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
05263 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
05264
05265 }
05266 RpcFinally
05267 {
05268 }
05269 RpcEndFinally
05270 _pRpcMessage->BufferLength =
05271 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
05272
05273 }
05274
05275 CINTERFACE_PROXY_VTABLE(8) _IFDMProxyVtbl =
05276 {
05277 &IID_IFDM,
05278 IUnknown_QueryInterface_Proxy,
05279 IUnknown_AddRef_Proxy,
05280 IUnknown_Release_Proxy ,
05281 0 ,
05282 0 ,
05283 0 ,
05284 0 ,
05285 IFDM_Shutdown_Proxy
05286 };
05287
05288
05289 static const PRPC_STUB_FUNCTION IFDM_table[] =
05290 {
05291 STUB_FORWARDING_FUNCTION,
05292 STUB_FORWARDING_FUNCTION,
05293 STUB_FORWARDING_FUNCTION,
05294 STUB_FORWARDING_FUNCTION,
05295 IFDM_Shutdown_Stub
05296 };
05297
05298 CInterfaceStubVtbl _IFDMStubVtbl =
05299 {
05300 &IID_IFDM,
05301 0,
05302 8,
05303 &IFDM_table[-3],
05304 CStdStubBuffer_DELEGATING_METHODS
05305 };
05306
05307
05308
05309
05310
05311
05312 extern const MIDL_STUB_DESC Object_StubDesc;
05313
05314
05315 #pragma code_seg(".orpc")
05316
05317 HRESULT STDMETHODCALLTYPE IFDMDownload_get_Url_Proxy(
05318 IFDMDownload __RPC_FAR * This,
05319 BSTR __RPC_FAR *pVal)
05320 {
05321
05322 HRESULT _RetVal;
05323
05324 RPC_MESSAGE _RpcMessage;
05325
05326 MIDL_STUB_MESSAGE _StubMsg;
05327
05328 if(pVal)
05329 {
05330 MIDL_memset(
05331 pVal,
05332 0,
05333 sizeof( BSTR ));
05334 }
05335 RpcTryExcept
05336 {
05337 NdrProxyInitialize(
05338 ( void __RPC_FAR * )This,
05339 ( PRPC_MESSAGE )&_RpcMessage,
05340 ( PMIDL_STUB_MESSAGE )&_StubMsg,
05341 ( PMIDL_STUB_DESC )&Object_StubDesc,
05342 7);
05343
05344
05345
05346 if(!pVal)
05347 {
05348 RpcRaiseException(RPC_X_NULL_REF_POINTER);
05349 }
05350 RpcTryFinally
05351 {
05352
05353 _StubMsg.BufferLength = 0U;
05354 NdrProxyGetBuffer(This, &_StubMsg);
05355 NdrProxySendReceive(This, &_StubMsg);
05356
05357 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
05358 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[0] );
05359
05360 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
05361 (unsigned char __RPC_FAR * __RPC_FAR *)&pVal,
05362 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30],
05363 (unsigned char)0 );
05364
05365 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
05366 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
05367
05368 }
05369 RpcFinally
05370 {
05371 NdrProxyFreeBuffer(This, &_StubMsg);
05372
05373 }
05374 RpcEndFinally
05375
05376 }
05377 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
05378 {
05379 NdrClearOutParameters(
05380 ( PMIDL_STUB_MESSAGE )&_StubMsg,
05381 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[2],
05382 ( void __RPC_FAR * )pVal);
05383 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
05384 }
05385 RpcEndExcept
05386 return _RetVal;
05387 }
05388
05389 void __RPC_STUB IFDMDownload_get_Url_Stub(
05390 IRpcStubBuffer *This,
05391 IRpcChannelBuffer *_pRpcChannelBuffer,
05392 PRPC_MESSAGE _pRpcMessage,
05393 DWORD *_pdwStubPhase)
05394 {
05395 BSTR _M20;
05396 HRESULT _RetVal;
05397 MIDL_STUB_MESSAGE _StubMsg;
05398 BSTR __RPC_FAR *pVal;
05399
05400 NdrStubInitialize(
05401 _pRpcMessage,
05402 &_StubMsg,
05403 &Object_StubDesc,
05404 _pRpcChannelBuffer);
05405 ( BSTR __RPC_FAR * )pVal = 0;
05406 RpcTryFinally
05407 {
05408 pVal = &_M20;
05409 MIDL_memset(
05410 pVal,
05411 0,
05412 sizeof( BSTR ));
05413
05414 *_pdwStubPhase = STUB_CALL_SERVER;
05415 _RetVal = (((IFDMDownload*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_Url((IFDMDownload *) ((CStdStubBuffer *)This)->pvServerObject,pVal);
05416
05417 *_pdwStubPhase = STUB_MARSHAL;
05418
05419 _StubMsg.BufferLength = 8U + 11U;
05420 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
05421 (unsigned char __RPC_FAR *)pVal,
05422 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
05423
05424 _StubMsg.BufferLength += 16;
05425
05426 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
05427 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
05428 (unsigned char __RPC_FAR *)pVal,
05429 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
05430
05431 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
05432 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
05433
05434 }
05435 RpcFinally
05436 {
05437 NdrPointerFree( &_StubMsg,
05438 (unsigned char __RPC_FAR *)pVal,
05439 &__MIDL_TypeFormatString.Format[2] );
05440
05441 }
05442 RpcEndFinally
05443 _pRpcMessage->BufferLength =
05444 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
05445
05446 }
05447
05448
05449 HRESULT STDMETHODCALLTYPE IFDMDownload_put_Url_Proxy(
05450 IFDMDownload __RPC_FAR * This,
05451 BSTR newVal)
05452 {
05453
05454 HRESULT _RetVal;
05455
05456 RPC_MESSAGE _RpcMessage;
05457
05458 MIDL_STUB_MESSAGE _StubMsg;
05459
05460 RpcTryExcept
05461 {
05462 NdrProxyInitialize(
05463 ( void __RPC_FAR * )This,
05464 ( PRPC_MESSAGE )&_RpcMessage,
05465 ( PMIDL_STUB_MESSAGE )&_StubMsg,
05466 ( PMIDL_STUB_DESC )&Object_StubDesc,
05467 8);
05468
05469
05470
05471 RpcTryFinally
05472 {
05473
05474 _StubMsg.BufferLength = 8U;
05475 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
05476 (unsigned char __RPC_FAR *)&newVal,
05477 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
05478
05479 NdrProxyGetBuffer(This, &_StubMsg);
05480 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
05481 (unsigned char __RPC_FAR *)&newVal,
05482 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
05483
05484 NdrProxySendReceive(This, &_StubMsg);
05485
05486 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
05487 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
05488
05489 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
05490
05491 }
05492 RpcFinally
05493 {
05494 NdrProxyFreeBuffer(This, &_StubMsg);
05495
05496 }
05497 RpcEndFinally
05498
05499 }
05500 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
05501 {
05502 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
05503 }
05504 RpcEndExcept
05505 return _RetVal;
05506 }
05507
05508 void __RPC_STUB IFDMDownload_put_Url_Stub(
05509 IRpcStubBuffer *This,
05510 IRpcChannelBuffer *_pRpcChannelBuffer,
05511 PRPC_MESSAGE _pRpcMessage,
05512 DWORD *_pdwStubPhase)
05513 {
05514 HRESULT _RetVal;
05515 MIDL_STUB_MESSAGE _StubMsg;
05516 void __RPC_FAR *_p_newVal;
05517 BSTR newVal;
05518
05519 NdrStubInitialize(
05520 _pRpcMessage,
05521 &_StubMsg,
05522 &Object_StubDesc,
05523 _pRpcChannelBuffer);
05524 _p_newVal = &newVal;
05525 MIDL_memset(
05526 _p_newVal,
05527 0,
05528 sizeof( BSTR ));
05529 RpcTryFinally
05530 {
05531 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
05532 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
05533
05534 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
05535 (unsigned char __RPC_FAR * __RPC_FAR *)&_p_newVal,
05536 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44],
05537 (unsigned char)0 );
05538
05539
05540 *_pdwStubPhase = STUB_CALL_SERVER;
05541 _RetVal = (((IFDMDownload*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_Url((IFDMDownload *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
05542
05543 *_pdwStubPhase = STUB_MARSHAL;
05544
05545 _StubMsg.BufferLength = 4U;
05546 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
05547 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
05548
05549 }
05550 RpcFinally
05551 {
05552 NdrUserMarshalFree( &_StubMsg,
05553 (unsigned char __RPC_FAR *)&newVal,
05554 &__MIDL_TypeFormatString.Format[44] );
05555
05556 }
05557 RpcEndFinally
05558 _pRpcMessage->BufferLength =
05559 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
05560
05561 }
05562
05563
05564 HRESULT STDMETHODCALLTYPE IFDMDownload_get_DownloadText_Proxy(
05565 IFDMDownload __RPC_FAR * This,
05566 long nTextIndex,
05567 BSTR __RPC_FAR *pVal)
05568 {
05569
05570 HRESULT _RetVal;
05571
05572 RPC_MESSAGE _RpcMessage;
05573
05574 MIDL_STUB_MESSAGE _StubMsg;
05575
05576 if(pVal)
05577 {
05578 MIDL_memset(
05579 pVal,
05580 0,
05581 sizeof( BSTR ));
05582 }
05583 RpcTryExcept
05584 {
05585 NdrProxyInitialize(
05586 ( void __RPC_FAR * )This,
05587 ( PRPC_MESSAGE )&_RpcMessage,
05588 ( PMIDL_STUB_MESSAGE )&_StubMsg,
05589 ( PMIDL_STUB_DESC )&Object_StubDesc,
05590 9);
05591
05592
05593
05594 if(!pVal)
05595 {
05596 RpcRaiseException(RPC_X_NULL_REF_POINTER);
05597 }
05598 RpcTryFinally
05599 {
05600
05601 _StubMsg.BufferLength = 4U;
05602 NdrProxyGetBuffer(This, &_StubMsg);
05603 *(( long __RPC_FAR * )_StubMsg.Buffer)++ = nTextIndex;
05604
05605 NdrProxySendReceive(This, &_StubMsg);
05606
05607 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
05608 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[30] );
05609
05610 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
05611 (unsigned char __RPC_FAR * __RPC_FAR *)&pVal,
05612 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30],
05613 (unsigned char)0 );
05614
05615 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
05616 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
05617
05618 }
05619 RpcFinally
05620 {
05621 NdrProxyFreeBuffer(This, &_StubMsg);
05622
05623 }
05624 RpcEndFinally
05625
05626 }
05627 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
05628 {
05629 NdrClearOutParameters(
05630 ( PMIDL_STUB_MESSAGE )&_StubMsg,
05631 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[2],
05632 ( void __RPC_FAR * )pVal);
05633 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
05634 }
05635 RpcEndExcept
05636 return _RetVal;
05637 }
05638
05639 void __RPC_STUB IFDMDownload_get_DownloadText_Stub(
05640 IRpcStubBuffer *This,
05641 IRpcChannelBuffer *_pRpcChannelBuffer,
05642 PRPC_MESSAGE _pRpcMessage,
05643 DWORD *_pdwStubPhase)
05644 {
05645 BSTR _M21;
05646 HRESULT _RetVal;
05647 MIDL_STUB_MESSAGE _StubMsg;
05648 long nTextIndex;
05649 BSTR __RPC_FAR *pVal;
05650
05651 NdrStubInitialize(
05652 _pRpcMessage,
05653 &_StubMsg,
05654 &Object_StubDesc,
05655 _pRpcChannelBuffer);
05656 ( BSTR __RPC_FAR * )pVal = 0;
05657 RpcTryFinally
05658 {
05659 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
05660 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[30] );
05661
05662 nTextIndex = *(( long __RPC_FAR * )_StubMsg.Buffer)++;
05663
05664 pVal = &_M21;
05665 MIDL_memset(
05666 pVal,
05667 0,
05668 sizeof( BSTR ));
05669
05670 *_pdwStubPhase = STUB_CALL_SERVER;
05671 _RetVal = (((IFDMDownload*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_DownloadText(
05672 (IFDMDownload *) ((CStdStubBuffer *)This)->pvServerObject,
05673 nTextIndex,
05674 pVal);
05675
05676 *_pdwStubPhase = STUB_MARSHAL;
05677
05678 _StubMsg.BufferLength = 8U + 11U;
05679 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
05680 (unsigned char __RPC_FAR *)pVal,
05681 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
05682
05683 _StubMsg.BufferLength += 16;
05684
05685 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
05686 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
05687 (unsigned char __RPC_FAR *)pVal,
05688 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[30] );
05689
05690 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
05691 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
05692
05693 }
05694 RpcFinally
05695 {
05696 NdrPointerFree( &_StubMsg,
05697 (unsigned char __RPC_FAR *)pVal,
05698 &__MIDL_TypeFormatString.Format[2] );
05699
05700 }
05701 RpcEndFinally
05702 _pRpcMessage->BufferLength =
05703 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
05704
05705 }
05706
05707 CINTERFACE_PROXY_VTABLE(10) _IFDMDownloadProxyVtbl =
05708 {
05709 &IID_IFDMDownload,
05710 IUnknown_QueryInterface_Proxy,
05711 IUnknown_AddRef_Proxy,
05712 IUnknown_Release_Proxy ,
05713 0 ,
05714 0 ,
05715 0 ,
05716 0 ,
05717 IFDMDownload_get_Url_Proxy ,
05718 IFDMDownload_put_Url_Proxy ,
05719 IFDMDownload_get_DownloadText_Proxy
05720 };
05721
05722
05723 static const PRPC_STUB_FUNCTION IFDMDownload_table[] =
05724 {
05725 STUB_FORWARDING_FUNCTION,
05726 STUB_FORWARDING_FUNCTION,
05727 STUB_FORWARDING_FUNCTION,
05728 STUB_FORWARDING_FUNCTION,
05729 IFDMDownload_get_Url_Stub,
05730 IFDMDownload_put_Url_Stub,
05731 IFDMDownload_get_DownloadText_Stub
05732 };
05733
05734 CInterfaceStubVtbl _IFDMDownloadStubVtbl =
05735 {
05736 &IID_IFDMDownload,
05737 0,
05738 10,
05739 &IFDMDownload_table[-3],
05740 CStdStubBuffer_DELEGATING_METHODS
05741 };
05742
05743
05744
05745
05746
05747
05748 extern const MIDL_STUB_DESC Object_StubDesc;
05749
05750
05751 #pragma code_seg(".orpc")
05752
05753 HRESULT STDMETHODCALLTYPE IFDMDownloadsStat_get_DownloadCount_Proxy(
05754 IFDMDownloadsStat __RPC_FAR * This,
05755 long __RPC_FAR *pVal)
05756 {
05757
05758 HRESULT _RetVal;
05759
05760 RPC_MESSAGE _RpcMessage;
05761
05762 MIDL_STUB_MESSAGE _StubMsg;
05763
05764 RpcTryExcept
05765 {
05766 NdrProxyInitialize(
05767 ( void __RPC_FAR * )This,
05768 ( PRPC_MESSAGE )&_RpcMessage,
05769 ( PMIDL_STUB_MESSAGE )&_StubMsg,
05770 ( PMIDL_STUB_DESC )&Object_StubDesc,
05771 7);
05772
05773
05774
05775 if(!pVal)
05776 {
05777 RpcRaiseException(RPC_X_NULL_REF_POINTER);
05778 }
05779 RpcTryFinally
05780 {
05781
05782 _StubMsg.BufferLength = 0U;
05783 NdrProxyGetBuffer(This, &_StubMsg);
05784 NdrProxySendReceive(This, &_StubMsg);
05785
05786 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
05787 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[14] );
05788
05789 *pVal = *(( long __RPC_FAR * )_StubMsg.Buffer)++;
05790
05791 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
05792
05793 }
05794 RpcFinally
05795 {
05796 NdrProxyFreeBuffer(This, &_StubMsg);
05797
05798 }
05799 RpcEndFinally
05800
05801 }
05802 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
05803 {
05804 NdrClearOutParameters(
05805 ( PMIDL_STUB_MESSAGE )&_StubMsg,
05806 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[54],
05807 ( void __RPC_FAR * )pVal);
05808 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
05809 }
05810 RpcEndExcept
05811 return _RetVal;
05812 }
05813
05814 void __RPC_STUB IFDMDownloadsStat_get_DownloadCount_Stub(
05815 IRpcStubBuffer *This,
05816 IRpcChannelBuffer *_pRpcChannelBuffer,
05817 PRPC_MESSAGE _pRpcMessage,
05818 DWORD *_pdwStubPhase)
05819 {
05820 long _M22;
05821 HRESULT _RetVal;
05822 MIDL_STUB_MESSAGE _StubMsg;
05823 long __RPC_FAR *pVal;
05824
05825 NdrStubInitialize(
05826 _pRpcMessage,
05827 &_StubMsg,
05828 &Object_StubDesc,
05829 _pRpcChannelBuffer);
05830 ( long __RPC_FAR * )pVal = 0;
05831 RpcTryFinally
05832 {
05833 pVal = &_M22;
05834
05835 *_pdwStubPhase = STUB_CALL_SERVER;
05836 _RetVal = (((IFDMDownloadsStat*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_DownloadCount((IFDMDownloadsStat *) ((CStdStubBuffer *)This)->pvServerObject,pVal);
05837
05838 *_pdwStubPhase = STUB_MARSHAL;
05839
05840 _StubMsg.BufferLength = 4U + 4U;
05841 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
05842 *(( long __RPC_FAR * )_StubMsg.Buffer)++ = *pVal;
05843
05844 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
05845
05846 }
05847 RpcFinally
05848 {
05849 }
05850 RpcEndFinally
05851 _pRpcMessage->BufferLength =
05852 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
05853
05854 }
05855
05856
05857 HRESULT STDMETHODCALLTYPE IFDMDownloadsStat_get_Download_Proxy(
05858 IFDMDownloadsStat __RPC_FAR * This,
05859 long nIndex,
05860 IFDMDownload __RPC_FAR *__RPC_FAR *pVal)
05861 {
05862
05863 HRESULT _RetVal;
05864
05865 RPC_MESSAGE _RpcMessage;
05866
05867 MIDL_STUB_MESSAGE _StubMsg;
05868
05869 if(pVal)
05870 {
05871 MIDL_memset(
05872 pVal,
05873 0,
05874 sizeof( IFDMDownload __RPC_FAR *__RPC_FAR * ));
05875 }
05876 RpcTryExcept
05877 {
05878 NdrProxyInitialize(
05879 ( void __RPC_FAR * )This,
05880 ( PRPC_MESSAGE )&_RpcMessage,
05881 ( PMIDL_STUB_MESSAGE )&_StubMsg,
05882 ( PMIDL_STUB_DESC )&Object_StubDesc,
05883 8);
05884
05885
05886
05887 if(!pVal)
05888 {
05889 RpcRaiseException(RPC_X_NULL_REF_POINTER);
05890 }
05891 RpcTryFinally
05892 {
05893
05894 _StubMsg.BufferLength = 4U;
05895 NdrProxyGetBuffer(This, &_StubMsg);
05896 *(( long __RPC_FAR * )_StubMsg.Buffer)++ = nIndex;
05897
05898 NdrProxySendReceive(This, &_StubMsg);
05899
05900 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
05901 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[38] );
05902
05903 NdrPointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
05904 (unsigned char __RPC_FAR * __RPC_FAR *)&pVal,
05905 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[76],
05906 (unsigned char)0 );
05907
05908 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
05909 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
05910
05911 }
05912 RpcFinally
05913 {
05914 NdrProxyFreeBuffer(This, &_StubMsg);
05915
05916 }
05917 RpcEndFinally
05918
05919 }
05920 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
05921 {
05922 NdrClearOutParameters(
05923 ( PMIDL_STUB_MESSAGE )&_StubMsg,
05924 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[76],
05925 ( void __RPC_FAR * )pVal);
05926 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
05927 }
05928 RpcEndExcept
05929 return _RetVal;
05930 }
05931
05932 void __RPC_STUB IFDMDownloadsStat_get_Download_Stub(
05933 IRpcStubBuffer *This,
05934 IRpcChannelBuffer *_pRpcChannelBuffer,
05935 PRPC_MESSAGE _pRpcMessage,
05936 DWORD *_pdwStubPhase)
05937 {
05938 IFDMDownload __RPC_FAR *_M23;
05939 HRESULT _RetVal;
05940 MIDL_STUB_MESSAGE _StubMsg;
05941 long nIndex;
05942 IFDMDownload __RPC_FAR *__RPC_FAR *pVal;
05943
05944 NdrStubInitialize(
05945 _pRpcMessage,
05946 &_StubMsg,
05947 &Object_StubDesc,
05948 _pRpcChannelBuffer);
05949 ( IFDMDownload __RPC_FAR *__RPC_FAR * )pVal = 0;
05950 RpcTryFinally
05951 {
05952 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
05953 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[38] );
05954
05955 nIndex = *(( long __RPC_FAR * )_StubMsg.Buffer)++;
05956
05957 pVal = &_M23;
05958 _M23 = 0;
05959
05960 *_pdwStubPhase = STUB_CALL_SERVER;
05961 _RetVal = (((IFDMDownloadsStat*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_Download(
05962 (IFDMDownloadsStat *) ((CStdStubBuffer *)This)->pvServerObject,
05963 nIndex,
05964 pVal);
05965
05966 *_pdwStubPhase = STUB_MARSHAL;
05967
05968 _StubMsg.BufferLength = 0U + 4U;
05969 NdrPointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
05970 (unsigned char __RPC_FAR *)pVal,
05971 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[76] );
05972
05973 _StubMsg.BufferLength += 16;
05974
05975 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
05976 NdrPointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
05977 (unsigned char __RPC_FAR *)pVal,
05978 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[76] );
05979
05980 _StubMsg.Buffer = (unsigned char __RPC_FAR *)(((long)_StubMsg.Buffer + 3) & ~ 0x3);
05981 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
05982
05983 }
05984 RpcFinally
05985 {
05986 NdrPointerFree( &_StubMsg,
05987 (unsigned char __RPC_FAR *)pVal,
05988 &__MIDL_TypeFormatString.Format[76] );
05989
05990 }
05991 RpcEndFinally
05992 _pRpcMessage->BufferLength =
05993 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
05994
05995 }
05996
05997
05998 HRESULT STDMETHODCALLTYPE IFDMDownloadsStat_BuildListOfDownloads_Proxy(
05999 IFDMDownloadsStat __RPC_FAR * This,
06000 BOOL bIncludeCompleted,
06001 BOOL bIncludeRunning)
06002 {
06003
06004 HRESULT _RetVal;
06005
06006 RPC_MESSAGE _RpcMessage;
06007
06008 MIDL_STUB_MESSAGE _StubMsg;
06009
06010 RpcTryExcept
06011 {
06012 NdrProxyInitialize(
06013 ( void __RPC_FAR * )This,
06014 ( PRPC_MESSAGE )&_RpcMessage,
06015 ( PMIDL_STUB_MESSAGE )&_StubMsg,
06016 ( PMIDL_STUB_DESC )&Object_StubDesc,
06017 9);
06018
06019
06020
06021 RpcTryFinally
06022 {
06023
06024 _StubMsg.BufferLength = 4U + 4U;
06025 NdrProxyGetBuffer(This, &_StubMsg);
06026 *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = bIncludeCompleted;
06027
06028 *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = bIncludeRunning;
06029
06030 NdrProxySendReceive(This, &_StubMsg);
06031
06032 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
06033 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[46] );
06034
06035 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
06036
06037 }
06038 RpcFinally
06039 {
06040 NdrProxyFreeBuffer(This, &_StubMsg);
06041
06042 }
06043 RpcEndFinally
06044
06045 }
06046 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
06047 {
06048 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
06049 }
06050 RpcEndExcept
06051 return _RetVal;
06052 }
06053
06054 void __RPC_STUB IFDMDownloadsStat_BuildListOfDownloads_Stub(
06055 IRpcStubBuffer *This,
06056 IRpcChannelBuffer *_pRpcChannelBuffer,
06057 PRPC_MESSAGE _pRpcMessage,
06058 DWORD *_pdwStubPhase)
06059 {
06060 HRESULT _RetVal;
06061 MIDL_STUB_MESSAGE _StubMsg;
06062 BOOL bIncludeCompleted;
06063 BOOL bIncludeRunning;
06064
06065 NdrStubInitialize(
06066 _pRpcMessage,
06067 &_StubMsg,
06068 &Object_StubDesc,
06069 _pRpcChannelBuffer);
06070 RpcTryFinally
06071 {
06072 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
06073 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[46] );
06074
06075 bIncludeCompleted = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
06076
06077 bIncludeRunning = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
06078
06079
06080 *_pdwStubPhase = STUB_CALL_SERVER;
06081 _RetVal = (((IFDMDownloadsStat*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> BuildListOfDownloads(
06082 (IFDMDownloadsStat *) ((CStdStubBuffer *)This)->pvServerObject,
06083 bIncludeCompleted,
06084 bIncludeRunning);
06085
06086 *_pdwStubPhase = STUB_MARSHAL;
06087
06088 _StubMsg.BufferLength = 4U;
06089 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
06090 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
06091
06092 }
06093 RpcFinally
06094 {
06095 }
06096 RpcEndFinally
06097 _pRpcMessage->BufferLength =
06098 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
06099
06100 }
06101
06102 CINTERFACE_PROXY_VTABLE(10) _IFDMDownloadsStatProxyVtbl =
06103 {
06104 &IID_IFDMDownloadsStat,
06105 IUnknown_QueryInterface_Proxy,
06106 IUnknown_AddRef_Proxy,
06107 IUnknown_Release_Proxy ,
06108 0 ,
06109 0 ,
06110 0 ,
06111 0 ,
06112 IFDMDownloadsStat_get_DownloadCount_Proxy ,
06113 IFDMDownloadsStat_get_Download_Proxy ,
06114 IFDMDownloadsStat_BuildListOfDownloads_Proxy
06115 };
06116
06117
06118 static const PRPC_STUB_FUNCTION IFDMDownloadsStat_table[] =
06119 {
06120 STUB_FORWARDING_FUNCTION,
06121 STUB_FORWARDING_FUNCTION,
06122 STUB_FORWARDING_FUNCTION,
06123 STUB_FORWARDING_FUNCTION,
06124 IFDMDownloadsStat_get_DownloadCount_Stub,
06125 IFDMDownloadsStat_get_Download_Stub,
06126 IFDMDownloadsStat_BuildListOfDownloads_Stub
06127 };
06128
06129 CInterfaceStubVtbl _IFDMDownloadsStatStubVtbl =
06130 {
06131 &IID_IFDMDownloadsStat,
06132 0,
06133 10,
06134 &IFDMDownloadsStat_table[-3],
06135 CStdStubBuffer_DELEGATING_METHODS
06136 };
06137
06138
06139
06140
06141
06142
06143 extern const MIDL_STUB_DESC Object_StubDesc;
06144
06145
06146 #pragma code_seg(".orpc")
06147
06148 HRESULT STDMETHODCALLTYPE IFdmTorrentFilesRcvr_CreateBtDownloadFromFile_Proxy(
06149 IFdmTorrentFilesRcvr __RPC_FAR * This,
06150 BSTR bstrFile)
06151 {
06152
06153 HRESULT _RetVal;
06154
06155 RPC_MESSAGE _RpcMessage;
06156
06157 MIDL_STUB_MESSAGE _StubMsg;
06158
06159 RpcTryExcept
06160 {
06161 NdrProxyInitialize(
06162 ( void __RPC_FAR * )This,
06163 ( PRPC_MESSAGE )&_RpcMessage,
06164 ( PMIDL_STUB_MESSAGE )&_StubMsg,
06165 ( PMIDL_STUB_DESC )&Object_StubDesc,
06166 7);
06167
06168
06169
06170 RpcTryFinally
06171 {
06172
06173 _StubMsg.BufferLength = 8U;
06174 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
06175 (unsigned char __RPC_FAR *)&bstrFile,
06176 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
06177
06178 NdrProxyGetBuffer(This, &_StubMsg);
06179 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
06180 (unsigned char __RPC_FAR *)&bstrFile,
06181 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
06182
06183 NdrProxySendReceive(This, &_StubMsg);
06184
06185 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
06186 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
06187
06188 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
06189
06190 }
06191 RpcFinally
06192 {
06193 NdrProxyFreeBuffer(This, &_StubMsg);
06194
06195 }
06196 RpcEndFinally
06197
06198 }
06199 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
06200 {
06201 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
06202 }
06203 RpcEndExcept
06204 return _RetVal;
06205 }
06206
06207 void __RPC_STUB IFdmTorrentFilesRcvr_CreateBtDownloadFromFile_Stub(
06208 IRpcStubBuffer *This,
06209 IRpcChannelBuffer *_pRpcChannelBuffer,
06210 PRPC_MESSAGE _pRpcMessage,
06211 DWORD *_pdwStubPhase)
06212 {
06213 HRESULT _RetVal;
06214 MIDL_STUB_MESSAGE _StubMsg;
06215 void __RPC_FAR *_p_bstrFile;
06216 BSTR bstrFile;
06217
06218 NdrStubInitialize(
06219 _pRpcMessage,
06220 &_StubMsg,
06221 &Object_StubDesc,
06222 _pRpcChannelBuffer);
06223 _p_bstrFile = &bstrFile;
06224 MIDL_memset(
06225 _p_bstrFile,
06226 0,
06227 sizeof( BSTR ));
06228 RpcTryFinally
06229 {
06230 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
06231 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
06232
06233 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
06234 (unsigned char __RPC_FAR * __RPC_FAR *)&_p_bstrFile,
06235 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44],
06236 (unsigned char)0 );
06237
06238
06239 *_pdwStubPhase = STUB_CALL_SERVER;
06240 _RetVal = (((IFdmTorrentFilesRcvr*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> CreateBtDownloadFromFile((IFdmTorrentFilesRcvr *) ((CStdStubBuffer *)This)->pvServerObject,bstrFile);
06241
06242 *_pdwStubPhase = STUB_MARSHAL;
06243
06244 _StubMsg.BufferLength = 4U;
06245 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
06246 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
06247
06248 }
06249 RpcFinally
06250 {
06251 NdrUserMarshalFree( &_StubMsg,
06252 (unsigned char __RPC_FAR *)&bstrFile,
06253 &__MIDL_TypeFormatString.Format[44] );
06254
06255 }
06256 RpcEndFinally
06257 _pRpcMessage->BufferLength =
06258 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
06259
06260 }
06261
06262
06263 HRESULT STDMETHODCALLTYPE IFdmTorrentFilesRcvr_get_ForceSilent_Proxy(
06264 IFdmTorrentFilesRcvr __RPC_FAR * This,
06265 BOOL __RPC_FAR *pVal)
06266 {
06267
06268 HRESULT _RetVal;
06269
06270 RPC_MESSAGE _RpcMessage;
06271
06272 MIDL_STUB_MESSAGE _StubMsg;
06273
06274 RpcTryExcept
06275 {
06276 NdrProxyInitialize(
06277 ( void __RPC_FAR * )This,
06278 ( PRPC_MESSAGE )&_RpcMessage,
06279 ( PMIDL_STUB_MESSAGE )&_StubMsg,
06280 ( PMIDL_STUB_DESC )&Object_StubDesc,
06281 8);
06282
06283
06284
06285 if(!pVal)
06286 {
06287 RpcRaiseException(RPC_X_NULL_REF_POINTER);
06288 }
06289 RpcTryFinally
06290 {
06291
06292 _StubMsg.BufferLength = 0U;
06293 NdrProxyGetBuffer(This, &_StubMsg);
06294 NdrProxySendReceive(This, &_StubMsg);
06295
06296 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
06297 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[14] );
06298
06299 *pVal = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
06300
06301 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
06302
06303 }
06304 RpcFinally
06305 {
06306 NdrProxyFreeBuffer(This, &_StubMsg);
06307
06308 }
06309 RpcEndFinally
06310
06311 }
06312 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
06313 {
06314 NdrClearOutParameters(
06315 ( PMIDL_STUB_MESSAGE )&_StubMsg,
06316 ( PFORMAT_STRING )&__MIDL_TypeFormatString.Format[54],
06317 ( void __RPC_FAR * )pVal);
06318 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
06319 }
06320 RpcEndExcept
06321 return _RetVal;
06322 }
06323
06324 void __RPC_STUB IFdmTorrentFilesRcvr_get_ForceSilent_Stub(
06325 IRpcStubBuffer *This,
06326 IRpcChannelBuffer *_pRpcChannelBuffer,
06327 PRPC_MESSAGE _pRpcMessage,
06328 DWORD *_pdwStubPhase)
06329 {
06330 BOOL _M24;
06331 HRESULT _RetVal;
06332 MIDL_STUB_MESSAGE _StubMsg;
06333 BOOL __RPC_FAR *pVal;
06334
06335 NdrStubInitialize(
06336 _pRpcMessage,
06337 &_StubMsg,
06338 &Object_StubDesc,
06339 _pRpcChannelBuffer);
06340 ( BOOL __RPC_FAR * )pVal = 0;
06341 RpcTryFinally
06342 {
06343 pVal = &_M24;
06344
06345 *_pdwStubPhase = STUB_CALL_SERVER;
06346 _RetVal = (((IFdmTorrentFilesRcvr*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> get_ForceSilent((IFdmTorrentFilesRcvr *) ((CStdStubBuffer *)This)->pvServerObject,pVal);
06347
06348 *_pdwStubPhase = STUB_MARSHAL;
06349
06350 _StubMsg.BufferLength = 4U + 4U;
06351 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
06352 *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = *pVal;
06353
06354 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
06355
06356 }
06357 RpcFinally
06358 {
06359 }
06360 RpcEndFinally
06361 _pRpcMessage->BufferLength =
06362 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
06363
06364 }
06365
06366
06367 HRESULT STDMETHODCALLTYPE IFdmTorrentFilesRcvr_put_ForceSilent_Proxy(
06368 IFdmTorrentFilesRcvr __RPC_FAR * This,
06369 BOOL newVal)
06370 {
06371
06372 HRESULT _RetVal;
06373
06374 RPC_MESSAGE _RpcMessage;
06375
06376 MIDL_STUB_MESSAGE _StubMsg;
06377
06378 RpcTryExcept
06379 {
06380 NdrProxyInitialize(
06381 ( void __RPC_FAR * )This,
06382 ( PRPC_MESSAGE )&_RpcMessage,
06383 ( PMIDL_STUB_MESSAGE )&_StubMsg,
06384 ( PMIDL_STUB_DESC )&Object_StubDesc,
06385 9);
06386
06387
06388
06389 RpcTryFinally
06390 {
06391
06392 _StubMsg.BufferLength = 4U;
06393 NdrProxyGetBuffer(This, &_StubMsg);
06394 *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++ = newVal;
06395
06396 NdrProxySendReceive(This, &_StubMsg);
06397
06398 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
06399 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
06400
06401 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
06402
06403 }
06404 RpcFinally
06405 {
06406 NdrProxyFreeBuffer(This, &_StubMsg);
06407
06408 }
06409 RpcEndFinally
06410
06411 }
06412 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
06413 {
06414 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
06415 }
06416 RpcEndExcept
06417 return _RetVal;
06418 }
06419
06420 void __RPC_STUB IFdmTorrentFilesRcvr_put_ForceSilent_Stub(
06421 IRpcStubBuffer *This,
06422 IRpcChannelBuffer *_pRpcChannelBuffer,
06423 PRPC_MESSAGE _pRpcMessage,
06424 DWORD *_pdwStubPhase)
06425 {
06426 HRESULT _RetVal;
06427 MIDL_STUB_MESSAGE _StubMsg;
06428 BOOL newVal;
06429
06430 NdrStubInitialize(
06431 _pRpcMessage,
06432 &_StubMsg,
06433 &Object_StubDesc,
06434 _pRpcChannelBuffer);
06435 RpcTryFinally
06436 {
06437 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
06438 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[20] );
06439
06440 newVal = *(( BOOL __RPC_FAR * )_StubMsg.Buffer)++;
06441
06442
06443 *_pdwStubPhase = STUB_CALL_SERVER;
06444 _RetVal = (((IFdmTorrentFilesRcvr*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> put_ForceSilent((IFdmTorrentFilesRcvr *) ((CStdStubBuffer *)This)->pvServerObject,newVal);
06445
06446 *_pdwStubPhase = STUB_MARSHAL;
06447
06448 _StubMsg.BufferLength = 4U;
06449 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
06450 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
06451
06452 }
06453 RpcFinally
06454 {
06455 }
06456 RpcEndFinally
06457 _pRpcMessage->BufferLength =
06458 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
06459
06460 }
06461
06462 CINTERFACE_PROXY_VTABLE(10) _IFdmTorrentFilesRcvrProxyVtbl =
06463 {
06464 &IID_IFdmTorrentFilesRcvr,
06465 IUnknown_QueryInterface_Proxy,
06466 IUnknown_AddRef_Proxy,
06467 IUnknown_Release_Proxy ,
06468 0 ,
06469 0 ,
06470 0 ,
06471 0 ,
06472 IFdmTorrentFilesRcvr_CreateBtDownloadFromFile_Proxy ,
06473 IFdmTorrentFilesRcvr_get_ForceSilent_Proxy ,
06474 IFdmTorrentFilesRcvr_put_ForceSilent_Proxy
06475 };
06476
06477
06478 static const PRPC_STUB_FUNCTION IFdmTorrentFilesRcvr_table[] =
06479 {
06480 STUB_FORWARDING_FUNCTION,
06481 STUB_FORWARDING_FUNCTION,
06482 STUB_FORWARDING_FUNCTION,
06483 STUB_FORWARDING_FUNCTION,
06484 IFdmTorrentFilesRcvr_CreateBtDownloadFromFile_Stub,
06485 IFdmTorrentFilesRcvr_get_ForceSilent_Stub,
06486 IFdmTorrentFilesRcvr_put_ForceSilent_Stub
06487 };
06488
06489 CInterfaceStubVtbl _IFdmTorrentFilesRcvrStubVtbl =
06490 {
06491 &IID_IFdmTorrentFilesRcvr,
06492 0,
06493 10,
06494 &IFdmTorrentFilesRcvr_table[-3],
06495 CStdStubBuffer_DELEGATING_METHODS
06496 };
06497
06498
06499
06500
06501
06502
06503 extern const MIDL_STUB_DESC Object_StubDesc;
06504
06505
06506 #pragma code_seg(".orpc")
06507
06508 HRESULT STDMETHODCALLTYPE IFDMFlashVideoDownloads_ProcessIeDocument_Proxy(
06509 IFDMFlashVideoDownloads __RPC_FAR * This,
06510 IDispatch __RPC_FAR *pDispatch)
06511 {
06512
06513 HRESULT _RetVal;
06514
06515 RPC_MESSAGE _RpcMessage;
06516
06517 MIDL_STUB_MESSAGE _StubMsg;
06518
06519 RpcTryExcept
06520 {
06521 NdrProxyInitialize(
06522 ( void __RPC_FAR * )This,
06523 ( PRPC_MESSAGE )&_RpcMessage,
06524 ( PMIDL_STUB_MESSAGE )&_StubMsg,
06525 ( PMIDL_STUB_DESC )&Object_StubDesc,
06526 7);
06527
06528
06529
06530 RpcTryFinally
06531 {
06532
06533 _StubMsg.BufferLength = 0U;
06534 NdrInterfacePointerBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
06535 (unsigned char __RPC_FAR *)pDispatch,
06536 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[58] );
06537
06538 NdrProxyGetBuffer(This, &_StubMsg);
06539 NdrInterfacePointerMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
06540 (unsigned char __RPC_FAR *)pDispatch,
06541 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[58] );
06542
06543 NdrProxySendReceive(This, &_StubMsg);
06544
06545 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
06546 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[24] );
06547
06548 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
06549
06550 }
06551 RpcFinally
06552 {
06553 NdrProxyFreeBuffer(This, &_StubMsg);
06554
06555 }
06556 RpcEndFinally
06557
06558 }
06559 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
06560 {
06561 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
06562 }
06563 RpcEndExcept
06564 return _RetVal;
06565 }
06566
06567 void __RPC_STUB IFDMFlashVideoDownloads_ProcessIeDocument_Stub(
06568 IRpcStubBuffer *This,
06569 IRpcChannelBuffer *_pRpcChannelBuffer,
06570 PRPC_MESSAGE _pRpcMessage,
06571 DWORD *_pdwStubPhase)
06572 {
06573 HRESULT _RetVal;
06574 MIDL_STUB_MESSAGE _StubMsg;
06575 IDispatch __RPC_FAR *pDispatch;
06576
06577 NdrStubInitialize(
06578 _pRpcMessage,
06579 &_StubMsg,
06580 &Object_StubDesc,
06581 _pRpcChannelBuffer);
06582 pDispatch = 0;
06583 RpcTryFinally
06584 {
06585 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
06586 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[24] );
06587
06588 NdrInterfacePointerUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
06589 (unsigned char __RPC_FAR * __RPC_FAR *)&pDispatch,
06590 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[58],
06591 (unsigned char)0 );
06592
06593
06594 *_pdwStubPhase = STUB_CALL_SERVER;
06595 _RetVal = (((IFDMFlashVideoDownloads*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> ProcessIeDocument((IFDMFlashVideoDownloads *) ((CStdStubBuffer *)This)->pvServerObject,pDispatch);
06596
06597 *_pdwStubPhase = STUB_MARSHAL;
06598
06599 _StubMsg.BufferLength = 4U;
06600 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
06601 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
06602
06603 }
06604 RpcFinally
06605 {
06606 NdrInterfacePointerFree( &_StubMsg,
06607 (unsigned char __RPC_FAR *)pDispatch,
06608 &__MIDL_TypeFormatString.Format[58] );
06609
06610 }
06611 RpcEndFinally
06612 _pRpcMessage->BufferLength =
06613 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
06614
06615 }
06616
06617
06618 HRESULT STDMETHODCALLTYPE IFDMFlashVideoDownloads_ProcessHtml_Proxy(
06619 IFDMFlashVideoDownloads __RPC_FAR * This,
06620 BSTR bstrHost,
06621 BSTR bstrHtml)
06622 {
06623
06624 HRESULT _RetVal;
06625
06626 RPC_MESSAGE _RpcMessage;
06627
06628 MIDL_STUB_MESSAGE _StubMsg;
06629
06630 RpcTryExcept
06631 {
06632 NdrProxyInitialize(
06633 ( void __RPC_FAR * )This,
06634 ( PRPC_MESSAGE )&_RpcMessage,
06635 ( PMIDL_STUB_MESSAGE )&_StubMsg,
06636 ( PMIDL_STUB_DESC )&Object_StubDesc,
06637 8);
06638
06639
06640
06641 RpcTryFinally
06642 {
06643
06644 _StubMsg.BufferLength = 8U + 15U;
06645 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
06646 (unsigned char __RPC_FAR *)&bstrHost,
06647 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
06648
06649 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
06650 (unsigned char __RPC_FAR *)&bstrHtml,
06651 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
06652
06653 NdrProxyGetBuffer(This, &_StubMsg);
06654 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
06655 (unsigned char __RPC_FAR *)&bstrHost,
06656 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
06657
06658 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
06659 (unsigned char __RPC_FAR *)&bstrHtml,
06660 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
06661
06662 NdrProxySendReceive(This, &_StubMsg);
06663
06664 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
06665 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[52] );
06666
06667 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
06668
06669 }
06670 RpcFinally
06671 {
06672 NdrProxyFreeBuffer(This, &_StubMsg);
06673
06674 }
06675 RpcEndFinally
06676
06677 }
06678 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
06679 {
06680 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
06681 }
06682 RpcEndExcept
06683 return _RetVal;
06684 }
06685
06686 void __RPC_STUB IFDMFlashVideoDownloads_ProcessHtml_Stub(
06687 IRpcStubBuffer *This,
06688 IRpcChannelBuffer *_pRpcChannelBuffer,
06689 PRPC_MESSAGE _pRpcMessage,
06690 DWORD *_pdwStubPhase)
06691 {
06692 HRESULT _RetVal;
06693 MIDL_STUB_MESSAGE _StubMsg;
06694 void __RPC_FAR *_p_bstrHost;
06695 void __RPC_FAR *_p_bstrHtml;
06696 BSTR bstrHost;
06697 BSTR bstrHtml;
06698
06699 NdrStubInitialize(
06700 _pRpcMessage,
06701 &_StubMsg,
06702 &Object_StubDesc,
06703 _pRpcChannelBuffer);
06704 _p_bstrHost = &bstrHost;
06705 MIDL_memset(
06706 _p_bstrHost,
06707 0,
06708 sizeof( BSTR ));
06709 _p_bstrHtml = &bstrHtml;
06710 MIDL_memset(
06711 _p_bstrHtml,
06712 0,
06713 sizeof( BSTR ));
06714 RpcTryFinally
06715 {
06716 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
06717 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[52] );
06718
06719 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
06720 (unsigned char __RPC_FAR * __RPC_FAR *)&_p_bstrHost,
06721 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44],
06722 (unsigned char)0 );
06723
06724 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
06725 (unsigned char __RPC_FAR * __RPC_FAR *)&_p_bstrHtml,
06726 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44],
06727 (unsigned char)0 );
06728
06729
06730 *_pdwStubPhase = STUB_CALL_SERVER;
06731 _RetVal = (((IFDMFlashVideoDownloads*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> ProcessHtml(
06732 (IFDMFlashVideoDownloads *) ((CStdStubBuffer *)This)->pvServerObject,
06733 bstrHost,
06734 bstrHtml);
06735
06736 *_pdwStubPhase = STUB_MARSHAL;
06737
06738 _StubMsg.BufferLength = 4U;
06739 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
06740 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
06741
06742 }
06743 RpcFinally
06744 {
06745 NdrUserMarshalFree( &_StubMsg,
06746 (unsigned char __RPC_FAR *)&bstrHost,
06747 &__MIDL_TypeFormatString.Format[44] );
06748
06749 NdrUserMarshalFree( &_StubMsg,
06750 (unsigned char __RPC_FAR *)&bstrHtml,
06751 &__MIDL_TypeFormatString.Format[44] );
06752
06753 }
06754 RpcEndFinally
06755 _pRpcMessage->BufferLength =
06756 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
06757
06758 }
06759
06760
06761 HRESULT STDMETHODCALLTYPE IFDMFlashVideoDownloads_CreateFromUrl_Proxy(
06762 IFDMFlashVideoDownloads __RPC_FAR * This,
06763 BSTR bstrUrl)
06764 {
06765
06766 HRESULT _RetVal;
06767
06768 RPC_MESSAGE _RpcMessage;
06769
06770 MIDL_STUB_MESSAGE _StubMsg;
06771
06772 RpcTryExcept
06773 {
06774 NdrProxyInitialize(
06775 ( void __RPC_FAR * )This,
06776 ( PRPC_MESSAGE )&_RpcMessage,
06777 ( PMIDL_STUB_MESSAGE )&_StubMsg,
06778 ( PMIDL_STUB_DESC )&Object_StubDesc,
06779 9);
06780
06781
06782
06783 RpcTryFinally
06784 {
06785
06786 _StubMsg.BufferLength = 8U;
06787 NdrUserMarshalBufferSize( (PMIDL_STUB_MESSAGE) &_StubMsg,
06788 (unsigned char __RPC_FAR *)&bstrUrl,
06789 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
06790
06791 NdrProxyGetBuffer(This, &_StubMsg);
06792 NdrUserMarshalMarshall( (PMIDL_STUB_MESSAGE)& _StubMsg,
06793 (unsigned char __RPC_FAR *)&bstrUrl,
06794 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44] );
06795
06796 NdrProxySendReceive(This, &_StubMsg);
06797
06798 if ( (_RpcMessage.DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
06799 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
06800
06801 _RetVal = *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++;
06802
06803 }
06804 RpcFinally
06805 {
06806 NdrProxyFreeBuffer(This, &_StubMsg);
06807
06808 }
06809 RpcEndFinally
06810
06811 }
06812 RpcExcept(_StubMsg.dwStubPhase != PROXY_SENDRECEIVE)
06813 {
06814 _RetVal = NdrProxyErrorHandler(RpcExceptionCode());
06815 }
06816 RpcEndExcept
06817 return _RetVal;
06818 }
06819
06820 void __RPC_STUB IFDMFlashVideoDownloads_CreateFromUrl_Stub(
06821 IRpcStubBuffer *This,
06822 IRpcChannelBuffer *_pRpcChannelBuffer,
06823 PRPC_MESSAGE _pRpcMessage,
06824 DWORD *_pdwStubPhase)
06825 {
06826 HRESULT _RetVal;
06827 MIDL_STUB_MESSAGE _StubMsg;
06828 void __RPC_FAR *_p_bstrUrl;
06829 BSTR bstrUrl;
06830
06831 NdrStubInitialize(
06832 _pRpcMessage,
06833 &_StubMsg,
06834 &Object_StubDesc,
06835 _pRpcChannelBuffer);
06836 _p_bstrUrl = &bstrUrl;
06837 MIDL_memset(
06838 _p_bstrUrl,
06839 0,
06840 sizeof( BSTR ));
06841 RpcTryFinally
06842 {
06843 if ( (_pRpcMessage->DataRepresentation & 0X0000FFFFUL) != NDR_LOCAL_DATA_REPRESENTATION )
06844 NdrConvert( (PMIDL_STUB_MESSAGE) &_StubMsg, (PFORMAT_STRING) &__MIDL_ProcFormatString.Format[6] );
06845
06846 NdrUserMarshalUnmarshall( (PMIDL_STUB_MESSAGE) &_StubMsg,
06847 (unsigned char __RPC_FAR * __RPC_FAR *)&_p_bstrUrl,
06848 (PFORMAT_STRING) &__MIDL_TypeFormatString.Format[44],
06849 (unsigned char)0 );
06850
06851
06852 *_pdwStubPhase = STUB_CALL_SERVER;
06853 _RetVal = (((IFDMFlashVideoDownloads*) ((CStdStubBuffer *)This)->pvServerObject)->lpVtbl) -> CreateFromUrl((IFDMFlashVideoDownloads *) ((CStdStubBuffer *)This)->pvServerObject,bstrUrl);
06854
06855 *_pdwStubPhase = STUB_MARSHAL;
06856
06857 _StubMsg.BufferLength = 4U;
06858 NdrStubGetBuffer(This, _pRpcChannelBuffer, &_StubMsg);
06859 *(( HRESULT __RPC_FAR * )_StubMsg.Buffer)++ = _RetVal;
06860
06861 }
06862 RpcFinally
06863 {
06864 NdrUserMarshalFree( &_StubMsg,
06865 (unsigned char __RPC_FAR *)&bstrUrl,
06866 &__MIDL_TypeFormatString.Format[44] );
06867
06868 }
06869 RpcEndFinally
06870 _pRpcMessage->BufferLength =
06871 (unsigned int)((long)_StubMsg.Buffer - (long)_pRpcMessage->Buffer);
06872
06873 }
06874
06875 extern const USER_MARSHAL_ROUTINE_QUADRUPLE UserMarshalRoutines[1];
06876
06877 static const MIDL_STUB_DESC Object_StubDesc =
06878 {
06879 0,
06880 NdrOleAllocate,
06881 NdrOleFree,
06882 0,
06883 0,
06884 0,
06885 0,
06886 0,
06887 __MIDL_TypeFormatString.Format,
06888 1,
06889 0x20000,
06890 0,
06891 0x50100a4,
06892 0,
06893 UserMarshalRoutines,
06894 0,
06895 1,
06896 0,
06897 0,
06898 0
06899 };
06900
06901 CINTERFACE_PROXY_VTABLE(10) _IFDMFlashVideoDownloadsProxyVtbl =
06902 {
06903 &IID_IFDMFlashVideoDownloads,
06904 IUnknown_QueryInterface_Proxy,
06905 IUnknown_AddRef_Proxy,
06906 IUnknown_Release_Proxy ,
06907 0 ,
06908 0 ,
06909 0 ,
06910 0 ,
06911 IFDMFlashVideoDownloads_ProcessIeDocument_Proxy ,
06912 IFDMFlashVideoDownloads_ProcessHtml_Proxy ,
06913 IFDMFlashVideoDownloads_CreateFromUrl_Proxy
06914 };
06915
06916
06917 static const PRPC_STUB_FUNCTION IFDMFlashVideoDownloads_table[] =
06918 {
06919 STUB_FORWARDING_FUNCTION,
06920 STUB_FORWARDING_FUNCTION,
06921 STUB_FORWARDING_FUNCTION,
06922 STUB_FORWARDING_FUNCTION,
06923 IFDMFlashVideoDownloads_ProcessIeDocument_Stub,
06924 IFDMFlashVideoDownloads_ProcessHtml_Stub,
06925 IFDMFlashVideoDownloads_CreateFromUrl_Stub
06926 };
06927
06928 CInterfaceStubVtbl _IFDMFlashVideoDownloadsStubVtbl =
06929 {
06930 &IID_IFDMFlashVideoDownloads,
06931 0,
06932 10,
06933 &IFDMFlashVideoDownloads_table[-3],
06934 CStdStubBuffer_DELEGATING_METHODS
06935 };
06936
06937 #pragma data_seg(".rdata")
06938
06939 static const USER_MARSHAL_ROUTINE_QUADRUPLE UserMarshalRoutines[1] =
06940 {
06941
06942 {
06943 BSTR_UserSize
06944 ,BSTR_UserMarshal
06945 ,BSTR_UserUnmarshal
06946 ,BSTR_UserFree
06947 }
06948
06949 };
06950
06951
06952 #if !defined(__RPC_WIN32__)
06953 #error Invalid build platform for this stub.
06954 #endif
06955
06956 #if !(TARGET_IS_NT40_OR_LATER)
06957 #error You need a Windows NT 4.0 or later to run this stub because it uses these features:
06958 #error [wire_marshal] or [user_marshal] attribute.
06959 #error However, your C/C++ compilation flags indicate you intend to run this app on earlier systems.
06960 #error This app will die there with the RPC_X_WRONG_STUB_VERSION error.
06961 #endif
06962
06963
06964 static const MIDL_PROC_FORMAT_STRING __MIDL_ProcFormatString =
06965 {
06966 0,
06967 {
06968
06969 0x51,
06970 #ifndef _ALPHA_
06971 0x1,
06972 #else
06973 0x2,
06974 #endif
06975 NdrFcShort( 0x2 ),
06976 0x53,
06977 0x8,
06978
06979 0x4d,
06980 #ifndef _ALPHA_
06981 0x1,
06982 #else
06983 0x2,
06984 #endif
06985 NdrFcShort( 0x2c ),
06986 0x53,
06987 0x8,
06988 0x53,
06989 0x8,
06990
06991 0x51,
06992 #ifndef _ALPHA_
06993 0x1,
06994 #else
06995 0x2,
06996 #endif
06997 NdrFcShort( 0x36 ),
06998 0x53,
06999 0x8,
07000 0x4e,
07001 0x8,
07002 0x53,
07003 0x8,
07004
07005 0x4d,
07006 #ifndef _ALPHA_
07007 0x1,
07008 #else
07009 0x2,
07010 #endif
07011 NdrFcShort( 0x3a ),
07012 0x53,
07013 0x8,
07014 0x4e,
07015 0x8,
07016
07017 0x51,
07018 #ifndef _ALPHA_
07019 0x1,
07020 #else
07021 0x2,
07022 #endif
07023 NdrFcShort( 0x2 ),
07024 0x53,
07025 0x8,
07026 0x4e,
07027 0x8,
07028
07029 0x51,
07030 #ifndef _ALPHA_
07031 0x1,
07032 #else
07033 0x2,
07034 #endif
07035 NdrFcShort( 0x4c ),
07036 0x53,
07037 0x8,
07038 0x4e,
07039 0x8,
07040 0x4e,
07041 0x8,
07042 0x53,
07043 0x8,
07044
07045 0x4d,
07046 #ifndef _ALPHA_
07047 0x1,
07048 #else
07049 0x2,
07050 #endif
07051 NdrFcShort( 0x2c ),
07052
07053 0x4d,
07054 #ifndef _ALPHA_
07055 0x1,
07056 #else
07057 0x2,
07058 #endif
07059 NdrFcShort( 0x2c ),
07060 0x53,
07061 0x8,
07062
07063 0x0
07064 }
07065 };
07066
07067 static const MIDL_TYPE_FORMAT_STRING __MIDL_TypeFormatString =
07068 {
07069 0,
07070 {
07071 NdrFcShort( 0x0 ),
07072
07073 0x11, 0x4,
07074 NdrFcShort( 0x1a ),
07075
07076 0x13, 0x0,
07077 NdrFcShort( 0xc ),
07078
07079 0x1b,
07080 0x1,
07081 NdrFcShort( 0x2 ),
07082 0x9,
07083 0x0,
07084 NdrFcShort( 0xfffc ),
07085 0x6,
07086 0x5b,
07087
07088 0x17,
07089 0x3,
07090 NdrFcShort( 0x8 ),
07091 NdrFcShort( 0xfffffff2 ),
07092 0x8,
07093 0x8,
07094 0x5c,
07095 0x5b,
07096 0xb4,
07097 0x83,
07098 NdrFcShort( 0x0 ),
07099 NdrFcShort( 0x4 ),
07100 NdrFcShort( 0x0 ),
07101 NdrFcShort( 0xffffffe0 ),
07102
07103 0x12, 0x0,
07104 NdrFcShort( 0xffffffea ),
07105 0xb4,
07106 0x83,
07107 NdrFcShort( 0x0 ),
07108 NdrFcShort( 0x4 ),
07109 NdrFcShort( 0x0 ),
07110 NdrFcShort( 0xfffffff4 ),
07111
07112 0x11, 0xc,
07113 0x8,
07114 0x5c,
07115
07116 0x2f,
07117 0x5a,
07118 NdrFcLong( 0x20400 ),
07119 NdrFcShort( 0x0 ),
07120 NdrFcShort( 0x0 ),
07121 0xc0,
07122 0x0,
07123 0x0,
07124 0x0,
07125 0x0,
07126 0x0,
07127 0x0,
07128 0x46,
07129
07130 0x11, 0x14,
07131 NdrFcShort( 0x2 ),
07132
07133 0x2f,
07134 0x5a,
07135 NdrFcLong( 0x8f2b3016 ),
07136 NdrFcShort( 0x17d4 ),
07137 NdrFcShort( 0x447a ),
07138 0xb2,
07139 0x7,
07140 0xff,
07141 0xa8,
07142 0x95,
07143 0x7a,
07144 0x83,
07145 0x4a,
07146
07147 0x0
07148 }
07149 };
07150
07151 const CInterfaceProxyVtbl * _Fdm_ProxyVtblList[] =
07152 {
07153 ( CInterfaceProxyVtbl *) &_IFDMDownloadProxyVtbl,
07154 ( CInterfaceProxyVtbl *) &_IWGUrlReceiverProxyVtbl,
07155 ( CInterfaceProxyVtbl *) &_IFDMProxyVtbl,
07156 ( CInterfaceProxyVtbl *) &_IFDMFlashVideoDownloadsProxyVtbl,
07157 ( CInterfaceProxyVtbl *) &_IWGUrlListReceiverProxyVtbl,
07158 ( CInterfaceProxyVtbl *) &_IFdmTorrentFilesRcvrProxyVtbl,
07159 ( CInterfaceProxyVtbl *) &_IFDMDownloadsStatProxyVtbl,
07160 0
07161 };
07162
07163 const CInterfaceStubVtbl * _Fdm_StubVtblList[] =
07164 {
07165 ( CInterfaceStubVtbl *) &_IFDMDownloadStubVtbl,
07166 ( CInterfaceStubVtbl *) &_IWGUrlReceiverStubVtbl,
07167 ( CInterfaceStubVtbl *) &_IFDMStubVtbl,
07168 ( CInterfaceStubVtbl *) &_IFDMFlashVideoDownloadsStubVtbl,
07169 ( CInterfaceStubVtbl *) &_IWGUrlListReceiverStubVtbl,
07170 ( CInterfaceStubVtbl *) &_IFdmTorrentFilesRcvrStubVtbl,
07171 ( CInterfaceStubVtbl *) &_IFDMDownloadsStatStubVtbl,
07172 0
07173 };
07174
07175 PCInterfaceName const _Fdm_InterfaceNamesList[] =
07176 {
07177 "IFDMDownload",
07178 "IWGUrlReceiver",
07179 "IFDM",
07180 "IFDMFlashVideoDownloads",
07181 "IWGUrlListReceiver",
07182 "IFdmTorrentFilesRcvr",
07183 "IFDMDownloadsStat",
07184 0
07185 };
07186
07187 const IID * _Fdm_BaseIIDList[] =
07188 {
07189 &IID_IDispatch,
07190 &IID_IDispatch,
07191 &IID_IDispatch,
07192 &IID_IDispatch,
07193 &IID_IDispatch,
07194 &IID_IDispatch,
07195 &IID_IDispatch,
07196 0
07197 };
07198
07199
07200 #define _Fdm_CHECK_IID(n) IID_GENERIC_CHECK_IID( _Fdm, pIID, n)
07201
07202 int __stdcall _Fdm_IID_Lookup( const IID * pIID, int * pIndex )
07203 {
07204 IID_BS_LOOKUP_SETUP
07205
07206 IID_BS_LOOKUP_INITIAL_TEST( _Fdm, 7, 4 )
07207 IID_BS_LOOKUP_NEXT_TEST( _Fdm, 2 )
07208 IID_BS_LOOKUP_NEXT_TEST( _Fdm, 1 )
07209 IID_BS_LOOKUP_RETURN_RESULT( _Fdm, 7, *pIndex )
07210
07211 }
07212
07213 const ExtendedProxyFileInfo Fdm_ProxyFileInfo =
07214 {
07215 (PCInterfaceProxyVtblList *) & _Fdm_ProxyVtblList,
07216 (PCInterfaceStubVtblList *) & _Fdm_StubVtblList,
07217 (const PCInterfaceName * ) & _Fdm_InterfaceNamesList,
07218 (const IID ** ) & _Fdm_BaseIIDList,
07219 & _Fdm_IID_Lookup,
07220 7,
07221 1,
07222 0,
07223 0,
07224 0,
07225 0
07226 };
