00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015 #ifndef ___HxCorbaVideoPlayer_h__
00016 #define ___HxCorbaVideoPlayer_h__
00017
00018 #ifndef OB_INTEGER_VERSION
00019 # error No ORBacus version defined! Is <OB/CORBA.h> included?
00020 #endif
00021
00022 #ifndef OB_NO_VERSION_CHECK
00023 # if (OB_INTEGER_VERSION != 4010000L)
00024 # error ORBacus version mismatch!
00025 # endif
00026 #endif
00027
00028 namespace HxCorba
00029 {
00030
00031 class VideoPlayer;
00032 typedef VideoPlayer* VideoPlayer_ptr;
00033 typedef VideoPlayer* VideoPlayerRef;
00034
00035 extern OB::TypeCodeConst _tc_VideoPlayer;
00036
00037 class VideoPlayerFactory;
00038 typedef VideoPlayerFactory* VideoPlayerFactory_ptr;
00039 typedef VideoPlayerFactory* VideoPlayerFactoryRef;
00040
00041 extern OB::TypeCodeConst _tc_VideoPlayerFactory;
00042
00043 }
00044
00045 void OBDuplicate(HxCorba::VideoPlayer_ptr);
00046 void OBRelease(HxCorba::VideoPlayer_ptr);
00047
00048 void OBMarshal(HxCorba::VideoPlayer_ptr, OB::OutputStreamImpl*);
00049 void OBUnmarshal(HxCorba::VideoPlayer_ptr&, OB::InputStreamImpl*);
00050
00051 void OBDuplicate(HxCorba::VideoPlayerFactory_ptr);
00052 void OBRelease(HxCorba::VideoPlayerFactory_ptr);
00053
00054 void OBMarshal(HxCorba::VideoPlayerFactory_ptr, OB::OutputStreamImpl*);
00055 void OBUnmarshal(HxCorba::VideoPlayerFactory_ptr&, OB::InputStreamImpl*);
00056
00057 namespace HxCorba
00058 {
00059
00060 typedef OB::ObjVar< VideoPlayer > VideoPlayer_var;
00061 typedef OB::ObjOut< VideoPlayer > VideoPlayer_out;
00062
00063 typedef OB::ObjVar< VideoPlayerFactory > VideoPlayerFactory_var;
00064 typedef OB::ObjOut< VideoPlayerFactory > VideoPlayerFactory_out;
00065
00066 }
00067
00068 namespace OBStubImpl_HxCorba
00069 {
00070
00071 class VideoPlayer;
00072 typedef VideoPlayer* VideoPlayer_ptr;
00073
00074 class VideoPlayerFactory;
00075 typedef VideoPlayerFactory* VideoPlayerFactory_ptr;
00076
00077 }
00078
00079 void OBDuplicate(OBStubImpl_HxCorba::VideoPlayer_ptr);
00080 void OBRelease(OBStubImpl_HxCorba::VideoPlayer_ptr);
00081
00082 void OBDuplicate(OBStubImpl_HxCorba::VideoPlayerFactory_ptr);
00083 void OBRelease(OBStubImpl_HxCorba::VideoPlayerFactory_ptr);
00084
00085 namespace OBStubImpl_HxCorba
00086 {
00087
00088 typedef OB::ObjVar< VideoPlayer > VideoPlayer_var;
00089
00090 typedef OB::ObjVar< VideoPlayerFactory > VideoPlayerFactory_var;
00091
00092 }
00093
00094
00095
00096
00097 namespace HxCorba
00098 {
00099
00100
00101
00102
00103 class VideoPlayer : virtual public CORBA::Object
00104 {
00105 VideoPlayer(const VideoPlayer&);
00106 void operator=(const VideoPlayer&);
00107
00108 protected:
00109
00110 static const char* ids_[];
00111
00112 public:
00113
00114 VideoPlayer() { }
00115 virtual ~VideoPlayer() { }
00116
00117 typedef VideoPlayer_ptr _ptr_type;
00118 typedef VideoPlayer_var _var_type;
00119
00120 static inline VideoPlayer_ptr
00121 _duplicate(VideoPlayer_ptr p)
00122 {
00123 if(p)
00124 p -> _add_ref();
00125 return p;
00126 }
00127
00128 static inline VideoPlayer_ptr
00129 _nil()
00130 {
00131 return 0;
00132 }
00133
00134 static VideoPlayer_ptr _narrow(CORBA::Object_ptr);
00135 static VideoPlayer_ptr _unchecked_narrow(CORBA::Object_ptr);
00136
00137 static VideoPlayer_ptr _narrow(CORBA::AbstractBase_ptr);
00138 static VideoPlayer_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00139
00140 static const char** _OB_staticIds();
00141
00142
00143
00144
00145 virtual void play() = 0;
00146
00147
00148
00149
00150 virtual void stop() = 0;
00151
00152
00153
00154
00155 virtual void seek(CORBA::Long frame) = 0;
00156
00157
00158
00159
00160 virtual void close() = 0;
00161 };
00162
00163
00164
00165
00166 class VideoPlayerFactory : virtual public CORBA::Object
00167 {
00168 VideoPlayerFactory(const VideoPlayerFactory&);
00169 void operator=(const VideoPlayerFactory&);
00170
00171 protected:
00172
00173 static const char* ids_[];
00174
00175 public:
00176
00177 VideoPlayerFactory() { }
00178 virtual ~VideoPlayerFactory() { }
00179
00180 typedef VideoPlayerFactory_ptr _ptr_type;
00181 typedef VideoPlayerFactory_var _var_type;
00182
00183 static inline VideoPlayerFactory_ptr
00184 _duplicate(VideoPlayerFactory_ptr p)
00185 {
00186 if(p)
00187 p -> _add_ref();
00188 return p;
00189 }
00190
00191 static inline VideoPlayerFactory_ptr
00192 _nil()
00193 {
00194 return 0;
00195 }
00196
00197 static VideoPlayerFactory_ptr _narrow(CORBA::Object_ptr);
00198 static VideoPlayerFactory_ptr _unchecked_narrow(CORBA::Object_ptr);
00199
00200 static VideoPlayerFactory_ptr _narrow(CORBA::AbstractBase_ptr);
00201 static VideoPlayerFactory_ptr _unchecked_narrow(CORBA::AbstractBase_ptr);
00202
00203 static const char** _OB_staticIds();
00204
00205
00206
00207
00208 virtual VideoPlayer_ptr makeFullPlayer(const char* fileName) = 0;
00209
00210
00211
00212
00213 virtual VideoPlayer_ptr makeAudioPlayer(const char* fileName) = 0;
00214 };
00215
00216 }
00217
00218
00219
00220
00221 namespace OBProxy_HxCorba
00222 {
00223
00224
00225
00226
00227 class VideoPlayer : virtual public ::HxCorba::VideoPlayer,
00228 virtual public OBCORBA::Object
00229 {
00230 VideoPlayer(const VideoPlayer&);
00231 void operator=(const VideoPlayer&);
00232
00233 protected:
00234
00235 virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
00236
00237 public:
00238
00239 VideoPlayer() { }
00240 virtual ~VideoPlayer() { }
00241
00242 virtual const char** _OB_ids() const;
00243
00244
00245
00246
00247 void play();
00248
00249
00250
00251
00252 void stop();
00253
00254
00255
00256
00257 void seek(CORBA::Long frame);
00258
00259
00260
00261
00262 void close();
00263 };
00264
00265
00266
00267
00268 class VideoPlayerFactory : virtual public ::HxCorba::VideoPlayerFactory,
00269 virtual public OBCORBA::Object
00270 {
00271 VideoPlayerFactory(const VideoPlayerFactory&);
00272 void operator=(const VideoPlayerFactory&);
00273
00274 protected:
00275
00276 virtual OB::MarshalStubImpl_ptr _OB_createMarshalStubImpl();
00277
00278 public:
00279
00280 VideoPlayerFactory() { }
00281 virtual ~VideoPlayerFactory() { }
00282
00283 virtual const char** _OB_ids() const;
00284
00285
00286
00287
00288 ::HxCorba::VideoPlayer_ptr makeFullPlayer(const char* fileName);
00289
00290
00291
00292
00293 ::HxCorba::VideoPlayer_ptr makeAudioPlayer(const char* fileName);
00294 };
00295
00296 }
00297
00298
00299
00300
00301 namespace OBStubImpl_HxCorba
00302 {
00303
00304
00305
00306
00307 class VideoPlayer : virtual public OB::StubImplBase
00308 {
00309 VideoPlayer(const VideoPlayer&);
00310 void operator=(const VideoPlayer&);
00311
00312 protected:
00313
00314 VideoPlayer() { }
00315
00316 public:
00317
00318 static inline VideoPlayer_ptr
00319 _duplicate(VideoPlayer_ptr p)
00320 {
00321 if(p)
00322 p -> _OB_incRef();
00323 return p;
00324 }
00325
00326 static inline VideoPlayer_ptr
00327 _nil()
00328 {
00329 return 0;
00330 }
00331
00332
00333
00334
00335 virtual void play() = 0;
00336
00337
00338
00339
00340 virtual void stop() = 0;
00341
00342
00343
00344
00345 virtual void seek(CORBA::Long frame) = 0;
00346
00347
00348
00349
00350 virtual void close() = 0;
00351 };
00352
00353
00354
00355
00356 class VideoPlayerFactory : virtual public OB::StubImplBase
00357 {
00358 VideoPlayerFactory(const VideoPlayerFactory&);
00359 void operator=(const VideoPlayerFactory&);
00360
00361 protected:
00362
00363 VideoPlayerFactory() { }
00364
00365 public:
00366
00367 static inline VideoPlayerFactory_ptr
00368 _duplicate(VideoPlayerFactory_ptr p)
00369 {
00370 if(p)
00371 p -> _OB_incRef();
00372 return p;
00373 }
00374
00375 static inline VideoPlayerFactory_ptr
00376 _nil()
00377 {
00378 return 0;
00379 }
00380
00381
00382
00383
00384 virtual ::HxCorba::VideoPlayer_ptr makeFullPlayer(const char* fileName) = 0;
00385
00386
00387
00388
00389 virtual ::HxCorba::VideoPlayer_ptr makeAudioPlayer(const char* fileName) = 0;
00390 };
00391
00392 }
00393
00394
00395
00396
00397 namespace OBMarshalStubImpl_HxCorba
00398 {
00399
00400
00401
00402
00403 class VideoPlayer : virtual public OBStubImpl_HxCorba::VideoPlayer,
00404 virtual public OB::MarshalStubImpl
00405 {
00406 VideoPlayer(const VideoPlayer&);
00407 void operator=(const VideoPlayer&);
00408
00409 protected:
00410
00411 VideoPlayer() { }
00412 friend class OBProxy_HxCorba::VideoPlayer;
00413
00414 public:
00415
00416
00417
00418
00419 virtual void play();
00420
00421
00422
00423
00424 virtual void stop();
00425
00426
00427
00428
00429 virtual void seek(CORBA::Long frame);
00430
00431
00432
00433
00434 virtual void close();
00435 };
00436
00437
00438
00439
00440 class VideoPlayerFactory : virtual public OBStubImpl_HxCorba::VideoPlayerFactory,
00441 virtual public OB::MarshalStubImpl
00442 {
00443 VideoPlayerFactory(const VideoPlayerFactory&);
00444 void operator=(const VideoPlayerFactory&);
00445
00446 protected:
00447
00448 VideoPlayerFactory() { }
00449 friend class OBProxy_HxCorba::VideoPlayerFactory;
00450
00451 public:
00452
00453
00454
00455
00456 virtual ::HxCorba::VideoPlayer_ptr makeFullPlayer(const char* fileName);
00457
00458
00459
00460
00461 virtual ::HxCorba::VideoPlayer_ptr makeAudioPlayer(const char* fileName);
00462 };
00463
00464 }
00465
00466
00467
00468
00469 namespace OBV_HxCorba
00470 {
00471
00472 }
00473
00474
00475
00476
00477 namespace CORBA
00478 {
00479
00480 inline void
00481 release(::HxCorba::VideoPlayer_ptr p)
00482 {
00483 if(p)
00484 p -> _remove_ref();
00485 }
00486
00487 inline Boolean
00488 is_nil(::HxCorba::VideoPlayer_ptr p)
00489 {
00490 return p == 0;
00491 }
00492
00493 inline void
00494 release(OBStubImpl_HxCorba::VideoPlayer_ptr p)
00495 {
00496 if(p)
00497 p -> _OB_decRef();
00498 }
00499
00500 inline Boolean
00501 is_nil(OBStubImpl_HxCorba::VideoPlayer_ptr p)
00502 {
00503 return p == 0;
00504 }
00505
00506 }
00507
00508 void operator<<=(CORBA::Any&, HxCorba::VideoPlayer_ptr*);
00509 void operator<<=(CORBA::Any&, HxCorba::VideoPlayer_ptr);
00510 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::VideoPlayer_ptr&);
00511
00512 inline void
00513 operator<<=(CORBA::Any_var& any, HxCorba::VideoPlayer_ptr* val)
00514 {
00515 any.inout() <<= val;
00516 }
00517
00518 inline void
00519 operator<<=(CORBA::Any_var& any, HxCorba::VideoPlayer_ptr val)
00520 {
00521 any.inout() <<= val;
00522 }
00523
00524 inline CORBA::Boolean
00525 operator>>=(const CORBA::Any_var& any, HxCorba::VideoPlayer_ptr& val)
00526 {
00527 return any.in() >>= val;
00528 }
00529
00530
00531
00532
00533 namespace CORBA
00534 {
00535
00536 inline void
00537 release(::HxCorba::VideoPlayerFactory_ptr p)
00538 {
00539 if(p)
00540 p -> _remove_ref();
00541 }
00542
00543 inline Boolean
00544 is_nil(::HxCorba::VideoPlayerFactory_ptr p)
00545 {
00546 return p == 0;
00547 }
00548
00549 inline void
00550 release(OBStubImpl_HxCorba::VideoPlayerFactory_ptr p)
00551 {
00552 if(p)
00553 p -> _OB_decRef();
00554 }
00555
00556 inline Boolean
00557 is_nil(OBStubImpl_HxCorba::VideoPlayerFactory_ptr p)
00558 {
00559 return p == 0;
00560 }
00561
00562 }
00563
00564 void operator<<=(CORBA::Any&, HxCorba::VideoPlayerFactory_ptr*);
00565 void operator<<=(CORBA::Any&, HxCorba::VideoPlayerFactory_ptr);
00566 CORBA::Boolean operator>>=(const CORBA::Any&, HxCorba::VideoPlayerFactory_ptr&);
00567
00568 inline void
00569 operator<<=(CORBA::Any_var& any, HxCorba::VideoPlayerFactory_ptr* val)
00570 {
00571 any.inout() <<= val;
00572 }
00573
00574 inline void
00575 operator<<=(CORBA::Any_var& any, HxCorba::VideoPlayerFactory_ptr val)
00576 {
00577 any.inout() <<= val;
00578 }
00579
00580 inline CORBA::Boolean
00581 operator>>=(const CORBA::Any_var& any, HxCorba::VideoPlayerFactory_ptr& val)
00582 {
00583 return any.in() >>= val;
00584 }
00585
00586 #endif