S60UIExampleappui.inc
上传用户:laixiong
上传日期:2007-03-11
资源大小:2994k
文件大小:1144k
源码类别:

Symbian

开发平台:

C/C++

  1. template <class T>
  2. inline void CArrayVar<T>::InsertL(TInt anIndex,const T &aRef,TInt aLength)
  3. #line 1595
  4. {CArrayVarBase::InsertL(anIndex,&aRef,aLength);}
  5. template <class T>
  6. inline TInt CArrayVar<T>::InsertIsqL(const T &aRef,TInt aLength,TKeyArrayVar &aKey)
  7. #line 1628
  8. {return(CArrayVarBase::InsertIsqL(&aRef,aLength,aKey));}
  9. template <class T>
  10. inline TInt CArrayVar<T>::InsertIsqAllowDuplicatesL(const T &aRef,TInt aLength,TKeyArrayVar &aKey)
  11. #line 1658
  12. {return(CArrayVarBase::InsertIsqAllowDuplicatesL(&aRef,aLength,aKey));}
  13. template <class T>
  14. inline const TArray<T> CArrayVar<T>::Array() const
  15. {return(TArray<T>(CountR,AtR,this));}
  16. inline const TAny *CArrayVar<TAny>::At(TInt anIndex) const
  17. #line 1692
  18. {return(CArrayVarBase::At(anIndex));}
  19. inline CArrayVar<TAny>::CArrayVar(TBufRep aRep,TInt aGranularity)
  20. : CArrayVarBase(aRep,aGranularity)
  21. #line 1714
  22. {}
  23. inline TAny *CArrayVar<TAny>::At(TInt anIndex)
  24. #line 1736
  25. {return(CArrayVarBase::At(anIndex));}
  26. inline void CArrayVar<TAny>::AppendL(const TAny *aPtr,TInt aLength)
  27. {CArrayVarBase::InsertL(Count(),aPtr,aLength);}
  28. inline TAny *CArrayVar<TAny>::ExtendL(TInt aLength)
  29. #line 1773
  30. {return(CArrayVarBase::ExpandL(Count(),aLength));}
  31. template <class T>
  32. inline CArrayVarFlat<T>::CArrayVarFlat(TInt aGranularity)
  33. : CArrayVar<T>((TBufRep)CBufFlat::NewL,aGranularity)
  34. #line 1791
  35. {}
  36. template <class T>
  37. inline CArrayVarSeg<T>::CArrayVarSeg(TInt aGranularity)
  38. : CArrayVar<T>((TBufRep)CBufSeg::NewL,aGranularity)
  39. #line 1809
  40. {}
  41. inline TInt CArrayPakBase::Count() const
  42. {return(iCount);}
  43. template <class T>
  44. inline CArrayPak<T>::CArrayPak(TBufRep aRep,TInt aGranularity)
  45. : CArrayPakBase(aRep,aGranularity)
  46. {}
  47. template <class T>
  48. inline const T &CArrayPak<T>::operator[](TInt anIndex) const
  49. #line 1857
  50. {return(*((const T *)CArrayPakBase::At(anIndex)));}
  51. template <class T>
  52. inline T &CArrayPak<T>::operator[](TInt anIndex)
  53. #line 1881
  54. {return(*((T *)CArrayPakBase::At(anIndex)));}
  55. template <class T>
  56. inline const T &CArrayPak<T>::At(TInt anIndex) const
  57. #line 1905
  58. {return(*((const T *)CArrayPakBase::At(anIndex)));}
  59. template <class T>
  60. inline T &CArrayPak<T>::At(TInt anIndex)
  61. #line 1929
  62. {return(*((T *)CArrayPakBase::At(anIndex)));}
  63. template <class T>
  64. inline void CArrayPak<T>::AppendL(const T &aRef,TInt aLength)
  65. #line 1948
  66. {CArrayPakBase::InsertL(Count(),&aRef,aLength);}
  67. template <class T>
  68. inline T &CArrayPak<T>::ExpandL(TInt anIndex,TInt aLength)
  69. #line 1988
  70. {return(*new(CArrayPakBase::ExpandL(anIndex,aLength)) T);}
  71. template <class T>
  72. inline T &CArrayPak<T>::ExtendL(TInt aLength)
  73. #line 2021
  74. {return(*new(CArrayPakBase::ExpandL(Count(),aLength)) T);}
  75. template <class T>
  76. inline TInt CArrayPak<T>::Find(const T &aRef,TKeyArrayPak &aKey,TInt &anIndex) const
  77. #line 2051
  78. {return(CArrayPakBase::Find(&aRef,aKey,anIndex));}
  79. template <class T>
  80. inline TInt CArrayPak<T>::FindIsq(const T &aRef,TKeyArrayPak &aKey,TInt &anIndex) const
  81. #line 2088
  82. {return(CArrayPakBase::FindIsq(&aRef,aKey,anIndex));}
  83. template <class T>
  84. inline void CArrayPak<T>::InsertL(TInt anIndex,const T &aRef,TInt aLength)
  85. #line 2114
  86. {CArrayPakBase::InsertL(anIndex,&aRef,aLength);}
  87. template <class T>
  88. inline TInt CArrayPak<T>::InsertIsqL(const T &aRef,TInt aLength,TKeyArrayPak &aKey)
  89. #line 2146
  90. {return(CArrayPakBase::InsertIsqL(&aRef,aLength,aKey));}
  91. template <class T>
  92. inline TInt CArrayPak<T>::InsertIsqAllowDuplicatesL(const T &aRef,TInt aLength,TKeyArrayPak &aKey)
  93. #line 2175
  94. {return(CArrayPakBase::InsertIsqAllowDuplicatesL(&aRef,aLength,aKey));}
  95. template <class T>
  96. inline const TArray<T> CArrayPak<T>::Array() const
  97. {return(TArray<T>(CountR,AtR,this));}
  98. inline CArrayPak<TAny>::CArrayPak(TBufRep aRep,TInt aGranularity)
  99. : CArrayPakBase(aRep,aGranularity)
  100. #line 2209
  101. {}
  102. inline const TAny *CArrayPak<TAny>::At(TInt anIndex) const
  103. #line 2231
  104. {return(CArrayPakBase::At(anIndex));}
  105. inline TAny *CArrayPak<TAny>::At(TInt anIndex)
  106. #line 2253
  107. {return(CArrayPakBase::At(anIndex));}
  108. inline void CArrayPak<TAny>::AppendL(const TAny *aPtr,TInt aLength)
  109. #line 2269
  110. {CArrayPakBase::InsertL(Count(),aPtr,aLength);}
  111. inline TAny *CArrayPak<TAny>::ExtendL(TInt aLength)
  112. #line 2290
  113. {return(CArrayPakBase::ExpandL(Count(),aLength));}
  114. template <class T>
  115. inline CArrayPakFlat<T>::CArrayPakFlat(TInt aGranularity)
  116. : CArrayPak<T>((TBufRep)CBufFlat::NewL,aGranularity)
  117. #line 2308
  118. {}
  119. inline TInt CObject::UniqueID() const
  120. #line 2326
  121. {return(iContainer->UniqueID());}
  122. inline TInt CObject::AccessCount() const
  123. {return(iAccessCount);}
  124. inline void CObject::Inc()
  125. #line 2351
  126. {iAccessCount++;}
  127. inline void CObject::Dec()
  128. #line 2365
  129. {iAccessCount--;}
  130. inline CObject * CObject::Owner() const
  131. {return(iOwner);}
  132. inline void CObject::SetOwner(CObject *anOwner)
  133. #line 2393
  134. {iOwner=anOwner;}
  135. inline TInt CObjectIx::Count() const
  136. #line 2409
  137. {return iHighWaterMark;}
  138. inline TInt CObjectIx::ActiveCount() const
  139. {return iNumEntries;}
  140. inline TInt CObjectCon::UniqueID() const
  141. {return iUniqueID;}
  142. inline TInt CObjectCon::Count() const
  143. {return iCount;}
  144. inline TInt CCirBufBase::Count() const
  145. {return(iCount);}
  146. inline TInt CCirBufBase::Length() const
  147. #line 2474
  148. {return(iLength);}
  149. template <class T>
  150. inline CCirBuf<T>::CCirBuf()
  151. : CCirBufBase(sizeof(T))
  152. #line 2491
  153. {}
  154. template <class T>
  155. inline TInt CCirBuf<T>::Add(const T *aPtr)
  156. #line 2514
  157. {return(DoAdd((const TUint8 *)aPtr));}
  158. template <class T>
  159. inline TInt CCirBuf<T>::Add(const T *aPtr,TInt aCount)
  160. #line 2541
  161. {return(DoAdd((const TUint8 *)aPtr,aCount));}
  162. template <class T>
  163. inline TInt CCirBuf<T>::Remove(T *aPtr)
  164. #line 2560
  165. {return(DoRemove((TUint8 *)aPtr));}
  166. template <class T>
  167. inline TInt CCirBuf<T>::Remove(T *aPtr,TInt aCount)
  168. #line 2585
  169. {return(DoRemove((TUint8 *)aPtr,aCount));}
  170. inline TBool CActive::IsActive() const
  171. #line 2605
  172. {return(iStatus.iFlags&TRequestStatus::EActive);}
  173. inline TBool CActive::IsAdded() const
  174. #line 2628
  175. {return(iLink.iNext!=0 );}
  176. inline TInt CActive::Priority() const
  177. {return iLink.iPriority;}
  178. inline TDeltaTimerEntry::TDeltaTimerEntry(TCallBack& aCallback)
  179. {iCallBack=aCallback;}
  180. inline TDeltaTimerEntry::TDeltaTimerEntry()
  181. {}
  182. inline void TDeltaTimerEntry::Set(TCallBack& aCallback)
  183. {iCallBack=aCallback;}
  184. #line 2681
  185. inline const RMessage2 &CServer2::Message() const
  186. {return iMessage;}
  187. #line 2695
  188. inline const CServer2 *CSession2::Server() const
  189. {return iServer;}
  190. inline RThread& CAsyncOneShot::Thread()
  191. { return iThread; }
  192. inline TInt CActiveScheduler::Level() const
  193. #line 2724
  194. {return StackDepth();}
  195. inline TBool CActiveSchedulerWait::IsStarted() const
  196. #line 2743
  197. {return iLoop != 0 ;}
  198. inline void CleanupStack::Pop(TAny* aExpectedItem)
  199. #line 2768
  200. { CleanupStack::Check(aExpectedItem); CleanupStack::Pop(); }
  201. inline void CleanupStack::Pop(TInt aCount, TAny* aLastExpectedItem)
  202. #line 2795
  203. {
  204. if (--aCount)
  205. CleanupStack::Pop(aCount);
  206. CleanupStack::Check(aLastExpectedItem);
  207. CleanupStack::Pop();
  208. }
  209. inline void CleanupStack::PopAndDestroy(TAny* aExpectedItem)
  210. #line 2823
  211. { CleanupStack::Check(aExpectedItem); CleanupStack::PopAndDestroy(); }
  212. inline void CleanupStack::PopAndDestroy(TInt aCount, TAny* aLastExpectedItem)
  213. #line 2851
  214. {
  215. if (--aCount)
  216. CleanupStack::PopAndDestroy(aCount);
  217. CleanupStack::Check(aLastExpectedItem);
  218. CleanupStack::PopAndDestroy();
  219. }
  220. #line 2961
  221. inline TCleanupItem::TCleanupItem(TCleanupOperation anOperation)
  222. : iOperation(anOperation)
  223. {}
  224. inline TCleanupItem::TCleanupItem(TCleanupOperation anOperation,TAny *aPtr)
  225. : iOperation(anOperation), iPtr(aPtr)
  226. #line 2988
  227. {}
  228. inline CCleanup &TCleanupTrapHandler::Cleanup()
  229. {return(*iCleanup);}
  230. template <class T>
  231. inline TAutoClose<T>::~TAutoClose()
  232. {if (!std::uncaught_exception()) iObj.Close();}
  233. template <class T>
  234. inline void TAutoClose<T>::PushL()
  235. {CleanupStack::PushL(TCleanupItem(Close, (TAny *)&iObj));}
  236. template <class T>
  237. inline void TAutoClose<T>::Pop()
  238. {CleanupStack::Pop();}
  239. template <class T>
  240. void TAutoClose<T>::Close(TAny *aObj)
  241. {((T *)aObj)->Close();}
  242. template <class T>
  243. inline void CleanupDelete<T>::PushL(T* aPtr)
  244. #line 3053
  245. {CleanupStack::PushL(TCleanupItem(&Delete,aPtr));}
  246. template <class T>
  247. void CleanupDelete<T>::Delete(TAny *aPtr)
  248. {delete (static_cast<T*>(aPtr)) ;}
  249. template <class T>
  250. inline void CleanupDeletePushL(T* aPtr)
  251. {CleanupDelete<T>::PushL(aPtr);}
  252. template <class T>
  253. inline void CleanupArrayDelete<T>::PushL(T* aPtr)
  254. #line 3091
  255. {CleanupStack::PushL(TCleanupItem(&ArrayDelete,aPtr));}
  256. template <class T>
  257. void CleanupArrayDelete<T>::ArrayDelete(TAny *aPtr)
  258. {delete [] (static_cast<T*>(aPtr)) ;}
  259. template <class T>
  260. inline void CleanupArrayDeletePushL(T* aPtr)
  261. {CleanupArrayDelete<T>::PushL(aPtr);}
  262. template <class T>
  263. inline void CleanupClose<T>::PushL(T& aRef)
  264. {CleanupStack::PushL(TCleanupItem(&Close,&aRef));}
  265. template <class T>
  266. void CleanupClose<T>::Close(TAny *aPtr)
  267. {((static_cast<T*>(aPtr)) )->Close();}
  268. template <class T>
  269. inline void CleanupClosePushL(T& aRef)
  270. {CleanupClose<T>::PushL(aRef);}
  271. template <class T>
  272. inline void CleanupRelease<T>::PushL(T& aRef)
  273. {CleanupStack::PushL(TCleanupItem(&Release,&aRef));}
  274. template <class T>
  275. void CleanupRelease<T>::Release(TAny *aPtr)
  276. {((static_cast<T*>(aPtr)) )->Release();}
  277. template <class T>
  278. inline void CleanupReleasePushL(T& aRef)
  279. {CleanupRelease<T>::PushL(aRef);}
  280. #line 3245 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32base.h" /* stack depth 6 */
  281. #line 14 "C:\Symbian\9.1\S60_3rd\epoc32\include\coeaui.h" /* stack depth 5 */
  282. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\w32std.h" /* stack depth 6 */
  283. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\fntstore.h" /* stack depth 7 */
  284. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\f32file.h" /* stack depth 8 */
  285. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32svr.h" /* stack depth 9 */
  286. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32hal.h" /* stack depth 10 */
  287. #line 14
  288. const TInt KMaxRomDevices=8;
  289. #line 33
  290. enum TDigitizerCalibrationType
  291.     {
  292.     EFactory,
  293.     ESaved
  294.     };
  295. #line 61
  296. class TDigitizerCalibration
  297.     {
  298. public:
  299.     TPoint iTl;
  300.     TPoint iBl;
  301.     TPoint iTr;
  302.     TPoint iBr;
  303.     };
  304. #line 83
  305. enum TKeyboard
  306. {
  307. EKeyboard_Keypad=1,
  308. EKeyboard_Full=2,
  309. };
  310. #line 115
  311. class TKeyboardInfoV01
  312. {
  313. public:
  314. TInt iDeviceKeys;
  315. #line 135
  316.     TInt iAppsKeys;
  317. #line 148
  318. TKeyboard iKeyboardType;
  319.     };
  320. #line 162
  321. typedef TPckgBuf<TKeyboardInfoV01> TKeyboardInfoV01Buf;
  322. #line 182
  323. class TDigitiserInfoV01
  324. {
  325. public:
  326. TPoint iOffsetToDisplay;
  327. TSize iDigitiserSize;
  328. };
  329. #line 196
  330. class TDigitiserInfoV02 : public TDigitiserInfoV01
  331. {
  332. TInt iZRange;
  333. TUint8 iThetaSupported;
  334. TUint8 iPhiSupported;
  335. TUint8 iAlphaSupported;
  336. TUint8 iPressureSupported;
  337. };
  338. #line 214
  339. typedef TPckgBuf<TDigitiserInfoV01> TDigitiserInfoV01Buf;
  340. #line 224
  341. typedef TPckgBuf<TDigitiserInfoV02> TDigitiserInfoV02Buf;
  342. #line 241
  343. class TMouseInfoV01
  344. {
  345. public:
  346. TInt iMouseButtons;
  347. TPoint iOffsetToDisplay;
  348. TSize iMouseAreaSize;
  349. };
  350. #line 260
  351. typedef TPckgBuf<TMouseInfoV01> TMouseInfoV01Buf;
  352. #line 279
  353. class TVariantInfoV01
  354. {
  355. public:
  356. TVersion iRomVersion;
  357. SInt64 iMachineUniqueId;
  358.     TUint iLedCapabilities;
  359.     TInt iProcessorClockInKHz;
  360.     TInt iSpeedFactor;
  361.     };
  362. #line 321
  363. typedef TPckgBuf<TVariantInfoV01> TVariantInfoV01Buf;
  364. #line 334
  365. enum TMachineStartupType
  366. {
  367. EStartupCold,EStartupColdReset,EStartupNewOs,
  368. EStartupPowerFail,EStartupWarmReset,EStartupKernelFault,
  369. EStartupSafeReset
  370. };
  371. #line 350
  372. enum TXYInputType
  373. {
  374. EXYInputNone,
  375. EXYInputPointer,
  376. EXYInputMouse,
  377. EXYInputDeltaMouse
  378. };
  379. #line 367
  380. class TMachineInfoV1
  381. {
  382. public:
  383. TVersion iRomVersion;
  384. TXYInputType iXYInputType;
  385. TBool iKeyboardPresent;
  386. TBool iBacklightPresent;
  387.     TSize iDisplaySizeInPixels;
  388.     TSize iXYInputSizeInPixels;
  389.     TSize iPhysicalScreenSize;
  390. TPoint iOffsetToDisplayInPixels;
  391. TInt iKeyboardId;
  392. TInt iDisplayId;
  393. SInt64 iMachineUniqueId;
  394.     TUint iLedCapabilities;
  395.     TInt iProcessorClockInKHz;
  396.     TInt iSpeedFactor;
  397.     TInt iMaximumDisplayColors;
  398. };
  399. typedef TPckgBuf<TMachineInfoV1> TMachineInfoV1Buf;
  400. #line 401
  401. class TMachineInfoV2 : public TMachineInfoV1
  402. {
  403. public:
  404. TInt iLanguageIndex;
  405.     TInt iKeyboardIndex;
  406.     };
  407. typedef TPckgBuf<TMachineInfoV2> TMachineInfoV2Buf;
  408. #line 422
  409. class TMemoryInfoV1
  410.     {
  411. public:
  412.     TInt iTotalRamInBytes;
  413.     TInt iTotalRomInBytes;
  414.     TInt iMaxFreeRamInBytes;
  415.     TInt iFreeRamInBytes;
  416.     TInt iInternalDiskRamInBytes;
  417.     TBool iRomIsReprogrammable;
  418.     };
  419. typedef TPckgBuf<TMemoryInfoV1> TMemoryInfoV1Buf;
  420. #line 447
  421. class TRomInfoEntryV1
  422. {
  423. public:
  424.     enum TRomTypeV1
  425.      {
  426.      ERomTypeRom=0,
  427.      ERomTypeFlash=1
  428.      };
  429. TInt iSize;
  430. TInt iWidth;
  431. TInt iSpeed;
  432. TRomTypeV1 iType;
  433. };
  434. #line 470
  435. class TRomInfoV1
  436. {
  437. public:
  438. TRomInfoEntryV1 iEntry[KMaxRomDevices];
  439. };
  440. typedef TPckgBuf<TRomInfoV1> TRomInfoV1Buf;
  441. const TUint KRuggedFileSystem=0x01;
  442. class TDriveInfoV1
  443.     {
  444. public:
  445. TInt iTotalSupportedDrives;
  446. TInfoName iDriveName[KMaxLocalDrives];
  447. TInt iTotalSockets;
  448. TInfoName iSocketName[KMaxPBusSockets];
  449. TInt iRuggedFileSystem;
  450. TUint iRegisteredDriveBitmask;
  451. };
  452. typedef TPckgBuf<TDriveInfoV1> TDriveInfoV1Buf;
  453. class TDriveInfoV18
  454.     {
  455. public:
  456. TInt iTotalSupportedDrives;
  457. TBuf8<KMaxInfoName> iDriveName[KMaxLocalDrives];
  458. TInt iTotalSockets;
  459. TBuf8<KMaxInfoName> iSocketName[KMaxPBusSockets];
  460. TInt iRuggedFileSystem;
  461. TUint iRegisteredDriveBitmask;
  462. };
  463. typedef TPckgBuf<TDriveInfoV18> TDriveInfoV1Buf8;
  464. #line 536
  465. class TExcInfo
  466. {
  467. public:
  468. TAny *iCodeAddress;
  469. TAny *iDataAddress;
  470. TInt iExtraData;
  471. };
  472. #line 575
  473. class UserHal
  474. {
  475. public:
  476. __declspec(dllexport) static TInt MemoryInfo(TDes8& anInfo);
  477. __declspec(dllexport) static TInt RomInfo(TDes8& anInfo);
  478. __declspec(dllexport) static TInt StartupReason(TMachineStartupType& aReason);
  479. __declspec(dllexport) static TInt FaultReason(TInt &aReason);
  480. __declspec(dllexport) static TInt ExceptionId(TInt &anId);
  481. __declspec(dllexport) static TInt ExceptionInfo(TExcInfo &aInfo);
  482. __declspec(dllexport) static TInt PageSizeInBytes(TInt& aSize);
  483. __declspec(dllexport) static TInt MachineInfo(TDes8& anInfo);
  484. __declspec(dllexport) static TInt TickPeriod(TTimeIntervalMicroSeconds32& aPeriod);
  485. __declspec(dllexport) static TInt DriveInfo(TDes8& anInfo);
  486.     __declspec(dllexport) static TInt SwitchOff();
  487. __declspec(dllexport) static TInt SetXYInputCalibration(const TDigitizerCalibration& aCalibration);
  488. __declspec(dllexport) static TInt CalibrationPoints(TDigitizerCalibration& aCalibration);
  489. __declspec(dllexport) static TInt SaveXYInputCalibration();
  490. __declspec(dllexport) static TInt RestoreXYInputCalibration(TDigitizerCalibrationType aType);
  491. };
  492. #line 8 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32svr.h" /* stack depth 9 */
  493. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\d32locd.h" /* stack depth 10 */
  494. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\partitions.h" /* stack depth 11 */
  495. #line 15
  496. const TUint KPartitionTypeEmpty=0x00;
  497. const TUint KPartitionTypeFAT12=0x01;
  498. const TUint KPartitionTypeXENIXroot=0x02;
  499. const TUint KPartitionTypeXENIXusr=0x03;
  500. const TUint KPartitionTypeFAT16small=0x04;
  501. const TUint KPartitionTypeExtended=0x05;
  502. const TUint KPartitionTypeFAT16=0x06;
  503. const TUint KPartitionTypeNTFS=0x07;
  504. const TUint KPartitionTypeAIX=0x08;
  505. const TUint KPartitionTypeAIXboot=0x09;
  506. const TUint KPartitionTypeOS2BootManager=0x0a;
  507. const TUint KPartitionTypeWin95FAT32=0x0b;
  508. const TUint KPartitionTypeWin95FAT32LBA=0x0c;
  509. const TUint KPartitionTypeWin95FAT16LBA=0x0e;
  510. const TUint KPartitionTypeWin95ExtdLBA=0x0f;
  511. const TUint KPartitionTypeOPUS=0x10;
  512. const TUint KPartitionTypeHiddenFAT12=0x11;
  513. const TUint KPartitionTypeCompaqDiag=0x12;
  514. const TUint KPartitionTypeHiddenFAT16small=0x14;
  515. const TUint KPartitionTypeHiddenFAT16=0x16;
  516. const TUint KPartitionTypeHiddenNTFS=0x17;
  517. const TUint KPartitionTypeASTSmartSleep=0x18;
  518. const TUint KPartitionTypeHiddenWin95FAT32=0x1b;
  519. const TUint KPartitionTypeHiddenWin95FAT32LBA=0x1c;
  520. const TUint KPartitionTypeHiddenWin95FAT16LBA=0x1e;
  521. const TUint KPartitionTypeNECDOS=0x24;
  522. const TUint KPartitionTypePlan9=0x39;
  523. const TUint KPartitionTypePartitionMagic=0x3c;
  524. const TUint KPartitionTypeVenix80286=0x40;
  525. const TUint KPartitionTypePPCPRePBoot=0x41;
  526. const TUint KPartitionTypeSFS=0x42;
  527. const TUint KPartitionTypeQNX4x=0x4d;
  528. const TUint KPartitionTypeQNX4x_2=0x4e;
  529. const TUint KPartitionTypeQNX4x_3=0x4f;
  530. const TUint KPartitionTypeOnTrackDM=0x50;
  531. const TUint KPartitionTypeOnTrackDM6Aux=0x51;
  532. const TUint KPartitionTypeCPM=0x52;
  533. const TUint KPartitionTypeOnTrackDM6Aux_2=0x53;
  534. const TUint KPartitionTypeOnTrackDM6=0x54;
  535. const TUint KPartitionTypeEZDrive=0x55;
  536. const TUint KPartitionTypeGoldenBow=0x56;
  537. const TUint KPartitionTypePriamEdisk=0x5c;
  538. const TUint KPartitionTypeSpeedStor=0x61;
  539. const TUint KPartitionTypeGNU_HURD=0x63;
  540. const TUint KPartitionTypeNovellNetware=0x64;
  541. const TUint KPartitionTypeNovellNetware_2=0x65;
  542. const TUint KPartitionTypeDiskSecure=0x70;
  543. const TUint KPartitionTypePCIX=0x75;
  544. const TUint KPartitionTypeOldMinix=0x80;
  545. const TUint KPartitionTypeMinixOldLinux=0x81;
  546. const TUint KPartitionTypeLinuxSwap=0x82;
  547. const TUint KPartitionTypeLinux=0x83;
  548. const TUint KPartitionTypeOS2Hidden=0x84;
  549. const TUint KPartitionTypeLinuxExtended=0x85;
  550. const TUint KPartitionTypeNTFSvolset=0x86;
  551. const TUint KPartitionTypeNTFSvolset_2=0x87;
  552. const TUint KPartitionTypeLinuxLVM=0x8e;
  553. const TUint KPartitionTypeAmoeba=0x93;
  554. const TUint KPartitionTypeAmoebaBBT=0x94;
  555. const TUint KPartitionTypeBSD_OS=0x9f;
  556. const TUint KPartitionTypeIBMThinkpad=0xa0;
  557. const TUint KPartitionTypeFreeBSD=0xa5;
  558. const TUint KPartitionTypeOpenBSD=0xa6;
  559. const TUint KPartitionTypeNeXTSTEP=0xa7;
  560. const TUint KPartitionTypeNetBSD=0xa9;
  561. const TUint KPartitionTypeBSDIfs=0xb7;
  562. const TUint KPartitionTypeBSDIswap=0xb8;
  563. const TUint KPartitionTypeBootWizardHidden=0xbb;
  564. const TUint KPartitionTypeDRDOS=0xc1;
  565. const TUint KPartitionTypeDRDOS_2=0xc4;
  566. const TUint KPartitionTypeDRDOS_3=0xc6;
  567. const TUint KPartitionTypeSyrinx=0xc7;
  568. const TUint KPartitionTypeNonFSData=0xda;
  569. const TUint KPartitionTypeCPM_CTOS=0xdb;
  570. const TUint KPartitionTypeDellUtility=0xde;
  571. const TUint KPartitionTypeBootIt=0xdf;
  572. const TUint KPartitionTypeDOSaccess=0xe1;
  573. const TUint KPartitionTypeDOS_RO=0xe3;
  574. const TUint KPartitionTypeSymbianCrashLog=0xf0;
  575. const TUint KPartitionTypeSpeedStor_2=0xf1;
  576. const TUint KPartitionTypeDOSsecondary=0xf2;
  577. const TUint KPartitionTypeSpeedStor_3=0xf4;
  578. const TUint KPartitionTypeRofs=0xfa;
  579. const TUint KPartitionTypeIso9660=0xfb;
  580. const TUint KPartitionTypeEneaLFFS=0xfc;
  581. const TUint KPartitionTypeLinuxRaidAuto=0xfd;
  582. const TUint KPartitionTypeLANStep=0xfe;
  583. const TUint KPartitionTypeBBT=0xff;
  584. inline TBool PartitionIsFAT(TUint a)
  585. {
  586. return (
  587. a==KPartitionTypeFAT12 ||
  588. a==KPartitionTypeFAT16small ||
  589. a==KPartitionTypeFAT16 ||
  590. a==KPartitionTypeFAT16 ||
  591. a==KPartitionTypeWin95FAT16LBA ||
  592. a==KPartitionTypeHiddenFAT12 ||
  593. a==KPartitionTypeHiddenFAT16small ||
  594. a==KPartitionTypeHiddenFAT16 ||
  595. a==KPartitionTypeHiddenWin95FAT16LBA
  596. );
  597. }
  598. inline TBool PartitionIsFAT32(TUint a)
  599. {
  600. return (
  601. a==KPartitionTypeWin95FAT32 ||
  602. a==KPartitionTypeWin95FAT32LBA ||
  603. a==KPartitionTypeHiddenWin95FAT32 ||
  604. a==KPartitionTypeHiddenWin95FAT32LBA
  605. );
  606. }
  607. inline TBool PartitionIsNTFS(TUint a)
  608. {
  609. return (
  610. a==KPartitionTypeNTFS ||
  611. a==KPartitionTypeHiddenNTFS
  612. );
  613. }
  614. const TUint KBootIndicatorBootable=0x80;
  615. class TMBRPartitionEntry
  616. {
  617. public:
  618. TBool IsValidPartition()
  619. { return (iNumSectors>0 && iPartitionType!=KPartitionTypeEmpty); }
  620. TBool IsValidDosPartition()
  621. { return (iNumSectors>0 && PartitionIsFAT(iPartitionType)); }
  622. TBool IsDefaultBootPartition()
  623. { return(iX86BootIndicator==KBootIndicatorBootable && (IsValidDosPartition() || IsValidFAT32Partition())); }
  624. TBool IsValidFAT32Partition()
  625. { return (iNumSectors>0 && PartitionIsFAT32(iPartitionType)); }
  626. public:
  627. TUint8 iX86BootIndicator;
  628. TUint8 iStartHead;
  629. TUint8 iStartSector;
  630. TUint8 iStartCylinder;
  631. TUint8 iPartitionType;
  632. TUint8 iEndHead;
  633. TUint8 iEndSector;
  634. TUint8 iEndCylinder;
  635. TUint32 iFirstSector;
  636. TUint32 iNumSectors;
  637. };
  638. const TUint KMBRFirstPartitionOffset=0x1BE;
  639. const TUint KMBRSignatureOffset=0x1FE;
  640. const TUint KMBRSignature=0xAA55;
  641. const TInt KMBRMaxPrimaryPartitions=4;
  642. class TMasterBootRecord
  643. {
  644. public:
  645. TUint8 iBootCode[KMBRFirstPartitionOffset];
  646. TMBRPartitionEntry iPartitionEntry[KMBRMaxPrimaryPartitions];
  647. TUint16 iSignature;
  648. };
  649. #line 9 "C:\Symbian\9.1\S60_3rd\epoc32\include\d32locd.h" /* stack depth 10 */
  650. #line 21
  651. enum TMediaDevice { EFixedMedia0, EFixedMedia1, EFixedMedia2, EFixedMedia3,
  652. EFixedMedia4, EFixedMedia5, EFixedMedia6, EFixedMedia7,
  653. ERemovableMedia0, ERemovableMedia1, ERemovableMedia2, ERemovableMedia3,
  654. EInvalidMedia
  655. };
  656. #line 36
  657. typedef signed int TSocket;
  658. class TLDriveAssignInfo
  659. {
  660. public:
  661. TMediaDevice iDevice;
  662. TInt iPriority;
  663. };
  664. class TMediaDeviceAssignInfo
  665. {
  666. public:
  667. TInt iFirstMedia;
  668. TInt iLastMedia;
  669. };
  670. class TLocalDriveCaps
  671. {
  672. public:
  673. __declspec(dllexport) TLocalDriveCaps();
  674. public:
  675. TInt64 iSize;
  676. TMediaType iType;
  677. TBatteryState iBattery;
  678. TUint iDriveAtt;
  679. TUint iMediaAtt;
  680.     TUint8* iBaseAddress;
  681. TUint16 iFileSystemId;
  682. TUint16 iPartitionType;
  683. };
  684. typedef TPckgBuf<TLocalDriveCaps> TLocalDriveCapsBuf;
  685. class TLocalDriveCapsV2 : public TLocalDriveCaps
  686. {
  687. public:
  688. TUint iHiddenSectors;
  689. TUint iEraseBlockSize;
  690.     };
  691. typedef TPckgBuf<TLocalDriveCapsV2> TLocalDriveCapsV2Buf;
  692. class TLDFormatInfo
  693. {
  694. public:
  695. TInt64 iCapacity;
  696. TUint16 iSectorsPerCluster;
  697. TUint16 iSectorsPerTrack;
  698. TUint16 iNumberOfSides;
  699. enum TFATBits {EFBDontCare, EFB12 = 12, EFB16 = 16, EFB32 = 32};
  700. TFATBits iFATBits;
  701. TUint32 iPad;
  702. };
  703. typedef TPckgBuf<TLDFormatInfo> TSpecialFormatInfoBuf;
  704. class TLocalDriveCapsV3 : public TLocalDriveCapsV2
  705. {
  706. public:
  707. TLDFormatInfo iFormatInfo;
  708. TBool iExtraInfo;
  709. TInt iMaxBytesPerFormat;
  710.     };
  711. void __compile_time_assert(int __check[((((TInt)&(((TLocalDriveCaps *)0x1000)->iSize))-0x1000)%8 == 0)?1:-1]) ;
  712. void __compile_time_assert(int __check[((((TInt)&(((TLocalDriveCapsV3 *)0x1000)->iFormatInfo.iCapacity))-0x1000) % 8 == 0)?1:-1]) ;
  713. typedef TPckgBuf<TLocalDriveCapsV3> TLocalDriveCapsV3Buf;
  714. class TLocalDriveCapsV4 : public TLocalDriveCapsV3
  715. {
  716. public:
  717. TInt iNumOfBlocks;
  718. TInt iNumPagesPerBlock;
  719. TInt iNumBytesMain;
  720. TInt iNumBytesSpare;
  721. TInt iEffectiveBlks;
  722. TInt iStartPage;
  723.     };
  724. typedef TPckgBuf<TLocalDriveCapsV4> TLocalDriveCapsV4Buf;
  725. typedef TBuf8<64 > TMediaSerialNumber;
  726. class TLocalDriveCapsV5 : public TLocalDriveCapsV4
  727. {
  728. public:
  729.     TUint iSerialNumLength;
  730. TUint8 iSerialNum[64 ];
  731. };
  732. typedef TPckgBuf<TLocalDriveCapsV5> TLocalDriveCapsV5Buf;
  733. class TFormatInfo
  734. {
  735. public:
  736. __declspec(dllexport) TFormatInfo();
  737. public:
  738. TBool iFormatIsCurrent;
  739. TInt i512ByteSectorsFormatted;
  740. TInt iMaxBytesPerFormat;
  741. };
  742. class TErrorInfo
  743. {
  744. public:
  745. enum TReasonCode
  746. {
  747. ENoError=0,
  748. EBadSector=1,
  749. };
  750. public:
  751.     TReasonCode iReasonCode;
  752. union
  753. {
  754. TInt64 iErrorPos;
  755.         TInt iOtherInfo;
  756. };
  757.     };
  758. typedef TPckgBuf<TErrorInfo> TErrorInfoBuf;
  759. class TLocalDriveMessageData
  760. {
  761. public:
  762. inline TLocalDriveMessageData()
  763. {}
  764. inline TLocalDriveMessageData(TInt64 aPos, TInt aLength, const TAny* aPtr, TInt aHandle, TInt anOffset, TInt aFlags)
  765. : iPos(aPos), iLength(aLength), iPtr(aPtr), iHandle(aHandle), iOffset(anOffset), iFlags(aFlags)
  766. {}
  767. public:
  768. TInt64 iPos;
  769. TInt iLength;
  770. const TAny* iPtr;
  771. TInt iHandle;
  772. TInt iOffset;
  773. TInt iFlags;
  774. };
  775. class TLocalDriveControlIOData
  776. {
  777. public:
  778. inline TLocalDriveControlIOData()
  779. {}
  780. inline TLocalDriveControlIOData(TInt aCommand, TAny* aParam1, TAny* aParam2, TInt aHandle)
  781. : iCommand(aCommand), iParam1(aParam1), iParam2(aParam2), iHandle(aHandle)
  782. {}
  783. public:
  784. TInt iCommand;
  785. TAny* iParam1;
  786. TAny* iParam2;
  787. TInt iHandle;
  788. };
  789. class TLocalDrivePasswordData
  790. {
  791. public:
  792. TLocalDrivePasswordData(const TDesC8& aOldPasswd, const TDesC8& aNewPasswd, TBool aStorePasswd)
  793. : iOldPasswd(&aOldPasswd), iNewPasswd(&aNewPasswd), iStorePasswd(aStorePasswd)
  794. {}
  795. TLocalDrivePasswordData()
  796. : iOldPasswd(&KNullDesC8), iNewPasswd(&KNullDesC8), iStorePasswd(EFalse)
  797. {}
  798. public:
  799. const TDesC8 *iOldPasswd;
  800. const TDesC8 *iNewPasswd;
  801. TBool iStorePasswd;
  802. };
  803. typedef TPckgBuf<TLocalDrivePasswordData> TLocalDrivePasswordDataPckg;
  804. class TPasswordStore
  805. {
  806. public:
  807. virtual TInt Init()=0;
  808. virtual TInt ReadPasswordData(TDes8 &aBuf)=0;
  809. virtual TInt WritePasswordData(TDesC8 &aBuf)=0;
  810. virtual TInt PasswordStoreLengthInBytes()=0;
  811. enum {EMaxPasswordLength=256};
  812. };
  813. class TMountInfoData
  814. {
  815. public:
  816. TDesC8* iInfo;
  817. TAny* iThread;
  818. };
  819. const TInt KLocalDriveMajorVersion=1;
  820. const TInt KLocalDriveMinorVersion=0;
  821. const TInt KLocalDriveBuildVersion=160;
  822. const static TLitC<sizeof(L"LocDrv")/2> KLitLocalDriveLddName={sizeof(L"LocDrv")/2-1,L"LocDrv"} ;
  823. const TInt KLocalMessageHandle=-1;
  824. class RLocalDrive : public RBusLogicalChannel
  825. {
  826. public:
  827. enum TControl
  828. {
  829. EControlRead=0,
  830. EControlWrite=1,
  831. EControlCaps=2,
  832. EControlFormat=3,
  833. EControlEnlarge=4,
  834. EControlReduce=5,
  835. EControlForceMediaChange=6,
  836. EControlMediaDevice=7,
  837. EControlPasswordLock=8,
  838. EControlPasswordUnlock=9,
  839. EControlPasswordClear=10,
  840. EControlNotifyChange=11,
  841. EControlNotifyChangeCancel=12,
  842. EControlReadPasswordStore=13,
  843. EControlWritePasswordStore=14,
  844. EControlPasswordStoreLengthInBytes=15,
  845. EControlIsRemovable=16,
  846. EControlSetMountInfo=17,
  847. EControlControlIO=18,
  848. EControlPasswordErase=19,
  849. EControlDeleteNotify=20,
  850. EControlGetLastErrorInfo=21,
  851. };
  852. enum TRemountFlags
  853. {
  854. ELocDrvRemountNotifyChange    = 0,
  855. ELocDrvRemountForceMediaChange = 1,
  856. };
  857. public:
  858. inline TVersion VersionRequired() const;
  859. inline TInt Connect(TInt aDriveNumber, TBool& aChangedFlag);
  860. inline TInt Enlarge(TInt aLength);
  861. inline TInt Reduce(TInt aPos, TInt aLength);
  862. inline TInt Read(TInt64 aPos, TInt aLength, const TAny* aTrg, TInt aMessageHandle, TInt aOffset, TInt aFlags);
  863. inline TInt Read(TInt64 aPos, TInt aLength, const TAny* aTrg, TInt aMessageHandle, TInt anOffset);
  864. inline TInt Read(TInt64 aPos, TInt aLength, TDes8& aTrg);
  865. inline TInt Write(TInt64 aPos, TInt aLength, const TAny* aSrc, TInt aMessageHandle, TInt aOffset, TInt aFlags);
  866. inline TInt Write(TInt64 aPos, TInt aLength, const TAny* aSrc, TInt aMessageHandle, TInt anOffset);
  867. inline TInt Write(TInt64 aPos, const TDesC8& aSrc);
  868. inline TInt Caps(TDes8& anInfo);
  869. inline TInt Format(TInt64 aPos, TInt aLength);
  870. inline TInt ForceMediaChange(TInt aMode=0);
  871. inline void NotifyChange(TRequestStatus* aStatus);
  872. inline void NotifyChangeCancel();
  873. inline TInt SetMountInfo(const TDesC8* aInfo,TInt aMessageHandle);
  874. inline TMediaDevice MediaDevice();
  875. inline TInt IsRemovable(TInt& aSocketNum);
  876. inline TInt ControlIO(TInt aCommand, TAny* aParam1, TAny* aParam2);
  877. inline TInt Unlock(const TDesC8& aPassword, TBool aStorePassword);
  878. inline TInt SetPassword(const TDesC8& aOldPassword, const TDesC8& aNewPassword, TBool aStorePassword);
  879. inline TInt Clear(const TDesC8& aPassword);
  880. inline TInt ErasePassword();
  881. inline TInt ReadPasswordData(TDesC8& aStoreData);
  882. inline TInt WritePasswordData(const TDesC8& aStoreData);
  883. inline TInt PasswordStoreLengthInBytes();
  884. inline TInt DeleteNotify(TInt64 aPos, TInt aLength);
  885. inline TInt GetLastErrorInfo(TDesC8& aErrorInfo);
  886. };
  887. class TBusLocalDrive : public RLocalDrive
  888. {
  889. public:
  890. __declspec(dllexport) TBusLocalDrive();
  891. __declspec(dllexport) TInt Connect(TInt aDriveNumber, TBool& aChangedFlag);
  892. __declspec(dllexport) void Disconnect();
  893. __declspec(dllexport) TInt Enlarge(TInt aLength);
  894. __declspec(dllexport) TInt ReduceSize(TInt aPos, TInt aLength);
  895. __declspec(dllexport) TInt Read(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt aMessageHandle,TInt aOffset,TInt aFlags);
  896. __declspec(dllexport) TInt Read(TInt64 aPos,TInt aLength,const TAny* aTrg,TInt aMessageHandle,TInt anOffset);
  897. __declspec(dllexport) TInt Read(TInt64 aPos,TInt aLength,TDes8& aTrg);
  898. __declspec(dllexport) TInt Write(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt aMessageHandle,TInt aOffset,TInt aFlags);
  899. __declspec(dllexport) TInt Write(TInt64 aPos,TInt aLength,const TAny* aSrc,TInt aMessageHandle,TInt anOffset);
  900. __declspec(dllexport) TInt Write(TInt64 aPos,const TDesC8& aSrc);
  901. __declspec(dllexport) TInt Caps(TDes8& anInfo);
  902. __declspec(dllexport) TInt Format(TFormatInfo& anInfo);
  903. __declspec(dllexport) TInt Format(TInt64 aPos,TInt aLength);
  904. __declspec(dllexport) TInt SetMountInfo(const TDesC8* aMountInfo,TInt aMessageHandle);
  905. __declspec(dllexport) TInt ForceRemount(TUint aFlags=0);
  906. __declspec(dllexport) TInt ControlIO(TInt aCommand, TAny* aParam1, TAny* aParam2);
  907. __declspec(dllexport) TInt Unlock(const TDesC8& aPassword, TBool aStorePassword);
  908. __declspec(dllexport) TInt SetPassword(const TDesC8& aOldPassword, const TDesC8& aNewPassword, TBool aStorePassword);
  909. __declspec(dllexport) TInt Clear(const TDesC8& aPassword);
  910. __declspec(dllexport) TInt ErasePassword();
  911. __declspec(dllexport) TInt ReadPasswordData(TDes8 &aBuf);
  912. __declspec(dllexport) TInt WritePasswordData(const TDesC8 &aBuf);
  913. __declspec(dllexport) TInt PasswordStoreLengthInBytes();
  914. __declspec(dllexport) TInt DeleteNotify(TInt64 aPos, TInt aLength);
  915. __declspec(dllexport) TInt GetLastErrorInfo(TDes8& aErrorInfo);
  916. public:
  917. inline TInt& Status() {return(iStatus);}
  918. private:
  919. TInt CheckMount();
  920. private:
  921. TInt iStatus;
  922. };
  923. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\d32locd.inl" /* stack depth 11 */
  924. inline TVersion RLocalDrive::VersionRequired() const
  925. { return TVersion(KLocalDriveMajorVersion,KLocalDriveMinorVersion,KLocalDriveBuildVersion); }
  926. inline TInt RLocalDrive::Connect(TInt aDriveNumber, TBool& aChangedFlag)
  927. { return DoCreate(KLitLocalDriveLddName,VersionRequired(),aDriveNumber,0 ,(const TDesC8*)&aChangedFlag,EOwnerProcess); }
  928. inline TInt RLocalDrive::Enlarge(TInt aLength)
  929. { return DoControl(EControlEnlarge, (TAny*)aLength); }
  930. inline TInt RLocalDrive::Reduce(TInt aPos, TInt aLength)
  931. { return DoControl(EControlReduce, (TAny*)aPos, (TAny*)aLength); }
  932. inline TInt RLocalDrive::Read(TInt64 aPos, TInt aLength, const TAny* aTrg, TInt aMessageHandle, TInt aOffset, TInt aFlags)
  933. { TLocalDriveMessageData d(aPos,aLength,aTrg,aMessageHandle,aOffset,aFlags); return DoControl(EControlRead, &d); }
  934. inline TInt RLocalDrive::Read(TInt64 aPos, TInt aLength, const TAny* aTrg, TInt aMessageHandle, TInt anOffset)
  935. { TLocalDriveMessageData d(aPos,aLength,aTrg,aMessageHandle,anOffset,0); return DoControl(EControlRead, &d); }
  936. inline TInt RLocalDrive::Read(TInt64 aPos, TInt aLength, TDes8& aTrg)
  937. { TLocalDriveMessageData d(aPos,aLength,&aTrg,KLocalMessageHandle,0,0); return DoControl(EControlRead, &d); }
  938. inline TInt RLocalDrive::Write(TInt64 aPos, TInt aLength, const TAny* aSrc, TInt aMessageHandle, TInt aOffset, TInt aFlags)
  939. { TLocalDriveMessageData d(aPos,aLength,aSrc,aMessageHandle,aOffset,aFlags); return DoControl(EControlWrite, &d); }
  940. inline TInt RLocalDrive::Write(TInt64 aPos, TInt aLength, const TAny* aSrc, TInt aMessageHandle, TInt anOffset)
  941. { TLocalDriveMessageData d(aPos,aLength,aSrc,aMessageHandle,anOffset,0); return DoControl(EControlWrite, &d); }
  942. inline TInt RLocalDrive::Write(TInt64 aPos, const TDesC8& aSrc)
  943. { TLocalDriveMessageData d(aPos,aSrc.Length(),&aSrc,KLocalMessageHandle,0,0); return DoControl(EControlWrite, &d); }
  944. inline TInt RLocalDrive::Caps(TDes8& anInfo)
  945. { return DoControl(EControlCaps, &anInfo); }
  946. inline TInt RLocalDrive::Format(TInt64 aPos, TInt aLength)
  947. { TLocalDriveMessageData d(aPos,aLength,0 ,KLocalMessageHandle,0,0); return DoControl(EControlFormat, &d); }
  948. inline TInt RLocalDrive::ForceMediaChange(TInt aMode)
  949. { return DoControl(EControlForceMediaChange, (TAny*)aMode); }
  950. inline void RLocalDrive::NotifyChange(TRequestStatus* aStatus)
  951. { *aStatus=KRequestPending; DoControl(EControlNotifyChange, aStatus); }
  952. inline void RLocalDrive::NotifyChangeCancel()
  953. { DoControl(EControlNotifyChangeCancel); }
  954. inline TMediaDevice RLocalDrive::MediaDevice()
  955. { return (TMediaDevice)DoControl(EControlMediaDevice); }
  956. inline TInt RLocalDrive::SetMountInfo(const TDesC8* aInfo,TInt aMessageHandle)
  957. { TLocalDriveMessageData d(0,0,aInfo,aMessageHandle,0,0); return DoControl(EControlSetMountInfo, &d); }
  958. inline TInt RLocalDrive::IsRemovable(TInt& aSocketNum)
  959. { return DoControl(EControlIsRemovable,&aSocketNum); }
  960. inline TInt RLocalDrive::ControlIO(TInt aCommand, TAny* aParam1, TAny* aParam2)
  961. { TLocalDriveControlIOData d(aCommand,aParam1,aParam2,KLocalMessageHandle); return DoControl(EControlControlIO,&d); }
  962. inline TInt RLocalDrive::Unlock(const TDesC8& aPassword, TBool aStorePassword)
  963. { TLocalDrivePasswordData d((TDesC8&)aPassword, (TDesC8&)aPassword, aStorePassword); return DoControl(EControlPasswordUnlock, &d); }
  964. inline TInt RLocalDrive::SetPassword(const TDesC8& aOldPassword, const TDesC8& aNewPassword, TBool aStorePassword)
  965. { TLocalDrivePasswordData d((TDesC8&)aOldPassword, (TDesC8&)aNewPassword, aStorePassword); return DoControl(EControlPasswordLock, &d); }
  966. inline TInt RLocalDrive::Clear(const TDesC8& aPassword)
  967. { TLocalDrivePasswordData d((TDesC8&)aPassword, (TDesC8&)aPassword, EFalse); return DoControl(EControlPasswordClear, &d); }
  968. inline TInt RLocalDrive::ErasePassword()
  969. { return DoControl(EControlPasswordErase); }
  970. inline TInt RLocalDrive::ReadPasswordData(TDesC8& aStoreData)
  971. { return DoControl(EControlReadPasswordStore, (TDesC8*)&aStoreData); }
  972. inline TInt RLocalDrive::WritePasswordData(const TDesC8& aStoreData)
  973. { return DoControl(EControlWritePasswordStore, (TDesC8*)&aStoreData); }
  974. inline TInt RLocalDrive::PasswordStoreLengthInBytes()
  975. { TInt length=0; return DoControl(EControlPasswordStoreLengthInBytes, (TAny*)&length)==KErrNone?length:0; }
  976. inline TInt RLocalDrive::DeleteNotify(TInt64 aPos, TInt aLength)
  977. { TLocalDriveMessageData d(aPos,aLength,0,KLocalMessageHandle,0,0); return DoControl(EControlDeleteNotify, &d); }
  978. inline TInt RLocalDrive::GetLastErrorInfo(TDesC8& aErrorInfo)
  979. { return DoControl(EControlGetLastErrorInfo, (TDesC8*)&aErrorInfo); }
  980. #line 500 "C:\Symbian\9.1\S60_3rd\epoc32\include\d32locd.h" /* stack depth 10 */
  981. #line 9 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32svr.h" /* stack depth 9 */
  982. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32notif.h" /* stack depth 10 */
  983. #line 16
  984. enum TNotifierMessage
  985. {
  986. ENotifierNotify,
  987. ENotifierInfoPrint,
  988. EStartNotifier,
  989. ECancelNotifier,
  990. EUpdateNotifier,
  991. EStartNotifierAndGetResponse,
  992. EStartNotifierFromSpecifiedDll,
  993. EStartNotifierFromSpecifiedDllAndGetResponse,
  994. ENotifierNotifyCancel,
  995. EUpdateNotifierAndGetResponse,
  996. };
  997. #line 10 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32svr.h" /* stack depth 9 */
  998. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32ldr.h" /* stack depth 10 */
  999. #line 15
  1000. const TInt KMaxLibraryEntryPoints=0x100;
  1001. const TInt KLoaderMajorVersionNumber=1;
  1002. const TInt KLoaderMinorVersionNumber=0;
  1003. enum TLoaderMsg
  1004. {
  1005. ELoadProcess=1,
  1006. ELoadLibrary=2,
  1007. ELoadLogicalDevice=3,
  1008. ELoadPhysicalDevice=4,
  1009. ELoadLocale=5,
  1010. ELoadFileSystem=6,
  1011. EGetInfo=7,
  1012. ELoaderDebugFunction=8,
  1013. ELoadFSExtension=9,
  1014. EGetInfoFromHeader=10,
  1015. ELoadFSPlugin=11,
  1016. EMaxLoaderMsg
  1017. };
  1018. class TLdrInfo
  1019. {
  1020. public:
  1021. __declspec(dllexport) TLdrInfo();
  1022. public:
  1023. TUidType iRequestedUids;
  1024. TOwnerType iOwnerType;
  1025. TInt iHandle;
  1026. TUint32 iSecureId;
  1027. TUint32 iRequestedVersion;
  1028. };
  1029. class RLoader : public RSessionBase
  1030. {
  1031. public:
  1032. __declspec(dllexport) TInt Connect();
  1033. TVersion Version() const;
  1034. TInt LoadProcess(TInt& aHandle, const TDesC& aFileName, const TDesC& aCommand, const TUidType& aUidType, TOwnerType aType);
  1035. __declspec(dllexport) TInt LoadLibrary(TInt& aHandle, const TDesC& aFileName, const TDesC& aPath, const TUidType& aType, TUint32 aModuleVersion);
  1036. __declspec(dllexport) TInt GetInfo(const TDesC& aFileName, TDes8& aInfoBuf);
  1037. TInt LoadDeviceDriver(const TDesC& aFileName, TInt aDeviceType);
  1038. __declspec(dllexport) TInt DebugFunction(TInt aFunction, TInt a1, TInt a2, TInt a3);
  1039. TInt LoadLocale(const TDesC& aLocaleDllName, TLibraryFunction* aExportList);
  1040. TInt GetInfoFromHeader(const TDesC8& aHeader, TDes8& aInfoBuf);
  1041. public:
  1042. using RSessionBase::SendReceive;
  1043. };
  1044. enum TCodeSegAttributes
  1045. {
  1046. ECodeSegAttKernel =0x00000001,
  1047. ECodeSegAttGlobal =0x00000002,
  1048. ECodeSegAttFixed =0x00000004,
  1049. ECodeSegAttABIMask =0x00000018,
  1050. ECodeSegAttHDll =(TInt)0x80000000,
  1051. ECodeSegAttExpVer =0x40000000,
  1052. };
  1053. class TCodeSegCreateInfo
  1054. {
  1055. public:
  1056. TBuf8<KMaxFileName> iFileName;
  1057. TUidType iUids;
  1058. TUint32 iAttr;
  1059. TInt iCodeSize;
  1060. TInt iTextSize;
  1061. TInt iDataSize;
  1062. TInt iBssSize;
  1063. TInt iTotalDataSize;
  1064. TUint32 iEntryPtVeneer;
  1065. TUint32 iFileEntryPoint;
  1066. TInt iDepCount;
  1067. TUint32 iExportDir;
  1068. TInt iExportDirCount;
  1069. TUint32 iCodeLoadAddress;
  1070. TUint32 iCodeRunAddress;
  1071. TUint32 iDataLoadAddress;
  1072. TUint32 iDataRunAddress;
  1073. TUint32 iExceptionDescriptor;
  1074. TInt iRootNameOffset;
  1075. TInt iRootNameLength;
  1076. TInt iExtOffset;
  1077. TUint32 iModuleVersion;
  1078. SSecurityInfo iS;
  1079. TAny* iHandle;
  1080. TInt iClientProcessHandle;
  1081. public:
  1082. __declspec(dllexport) TPtrC8 RootName() const;
  1083. __declspec(dllexport) void FullFileName(TDes8& aName) const;
  1084. };
  1085. class TProcessCreateInfo : public TCodeSegCreateInfo
  1086. {
  1087. public:
  1088. TInt iHeapSizeMin;
  1089. TInt iHeapSizeMax;
  1090. TInt iStackSize;
  1091. TInt iClientHandle;
  1092. TInt iProcessHandle;
  1093. TInt iFinalHandle;
  1094. TOwnerType iOwnerType;
  1095. TProcessPriority iPriority;
  1096. TUint iSecurityZone;
  1097. };
  1098. const TUint KSecurityZoneUnique = 0u;
  1099. const TUint KSecurityZoneLegacyCode = ~0u;
  1100. class TLibraryCreateInfo
  1101. {
  1102. public:
  1103. TAny* iCodeSegHandle;
  1104. TInt iClientHandle;
  1105. TInt iLibraryHandle;
  1106. TOwnerType iOwnerType;
  1107. };
  1108. class TFindCodeSeg
  1109. {
  1110. public:
  1111. TUidType iUids;
  1112. const TAny* iRomImgHdr;
  1113. TUint32 iAttrMask;
  1114. TUint32 iAttrVal;
  1115. TInt iProcess;
  1116. SSecurityInfo iS;
  1117. TUint32 iModuleVersion;
  1118. TBuf8<KMaxLibraryName> iName;
  1119. };
  1120. class E32Loader
  1121. {
  1122. public:
  1123. __declspec(dllexport) static TInt CodeSegCreate(TCodeSegCreateInfo& aInfo);
  1124. __declspec(dllexport) static TInt CodeSegLoaded(TCodeSegCreateInfo& aInfo);
  1125. __declspec(dllexport) static TInt LibraryCreate(TLibraryCreateInfo& aInfo);
  1126. __declspec(dllexport) static TInt CodeSegOpen(TAny* aHandle, TInt aClientProcessHandle);
  1127. __declspec(dllexport) static void CodeSegClose(TAny* aHandle);
  1128. __declspec(dllexport) static void CodeSegNext(TAny*& aHandle, const TFindCodeSeg& aFind);
  1129. __declspec(dllexport) static void CodeSegInfo(TAny* aHandle, TCodeSegCreateInfo& aInfo);
  1130. __declspec(dllexport) static TInt CodeSegAddDependency(TAny* aImporter, TAny* aExporter);
  1131. __declspec(dllexport) static void CodeSegDeferDeletes();
  1132. __declspec(dllexport) static void CodeSegEndDeferDeletes();
  1133. __declspec(dllexport) static TInt ProcessCreate(TProcessCreateInfo& aInfo, const TDesC8* aCommandLine);
  1134. __declspec(dllexport) static TInt ProcessLoaded(TProcessCreateInfo& aInfo);
  1135. __declspec(dllexport) static TInt CheckClientState(TInt aClientHandle);
  1136. __declspec(dllexport) static TInt DeviceLoad(TAny* aHandle, TInt aType);
  1137. __declspec(dllexport) static TAny* ThreadProcessCodeSeg(TInt aHandle);
  1138. __declspec(dllexport) static void ReadExportDir(TAny* aHandle, TUint32* aDest);
  1139. __declspec(dllexport) static TInt LocaleExports(TAny* aHandle, TLibraryFunction* aExportsList);
  1140. __declspec(dllexport) static void GetV7StubAddresses(TLinAddr& aExe, TLinAddr& aDll);
  1141. static TInt V7ExeEntryStub();
  1142. static TInt V7DllEntryStub(TInt aReason);
  1143. public:
  1144. static TInt WaitDllLock();
  1145. static TInt ReleaseDllLock();
  1146. static TInt LibraryAttach(TInt aHandle, TInt& aNumEps, TLinAddr* aEpList);
  1147. static TInt LibraryAttached(TInt aHandle);
  1148. static TInt StaticCallList(TInt& aNumEps, TLinAddr* aEpList);
  1149. static TInt LibraryDetach(TInt& aNumEps, TLinAddr* aEpList);
  1150. static TInt LibraryDetached();
  1151. };
  1152. typedef TInt (*TSupervisorFunction)(TAny*);
  1153. #line 11 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32svr.h" /* stack depth 9 */
  1154. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32event.h" /* stack depth 10 */
  1155. #line 14
  1156. const TInt KUndefinedDeviceNumber = -1;
  1157. #line 25
  1158. class TRawEvent
  1159. {
  1160. public:
  1161. enum TType
  1162. {
  1163. ENone,
  1164. EPointerMove,
  1165.         EPointerSwitchOn,
  1166. EKeyDown,
  1167. EKeyUp,
  1168. ERedraw,
  1169. ESwitchOn,
  1170.         EActive,
  1171. EInactive,
  1172. EUpdateModifiers,
  1173. EButton1Down,
  1174. EButton1Up,
  1175. EButton2Down,
  1176. EButton2Up,
  1177. EButton3Down,
  1178. EButton3Up,
  1179. ESwitchOff,
  1180. EKeyRepeat,
  1181. ECaseOpen,
  1182. ECaseClose,
  1183. #line 165
  1184. EPointer3DInRange,
  1185. #line 174
  1186. EPointer3DOutOfRange,
  1187. #line 183
  1188. EPointer3DTilt,
  1189. #line 192
  1190. EPointer3DRotation,
  1191. #line 201
  1192. EPointer3DTiltAndMove,
  1193. EButton4Down,
  1194. EButton4Up,
  1195. EButton5Down,
  1196. EButton5Up,
  1197. EButton6Down,
  1198. EButton6Up
  1199. };
  1200. public:
  1201. inline TRawEvent()
  1202. { *(TInt*)&iType=0; }
  1203. inline TType Type() const
  1204. {return TType(iType);}
  1205. inline TInt DeviceNumber() const
  1206. {return TInt(iDeviceNumber-1);}
  1207. inline void SetDeviceNumber(TInt aDeviceNumber)
  1208. {iDeviceNumber = TUint8(aDeviceNumber+1);}
  1209. __declspec(dllexport) TPoint Pos() const;
  1210. __declspec(dllexport) TInt ScanCode() const;
  1211.     __declspec(dllexport) TInt Modifiers() const;
  1212. __declspec(dllexport) TPoint3D Pos3D() const;
  1213. #line 289
  1214. __declspec(dllexport) TAngle3D Tilt() const;
  1215. #line 299
  1216. __declspec(dllexport) TInt Rotation() const;
  1217. #line 309
  1218. inline TUint Ticks() const
  1219. {return iTicks;}
  1220. inline TBool IsTip() const
  1221. {return TBool(iTip);}
  1222. inline void SetTip(TBool aTip)
  1223. {iTip = TUint8(aTip);}
  1224. __declspec(dllexport) void Set(TType aType,TInt aScanCode);
  1225. __declspec(dllexport) void Set(TType aType,TInt aX,TInt aY);
  1226. __declspec(dllexport) void Set(TType aType);
  1227. __declspec(dllexport) void Set(TType aType,TInt aX,TInt aY,TInt aZ);
  1228. __declspec(dllexport) void Set(TType aType,TInt aX,TInt aY,TInt aZ,TInt aPhi,TInt aTheta,TInt aAlpha);
  1229. __declspec(dllexport) void SetTilt(TType aType,TInt aPhi,TInt aTheta);
  1230. __declspec(dllexport) void SetRotation(TType aType,TInt aAlpha);
  1231. protected:
  1232. TUint8 iType;
  1233. TUint8 iTip;
  1234. TUint8 iSpare2;
  1235. TUint8 iDeviceNumber;
  1236. TUint iTicks;
  1237. union
  1238. {
  1239. struct {TInt x;TInt y;} pos;
  1240. struct {TInt x;TInt y;TInt z;TInt phi;TInt theta;TInt alpha;} pos3D;
  1241. TInt scanCode;
  1242. TInt modifiers;
  1243. } iU;
  1244. };
  1245. #line 362
  1246. class TRawEventBuf : public TPckgBuf<TRawEvent>
  1247. {
  1248. public:
  1249. inline TRawEvent &Event() const {return(*((TRawEvent *)&iBuf[0]));}
  1250. };
  1251. #line 383
  1252. class TScreenInfoV01
  1253. {
  1254. public:
  1255. TBool iWindowHandleValid;
  1256. TAny *iWindowHandle;
  1257. TBool iScreenAddressValid;
  1258. TAny *iScreenAddress;
  1259. TSize iScreenSize;
  1260. };
  1261. #line 12 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32svr.h" /* stack depth 9 */
  1262. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32ktran.h" /* stack depth 10 */
  1263. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32keys.h" /* stack depth 11 */
  1264. #line 39
  1265. enum TEventModifier
  1266. {
  1267. EModifierAutorepeatable=0x00000001,
  1268. EModifierKeypad=0x00000002,
  1269. EModifierLeftAlt=0x00000004,
  1270. EModifierRightAlt=0x00000008,
  1271. EModifierAlt=0x00000010,
  1272. EModifierLeftCtrl=0x00000020,
  1273. EModifierRightCtrl=0x00000040,
  1274. EModifierCtrl=0x00000080,
  1275. EModifierLeftShift=0x00000100,
  1276. EModifierRightShift=0x00000200,
  1277. EModifierShift=0x00000400,
  1278. EModifierLeftFunc=0x00000800,
  1279. EModifierRightFunc=0x00001000,
  1280. EModifierFunc=0x00002000,
  1281. EModifierCapsLock=0x00004000,
  1282. EModifierNumLock=0x00008000,
  1283. EModifierScrollLock=0x00010000,
  1284. EModifierKeyUp=0x00020000,
  1285. EModifierSpecial=0x00040000,
  1286. EModifierDoubleClick=0x00080000,
  1287.     EModifierPureKeycode=0x00100000,
  1288. EModifierKeyboardExtend=0x00200000,
  1289. EModifierCancelRotation=0x00000000,
  1290. EModifierRotateBy90=0x00400000,
  1291. EModifierRotateBy180=0x00800000,
  1292. EModifierRotateBy270=0x01000000,
  1293. EModifierPointer3DButton1=0x02000000,
  1294. EModifierPointer3DButton2=0x04000000,
  1295. EModifierPointer3DButton3=0x08000000,
  1296. EAllModifiers=0x0fffffff
  1297. };
  1298. #line 88
  1299. enum TModifierState
  1300.     {
  1301.     ETurnOnModifier=0x40,
  1302.     ETurnOffModifier,
  1303.     EToggleModifier
  1304.     };
  1305. #line 120
  1306. enum TStdScanCode
  1307. {
  1308. EStdKeyNull=0x00,
  1309. EStdKeyBackspace=0x01,
  1310. EStdKeyTab=0x02,
  1311. EStdKeyEnter=0x03,
  1312. EStdKeyEscape=0x04,
  1313. EStdKeySpace=0x05,
  1314. EStdKeyPrintScreen=0x06,
  1315. EStdKeyPause=0x07,
  1316. EStdKeyHome=0x08,
  1317. EStdKeyEnd=0x09,
  1318. EStdKeyPageUp=0x0a,
  1319. EStdKeyPageDown=0x0b,
  1320. EStdKeyInsert=0x0c,
  1321. EStdKeyDelete=0x0d,
  1322. EStdKeyLeftArrow=0x0e,
  1323. EStdKeyRightArrow=0x0f,
  1324. EStdKeyUpArrow=0x10,
  1325. EStdKeyDownArrow=0x11,
  1326. EStdKeyLeftShift=0x12,
  1327. EStdKeyRightShift=0x13,
  1328. EStdKeyLeftAlt=0x14,
  1329. EStdKeyRightAlt=0x15,
  1330. EStdKeyLeftCtrl=0x16,
  1331. EStdKeyRightCtrl=0x17,
  1332. EStdKeyLeftFunc=0x18,
  1333. EStdKeyRightFunc=0x19,
  1334. EStdKeyCapsLock=0x1a,
  1335. EStdKeyNumLock=0x1b,
  1336. EStdKeyScrollLock=0x1c,
  1337. EStdKeyF1=0x60,
  1338. EStdKeyF2=0x61,
  1339. EStdKeyF3=0x62,
  1340. EStdKeyF4=0x63,
  1341. EStdKeyF5=0x64,
  1342. EStdKeyF6=0x65,
  1343. EStdKeyF7=0x66,
  1344. EStdKeyF8=0x67,
  1345. EStdKeyF9=0x68,
  1346. EStdKeyF10=0x69,
  1347. EStdKeyF11=0x6a,
  1348. EStdKeyF12=0x6b,
  1349. EStdKeyF13=0x6c,
  1350. EStdKeyF14=0x6d,
  1351. EStdKeyF15=0x6e,
  1352. EStdKeyF16=0x6f,
  1353. EStdKeyF17=0x70,
  1354. EStdKeyF18=0x71,
  1355. EStdKeyF19=0x72,
  1356. EStdKeyF20=0x73,
  1357. EStdKeyF21=0x74,
  1358. EStdKeyF22=0x75,
  1359. EStdKeyF23=0x76,
  1360. EStdKeyF24=0x77,
  1361. EStdKeyXXX=0x78,
  1362. EStdKeyComma=0x79,
  1363. EStdKeyFullStop=0x7a,
  1364. EStdKeyForwardSlash=0x7b,
  1365. EStdKeyBackSlash=0x7c,
  1366. EStdKeySemiColon=0x7d,
  1367. EStdKeySingleQuote=0x7e,
  1368. EStdKeyHash=0x7f,
  1369. EStdKeySquareBracketLeft=0x80,
  1370. EStdKeySquareBracketRight=0x81,
  1371. EStdKeyMinus=0x82,
  1372. EStdKeyEquals=0x83,
  1373. EStdKeyNkpForwardSlash=0x84,
  1374. EStdKeyNkpAsterisk=0x85,
  1375. EStdKeyNkpMinus=0x86,
  1376. EStdKeyNkpPlus=0x87,
  1377. EStdKeyNkpEnter=0x88,
  1378. EStdKeyNkp1=0x89,
  1379. EStdKeyNkp2=0x8a,
  1380. EStdKeyNkp3=0x8b,
  1381. EStdKeyNkp4=0x8c,
  1382. EStdKeyNkp5=0x8d,
  1383. EStdKeyNkp6=0x8e,
  1384. EStdKeyNkp7=0x8f,
  1385. EStdKeyNkp8=0x90,
  1386. EStdKeyNkp9=0x91,
  1387. EStdKeyNkp0=0x92,
  1388. EStdKeyNkpFullStop=0x93,
  1389.     EStdKeyMenu=0x94,
  1390.     EStdKeyBacklightOn=0x95,
  1391.     EStdKeyBacklightOff=0x96,
  1392.     EStdKeyBacklightToggle=0x97,
  1393.     EStdKeyIncContrast=0x98,
  1394.     EStdKeyDecContrast=0x99,
  1395.     EStdKeySliderDown=0x9a,
  1396.     EStdKeySliderUp=0x9b,
  1397.     EStdKeyDictaphonePlay=0x9c,
  1398.     EStdKeyDictaphoneStop=0x9d,
  1399.     EStdKeyDictaphoneRecord=0x9e,
  1400.     EStdKeyHelp=0x9f,
  1401.     EStdKeyOff=0xa0,
  1402.     EStdKeyDial=0xa1,
  1403.     EStdKeyIncVolume=0xa2,
  1404.     EStdKeyDecVolume=0xa3,
  1405.     EStdKeyDevice0=0xa4,
  1406.     EStdKeyDevice1=0xa5,
  1407.     EStdKeyDevice2=0xa6,
  1408.     EStdKeyDevice3=0xa7,
  1409.     EStdKeyDevice4=0xa8,
  1410.     EStdKeyDevice5=0xa9,
  1411.     EStdKeyDevice6=0xaa,
  1412.     EStdKeyDevice7=0xab,
  1413.     EStdKeyDevice8=0xac,
  1414.     EStdKeyDevice9=0xad,
  1415.     EStdKeyDeviceA=0xae,
  1416.     EStdKeyDeviceB=0xaf,
  1417.     EStdKeyDeviceC=0xb0,
  1418.     EStdKeyDeviceD=0xb1,
  1419.     EStdKeyDeviceE=0xb2,
  1420.     EStdKeyDeviceF=0xb3,
  1421.     EStdKeyApplication0=0xb4,
  1422.     EStdKeyApplication1=0xb5,
  1423.     EStdKeyApplication2=0xb6,
  1424.     EStdKeyApplication3=0xb7,
  1425.     EStdKeyApplication4=0xb8,
  1426.     EStdKeyApplication5=0xb9,
  1427.     EStdKeyApplication6=0xba,
  1428.     EStdKeyApplication7=0xbb,
  1429.     EStdKeyApplication8=0xbc,
  1430.     EStdKeyApplication9=0xbd,
  1431.     EStdKeyApplicationA=0xbe,
  1432.     EStdKeyApplicationB=0xbf,
  1433.     EStdKeyApplicationC=0xc0,
  1434.     EStdKeyApplicationD=0xc1,
  1435.     EStdKeyApplicationE=0xc2,
  1436.     EStdKeyApplicationF=0xc3,
  1437. EStdKeyYes=0xc4,
  1438. EStdKeyNo=0xc5,
  1439. EStdKeyIncBrightness=0xc6,
  1440. EStdKeyDecBrightness=0xc7,
  1441. EStdKeyKeyboardExtend=0xc8,
  1442.     EStdKeyDevice10=0xc9,
  1443.     EStdKeyDevice11=0xca,
  1444.     EStdKeyDevice12=0xcb,
  1445.     EStdKeyDevice13=0xcc,
  1446.     EStdKeyDevice14=0xcd,
  1447.     EStdKeyDevice15=0xce,
  1448.     EStdKeyDevice16=0xcf,
  1449.     EStdKeyDevice17=0xd0,
  1450.     EStdKeyDevice18=0xd1,
  1451.     EStdKeyDevice19=0xd2,
  1452.     EStdKeyDevice1A=0xd3,
  1453.     EStdKeyDevice1B=0xd4,
  1454.     EStdKeyDevice1C=0xd5,
  1455.     EStdKeyDevice1D=0xd6,
  1456.     EStdKeyDevice1E=0xd7,
  1457.     EStdKeyDevice1F=0xd8,
  1458.     EStdKeyApplication10=0xd9,
  1459.     EStdKeyApplication11=0xda,
  1460.     EStdKeyApplication12=0xdb,
  1461.     EStdKeyApplication13=0xdc,
  1462.     EStdKeyApplication14=0xdd,
  1463.     EStdKeyApplication15=0xde,
  1464.     EStdKeyApplication16=0xdf,
  1465.     EStdKeyApplication17=0xe0,
  1466.     EStdKeyApplication18=0xe1,
  1467.     EStdKeyApplication19=0xe2,
  1468.     EStdKeyApplication1A=0xe3,
  1469.     EStdKeyApplication1B=0xe4,
  1470.     EStdKeyApplication1C=0xe5,
  1471.     EStdKeyApplication1D=0xe6,
  1472.     EStdKeyApplication1E=0xe7,
  1473.     EStdKeyApplication1F=0xe8
  1474. };
  1475. #line 303
  1476. enum TKeyCode
  1477. {
  1478. EKeyNull=0x0000,
  1479. EKeyBell=0x0007,
  1480. EKeyBackspace=0x0008,
  1481. EKeyTab=0x0009,
  1482. EKeyLineFeed=0x000a,
  1483. EKeyVerticalTab=0x000b,
  1484. EKeyFormFeed=0x000c,
  1485. EKeyEnter=0x000d,
  1486. EKeyEscape=0x001b,
  1487. EKeySpace=0x0020,
  1488. EKeyDelete=0x007f,
  1489. EKeyPrintScreen=0xf800 ,
  1490. EKeyPause,
  1491. EKeyHome,
  1492. EKeyEnd,
  1493. EKeyPageUp,
  1494. EKeyPageDown,
  1495. EKeyInsert,
  1496. EKeyLeftArrow,
  1497. EKeyRightArrow,
  1498. EKeyUpArrow,
  1499. EKeyDownArrow,
  1500. EKeyLeftShift,
  1501. EKeyRightShift,
  1502. EKeyLeftAlt,
  1503. EKeyRightAlt,
  1504. EKeyLeftCtrl,
  1505. EKeyRightCtrl,
  1506. EKeyLeftFunc,
  1507. EKeyRightFunc,
  1508. EKeyCapsLock,
  1509. EKeyNumLock,
  1510. EKeyScrollLock,
  1511. EKeyF1,
  1512. EKeyF2,
  1513. EKeyF3,
  1514. EKeyF4,
  1515. EKeyF5,
  1516. EKeyF6,
  1517. EKeyF7,
  1518. EKeyF8,
  1519. EKeyF9,
  1520. EKeyF10,
  1521. EKeyF11,
  1522. EKeyF12,
  1523. EKeyF13,
  1524. EKeyF14,
  1525. EKeyF15,
  1526. EKeyF16,
  1527. EKeyF17,
  1528. EKeyF18,
  1529. EKeyF19,
  1530. EKeyF20,
  1531. EKeyF21,
  1532. EKeyF22,
  1533. EKeyF23,
  1534. EKeyF24,
  1535.     EKeyOff,
  1536.     EKeyIncContrast,
  1537.     EKeyDecContrast,
  1538.     EKeyBacklightOn,
  1539.     EKeyBacklightOff,
  1540.     EKeyBacklightToggle,
  1541.     EKeySliderDown,
  1542.     EKeySliderUp,
  1543.     EKeyMenu,
  1544.     EKeyDictaphonePlay,
  1545.     EKeyDictaphoneStop,
  1546.     EKeyDictaphoneRecord,
  1547.     EKeyHelp,
  1548.     EKeyDial,
  1549. EKeyScreenDimension0,
  1550. EKeyScreenDimension1,
  1551. EKeyScreenDimension2,
  1552. EKeyScreenDimension3,
  1553. EKeyIncVolume,
  1554. EKeyDecVolume,
  1555. EKeyDevice0,
  1556. EKeyDevice1,
  1557. EKeyDevice2,
  1558. EKeyDevice3,
  1559. EKeyDevice4,
  1560. EKeyDevice5,
  1561. EKeyDevice6,
  1562. EKeyDevice7,
  1563. EKeyDevice8,
  1564. EKeyDevice9,
  1565. EKeyDeviceA,
  1566. EKeyDeviceB,
  1567. EKeyDeviceC,
  1568. EKeyDeviceD,
  1569. EKeyDeviceE,
  1570. EKeyDeviceF,
  1571. EKeyApplication0,
  1572. EKeyApplication1,
  1573. EKeyApplication2,
  1574. EKeyApplication3,
  1575. EKeyApplication4,
  1576. EKeyApplication5,
  1577. EKeyApplication6,
  1578. EKeyApplication7,
  1579. EKeyApplication8,
  1580. EKeyApplication9,
  1581. EKeyApplicationA,
  1582. EKeyApplicationB,
  1583. EKeyApplicationC,
  1584. EKeyApplicationD,
  1585. EKeyApplicationE,
  1586. EKeyApplicationF,
  1587. EKeyYes,
  1588. EKeyNo,
  1589. EKeyIncBrightness,
  1590. EKeyDecBrightness,
  1591. EKeyKeyboardExtend,
  1592. EKeyDevice10,
  1593. EKeyDevice11,
  1594. EKeyDevice12,
  1595. EKeyDevice13,
  1596. EKeyDevice14,
  1597. EKeyDevice15,
  1598. EKeyDevice16,
  1599. EKeyDevice17,
  1600. EKeyDevice18,
  1601. EKeyDevice19,
  1602. EKeyDevice1A,
  1603. EKeyDevice1B,
  1604. EKeyDevice1C,
  1605. EKeyDevice1D,
  1606. EKeyDevice1E,
  1607. EKeyDevice1F,
  1608. EKeyApplication10,
  1609. EKeyApplication11,
  1610. EKeyApplication12,
  1611. EKeyApplication13,
  1612. EKeyApplication14,
  1613. EKeyApplication15,
  1614. EKeyApplication16,
  1615. EKeyApplication17,
  1616. EKeyApplication18,
  1617. EKeyApplication19,
  1618. EKeyApplication1A,
  1619. EKeyApplication1B,
  1620. EKeyApplication1C,
  1621. EKeyApplication1D,
  1622. EKeyApplication1E,
  1623. EKeyApplication1F
  1624. };
  1625. #line 14 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32ktran.h" /* stack depth 10 */
  1626. class TMaskedModifiers
  1627. {
  1628. public:
  1629. TUint iMask;
  1630. TUint iValue;
  1631. };
  1632. enum TPattern
  1633. {
  1634. EAnyKey=0x00,
  1635. EAnyAlphaNumeric,
  1636. EAnyAlpha,
  1637. EAnyAlphaLowerCase,
  1638. EAnyAlphaUpperCase,
  1639. EAnyDecimalDigit,
  1640. EAnyDigitGivenRadix,
  1641. EAnyModifierKey,
  1642. EMatchKey=0x40,
  1643. EMatchKeyCaseInsens,
  1644. EMatchLeftOrRight
  1645. };
  1646. class TKeyCodePattern
  1647. {
  1648. public:
  1649. TUint16 iKeyCode;
  1650. TInt8   iPattern;
  1651. TInt8   iFiller;
  1652. };
  1653. class TCaptureKey
  1654. {
  1655. public:
  1656. TMaskedModifiers iModifiers;
  1657. TKeyCodePattern  iKeyCodePattern;
  1658. TUint iApp;
  1659. TUint iHandle;
  1660. };
  1661. class TKeyData
  1662. {
  1663. public:
  1664. TInt  iModifiers;
  1665. TInt  iApp;
  1666. TInt  iHandle;
  1667. TBool iIsCaptureKey;
  1668. TUint iKeyCode;
  1669. };
  1670. class CCaptureKeys: public CBase
  1671. {
  1672. public:
  1673. __declspec(dllexport) CCaptureKeys();
  1674. __declspec(dllexport) ~CCaptureKeys();
  1675. __declspec(dllexport) void Construct();
  1676. __declspec(dllexport) void AddCaptureKeyL(const TCaptureKey &aCaptureKey);
  1677. __declspec(dllexport) void AddCaptureKeyL(const TCaptureKey &aCaptureKey, TUint8 aPriority);
  1678. __declspec(dllexport) void SetCaptureKey(TUint32 aHandle, const TCaptureKey &aCaptureKey);
  1679. __declspec(dllexport) void SetCaptureKey(TUint32 aHandle, const TCaptureKey &aCaptureKey, TUint8 aPriority);
  1680. __declspec(dllexport) void CancelCaptureKey(TUint32 aHandle);
  1681. __declspec(dllexport) void CancelAllCaptureKeys(TUint32 aApp);
  1682. __declspec(dllexport) void ProcessCaptureKeys(TKeyData &aKeyData) const;
  1683. protected:
  1684. void CheckCaptureKey(const TCaptureKey &aCaptureKey);
  1685. void removeCaptureKey(TUint index);
  1686. protected:
  1687. RArray<TCaptureKey> iCKarray;
  1688. };
  1689. class CKeyTranslator: public CBase
  1690. {
  1691. public:
  1692. __declspec(dllexport) static CKeyTranslator *New();
  1693. virtual TInt GetModifierState()=0;
  1694. virtual void SetModifierState(TEventModifier aModifier,TModifierState aState)=0;
  1695. virtual TBool TranslateKey(TUint aScanCode,TBool aKeyUp,const CCaptureKeys &aCaptureKeys,TKeyData &aKeyData)=0;
  1696.     virtual void UpdateModifiers(TInt aModifiers)=0;
  1697.     virtual TInt ChangeKeyData(const TDesC& aLibraryName)=0;
  1698. };
  1699. #line 13 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32svr.h" /* stack depth 9 */
  1700. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32debug.h" /* stack depth 10 */
  1701. #line 13
  1702. const TInt KMaxProfiles=64;
  1703. class TProfile
  1704.     {
  1705. public:
  1706.     TInt iTime;
  1707.     TInt iCount;
  1708.     };
  1709. class RDebug
  1710. {
  1711. public:
  1712.     __declspec(dllexport) static void Printf(const char*, ...);
  1713.     __declspec(dllexport) static TInt Print(TRefByValue<const TDesC> aFmt,...);
  1714.     __declspec(dllexport) static void RawPrint(const TDesC& aDes);
  1715. };
  1716. #line 14 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32svr.h" /* stack depth 9 */
  1717. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32lmsg.h" /* stack depth 10 */
  1718. #line 15
  1719. const TInt KMaxLocaleMessageText=0x80;
  1720. enum TLocaleMessage
  1721. {
  1722. EFileServer_Button1,
  1723. EFileServer_Button2,
  1724. EFileServer_PutTheCardBackLine1,
  1725. EFileServer_PutTheCardBackLine2,
  1726. EFileServer_LowPowerLine1,
  1727. EFileServer_LowPowerLine2,
  1728. EFileServer_DiskErrorLine1,
  1729. EFileServer_DiskErrorLine2,
  1730. ESoundDriver_Chimes,
  1731. ESoundDriver_Rings,
  1732. ESoundDriver_Signal,
  1733. EMediaDriver_DiskNameInternal,
  1734. EMediaDriver_DiskNameExternal1,
  1735. EMediaDriver_DiskNameExternal2,
  1736. EMediaDriver_DiskNameExternal3,
  1737. EMediaDriver_DiskNameExternal4,
  1738. EMediaDriver_DiskNameExternal5,
  1739. EMediaDriver_DiskNameExternal6,
  1740. EMediaDriver_DiskNameExternal7,
  1741. EMediaDriver_DiskNameExternal8,
  1742. EMediaDriver_SocketName0,
  1743. EMediaDriver_SocketName1,
  1744. EMediaDriver_SocketName2,
  1745. EMediaDriver_SocketName3,
  1746. ELocaleMessages_LastMsg
  1747. };
  1748. class TLocaleMessageText : public TBuf<KMaxLocaleMessageText>
  1749. {
  1750. public:
  1751. __declspec(dllexport) TLocaleMessageText();
  1752. __declspec(dllexport) TLocaleMessageText(TLocaleMessage aMessageNo);
  1753. __declspec(dllexport) void Set(TLocaleMessage aMessageNo);
  1754. };
  1755. #line 15 "C:\Symbian\9.1\S60_3rd\epoc32\include\e32svr.h" /* stack depth 9 */
  1756. enum TBlockType {EBlocked,EUnBlocked,ERelease};
  1757. class UserSvr
  1758. {
  1759. public:
  1760. __declspec(dllexport) static void CaptureEventHook();
  1761. __declspec(dllexport) static void ReleaseEventHook();
  1762. __declspec(dllexport) static void RequestEvent(TRawEventBuf &anEvent,TRequestStatus &aStatus);
  1763. __declspec(dllexport) static void RequestEventCancel();
  1764. __declspec(dllexport) static TInt AddEvent(const TRawEvent& anEvent);
  1765. __declspec(dllexport) static void ScreenInfo(TDes8& anInfo);
  1766. __declspec(dllexport) static TInt DllSetTls(TInt aHandle, TAny *aPtr);
  1767. __declspec(dllexport) static TAny *DllTls(TInt aHandle);
  1768. __declspec(dllexport) static void DllFreeTls(TInt aHandle);
  1769. __declspec(dllexport) static void DllFileName(TInt aHandle, TDes &aFileName);
  1770. __declspec(dllexport) static void FsRegisterThread();
  1771. __declspec(dllexport) static void WsRegisterThread();
  1772.     __declspec(dllexport) static TBool TestBootSequence();
  1773.     __declspec(dllexport) static void WsRegisterSwitchOnScreenHandling(TBool aState);
  1774.     __declspec(dllexport) static void WsSwitchOnScreen();
  1775.     __declspec(dllexport) static TInt ChangeLocale(const TDesC& aLocaleDllName);
  1776. __declspec(dllexport) static TInt ResetMachine(TMachineStartupType aType);
  1777. __declspec(dllexport) static void UnlockRamDrive();
  1778. __declspec(dllexport) static void LockRamDrive();
  1779. __declspec(dllexport) static TUint32 RomRootDirectoryAddress();
  1780. __declspec(dllexport) static TInt ExecuteInSupervisorMode(TSupervisorFunction aFunction, TAny* aParameter);
  1781. __declspec(dllexport) static TUint32 RomHeaderAddress();
  1782. __declspec(dllexport) static TUint32 DebugMask();
  1783. __declspec(dllexport) static TUint32 DebugMask(TUint aIndex);
  1784. __declspec(dllexport) static TInt HalFunction(TInt aGroup, TInt aFunction, TAny* a1, TAny* a2);
  1785. __declspec(dllexport) static TInt HalFunction(TInt aGroup, TInt aFunction, TAny* a1, TAny* a2, TInt aDeviceNumber);
  1786. __declspec(dllexport) static TInt HalGet(TInt,TAny*);
  1787. __declspec(dllexport) static TInt HalSet(TInt,TAny*);
  1788. __declspec(dllexport) static TInt SetMemoryThresholds(TInt aLowThreshold, TInt aGoodThreshold);
  1789. __declspec(dllexport) static TBool IpcV1Available();
  1790. __declspec(dllexport) static TLinAddr ExceptionDescriptor(TLinAddr aCodeAddress);
  1791. __declspec(dllexport) static TInt LocalePropertiesSetDefaults();
  1792. };
  1793. #line 20 "C:\Symbian\9.1\S60_3rd\epoc32\include\f32file.h" /* stack depth 8 */
  1794. #line 30
  1795. const TInt KDefaultDrive=KMaxTInt;
  1796. #line 43
  1797. const TInt KDriveAbsent=0x00;
  1798. #line 56
  1799. const TInt KFileServerDefaultMessageSlots=-1;
  1800. #line 70
  1801. const TInt KEntryArraySize=(0x200*sizeof(TText));
  1802. #line 81
  1803. const TInt KPathDelimiter='\';
  1804. #line 92
  1805. const TInt KDriveDelimiter=':';
  1806. #line 103
  1807. const TInt KExtDelimiter='.';
  1808. #line 114
  1809. const TInt KMaxDrives=26;
  1810. #line 129
  1811. typedef TBuf8<KMaxDrives> TDriveList;
  1812. #line 141
  1813. const TInt KMaxDriveName=0x02;
  1814. #line 158
  1815. typedef TBuf<KMaxDriveName> TDriveName;
  1816. #line 169
  1817. const TUint KEntryAttNormal=0x0000;
  1818. #line 180
  1819. const TUint KEntryAttReadOnly=0x0001;
  1820. #line 191
  1821. const TUint KEntryAttHidden=0x0002;
  1822. #line 202
  1823. const TUint KEntryAttSystem=0x0004;
  1824. #line 213
  1825. const TUint KEntryAttVolume=0x0008;
  1826. #line 224
  1827. const TUint KEntryAttDir=0x0010;
  1828. #line 235
  1829. const TUint KEntryAttArchive=0x0020;
  1830. #line 244
  1831. const TUint KEntryAttXIP=0x0080;
  1832. #line 263
  1833. const TUint KEntryAttMatchMask=(KEntryAttHidden|KEntryAttSystem|KEntryAttDir);
  1834. #line 280
  1835. const TUint KEntryAttMaskSupported=0x3f;
  1836. #line 300
  1837. const TUint KEntryAttMatchExclusive=0x40000000;
  1838. #line 329
  1839. const TUint KEntryAttMatchExclude=0x08000000;
  1840. #line 345
  1841. const TUint KEntryAttAllowUid=0x10000000;
  1842. const TUint KDebugNotifyMask=0xFF000000;
  1843. enum TNotifyType
  1844. #line 374
  1845. {
  1846. ENotifyAll=0x01,
  1847. ENotifyEntry=0x02,
  1848. ENotifyFile=0x04,
  1849. ENotifyDir=0x08,
  1850. ENotifyAttributes=0x10,
  1851. ENotifyWrite=0x20,
  1852. ENotifyDisk=0x40
  1853. };
  1854. enum TNotifyDismountMode
  1855. #line 430
  1856. {
  1857. EFsDismountRegisterClient=0x01,
  1858. EFsDismountNotifyClients=0x02,
  1859. EFsDismountForceDismount=0x03,
  1860. };
  1861. enum TStartupConfigurationCmd
  1862. #line 458
  1863.     {
  1864.     ELoaderPriority,
  1865.     EMaxStartupConfigurationCmd
  1866.     };
  1867. enum TDriveNumber
  1868. {
  1869. EDriveA,   EDriveB,   EDriveC,   EDriveD,   EDriveE,
  1870. EDriveF,   EDriveG,   EDriveH,   EDriveI,   EDriveJ,
  1871. EDriveK,   EDriveL,   EDriveM,   EDriveN,   EDriveO,
  1872. EDriveP,   EDriveQ,   EDriveR,   EDriveS,   EDriveT,
  1873. EDriveU,   EDriveV,   EDriveW,   EDriveX,   EDriveY,
  1874. EDriveZ
  1875. };
  1876. enum TEntryKey
  1877. #line 501
  1878. {
  1879. ESortNone=0,
  1880. #line 514
  1881. ESortByName,
  1882. #line 527
  1883. ESortByExt,
  1884. #line 536
  1885. ESortBySize,
  1886. #line 547
  1887. ESortByDate,
  1888. #line 556
  1889. ESortByUid,
  1890. #line 567
  1891. EDirsAnyOrder=0,
  1892. EDirsFirst=0x100,
  1893. EDirsLast=0x200,
  1894. #line 593
  1895. EAscending=0,
  1896. EDescending=0x400,
  1897. #line 610
  1898. EDirDescending=0x800
  1899. };
  1900. enum TFileMode
  1901. #line 658
  1902. {
  1903. EFileShareExclusive,
  1904. #line 676
  1905. EFileShareReadersOnly,
  1906. #line 688
  1907. EFileShareAny,
  1908. #line 700
  1909. EFileShareReadersOrWriters,
  1910. EFileStream=0,
  1911. EFileStreamText=0x100,
  1912. EFileRead=0,
  1913. EFileWrite=0x200,
  1914. #line 735
  1915. EFileReadAsyncAll=0x400
  1916. };
  1917. #line 749
  1918. const TUint KFileShareMask=0xff;
  1919. enum TFormatMode
  1920. {
  1921. EHighDensity,
  1922. ELowDensity,
  1923. #line 780
  1924. EFullFormat=0,
  1925. #line 789
  1926. EQuickFormat=0x100,
  1927. ESpecialFormat=0x200
  1928. };
  1929. enum TSeek
  1930. #line 813
  1931. {
  1932. ESeekAddress,
  1933. ESeekStart,
  1934. ESeekCurrent,
  1935. ESeekEnd
  1936. };
  1937. class TEntry
  1938. #line 869
  1939. {
  1940. public:
  1941. __declspec(dllexport) TEntry();
  1942. __declspec(dllexport) TEntry(const TEntry& aEntry);
  1943. __declspec(dllexport) TEntry& operator=(const TEntry& aEntry);
  1944. __declspec(dllexport) TBool IsReadOnly() const;
  1945. __declspec(dllexport) TBool IsHidden() const;
  1946. __declspec(dllexport) TBool IsSystem() const;
  1947. __declspec(dllexport) TBool IsDir() const;
  1948. __declspec(dllexport) TBool IsArchive() const;
  1949. inline const TUid& operator[](TInt anIndex) const;
  1950. inline TBool IsUidPresent(TUid aUid) const;
  1951. inline TBool IsTypeValid() const;
  1952. inline TUid MostDerivedUid() const;
  1953. public:
  1954. #line 893
  1955. TUint iAtt;
  1956. TInt iSize;
  1957. TTime iModified;
  1958. TUidType iType;
  1959. #line 920
  1960. TBufC<KMaxFileName> iName;
  1961. private:
  1962. TUint32 iReserved[2];
  1963. };
  1964. class RDir;
  1965. class TEntryArray
  1966. #line 947
  1967. {
  1968. public:
  1969. __declspec(dllexport) TEntryArray();
  1970. __declspec(dllexport) TInt Count() const;
  1971. __declspec(dllexport) const TEntry& operator[](TInt anIndex) const;
  1972. private:
  1973. TInt iCount;
  1974. TInt iIndex;
  1975. const TEntry* iPos;
  1976. TBuf8<KEntryArraySize> iBuf;
  1977. friend class RDir;
  1978. friend class RFs;
  1979. };
  1980. class TDriveInfo
  1981. #line 973
  1982. {
  1983. public:
  1984. TMediaType iType;
  1985.     TBatteryState iBattery;
  1986. #line 997
  1987. TUint iDriveAtt;
  1988. #line 1010
  1989. TUint iMediaAtt;
  1990. private:
  1991. TUint32 iReserved;
  1992. };
  1993. class TVolumeInfo
  1994. #line 1033
  1995. {
  1996. public:
  1997. __declspec(dllexport) TVolumeInfo();
  1998. TDriveInfo iDrive;
  1999. TUint iUniqueID;
  2000. TInt64 iSize;
  2001. TInt64 iFree;
  2002. TBufC<KMaxFileName> iName;
  2003. private:
  2004. TUint32 iReserved[4];
  2005. };
  2006. class TDriveUnit
  2007. #line 1094
  2008. {
  2009. public:
  2010. inline TDriveUnit() {};
  2011. __declspec(dllexport) TDriveUnit(TInt aDrive);
  2012. __declspec(dllexport) TDriveUnit(const TDesC& aDrive);
  2013. __declspec(dllexport) TDriveUnit& operator=(TInt aDrive);
  2014. __declspec(dllexport) TDriveUnit& operator=(const TDesC& aDrive);
  2015. inline operator TInt() const;
  2016. __declspec(dllexport) TDriveName Name() const;
  2017. private:
  2018. TInt iDrive;
  2019. };
  2020. class RFs;
  2021. class TParseBase
  2022. #line 1139
  2023. {
  2024. private:
  2025. struct SField {TUint8 pos;TUint8 len;TUint8 present;TUint8 filler;};
  2026. enum TField {EDrive,EPath,EName,EExt,EMaxFields};
  2027. enum TWild {EWildName=0x01,EWildExt=0x02,EWildEither=0x04,EIsRoot=0x08,EWildIsKMatchOne=0x10,EWildIsKMatchAny=0x20};
  2028. public:
  2029. __declspec(dllexport) TParseBase();
  2030. __declspec(dllexport) TInt PopDir();
  2031. __declspec(dllexport) TInt AddDir(const TDesC& aName);
  2032. __declspec(dllexport) const TDesC& FullName() const;
  2033. __declspec(dllexport) TPtrC Drive() const;
  2034. __declspec(dllexport) TPtrC Path() const;
  2035. __declspec(dllexport) TPtrC DriveAndPath() const;
  2036. __declspec(dllexport) TPtrC Name() const;
  2037. __declspec(dllexport) TPtrC Ext() const;
  2038. __declspec(dllexport) TPtrC NameAndExt() const;
  2039. __declspec(dllexport) TBool DrivePresent() const;
  2040. __declspec(dllexport) TBool PathPresent() const;
  2041. __declspec(dllexport) TBool NamePresent() const;
  2042. __declspec(dllexport) TBool ExtPresent() const;
  2043. __declspec(dllexport) TBool NameOrExtPresent() const;
  2044. __declspec(dllexport) TBool IsRoot() const;
  2045. __declspec(dllexport) TBool IsWild() const;
  2046. __declspec(dllexport) TBool IsKMatchOne() const;
  2047. __declspec(dllexport) TBool IsKMatchAny() const;
  2048. __declspec(dllexport) TBool IsNameWild() const;
  2049. __declspec(dllexport) TBool IsExtWild() const;
  2050. protected:
  2051. virtual TDes& NameBuf() = 0;
  2052. virtual const TDesC& NameBufC() const = 0;
  2053. TInt Set(const TDesC* aName,const TDesC* aRelated,const TDesC* aDefault,TBool allowWild);
  2054. private:
  2055. TInt ParseDrive(TLex& aName,TBool& aDone);
  2056. TInt ParsePath(TLex& aName,TBool& aDone);
  2057. TInt ParseName(TLex& aName,TBool& aDone);
  2058. TInt ParseExt(TLex& aName,TBool& aDone);
  2059. protected:
  2060. TInt16 iMod;
  2061. private:
  2062. TInt16 iWild;
  2063. SField iField[EMaxFields];
  2064. };
  2065. class TParsePtr : public TParseBase
  2066. #line 1203
  2067. {
  2068. public:
  2069. __declspec(dllexport) TParsePtr(TDes& aName);
  2070. protected:
  2071. __declspec(dllexport) TDes& NameBuf();
  2072. __declspec(dllexport) const TDesC& NameBufC() const;
  2073. private:
  2074. TPtr iNameBuf;
  2075. };
  2076. class TParsePtrC : public TParseBase
  2077. #line 1235
  2078. {
  2079. public:
  2080. __declspec(dllexport) TParsePtrC(const TDesC& aName);
  2081. protected:
  2082. __declspec(dllexport) TDes& NameBuf();
  2083. __declspec(dllexport) const TDesC& NameBufC() const;
  2084. private:
  2085. TPtrC iNameBuf;
  2086. };
  2087. class TParse : public TParseBase
  2088. #line 1265
  2089. {
  2090. public:
  2091. __declspec(dllexport) TParse();
  2092. __declspec(dllexport) TInt Set(const TDesC& aName,const TDesC* aRelated,const TDesC* aDefault);
  2093. __declspec(dllexport) TInt SetNoWild(const TDesC& aName,const TDesC* aRelated,const TDesC* aDefault);
  2094. protected:
  2095. __declspec(dllexport) TDes& NameBuf();
  2096. __declspec(dllexport) const TDesC& NameBufC() const;
  2097. private:
  2098. TFileName iNameBuf;
  2099. };
  2100. class CDir : public CBase
  2101. #line 1289
  2102. {
  2103. public:
  2104. __declspec(dllexport) virtual ~CDir();
  2105. __declspec(dllexport) TInt Count() const;
  2106. __declspec(dllexport) const TEntry& operator[](TInt anIndex) const;
  2107. __declspec(dllexport) TInt Sort(TUint aEntrySortKey);
  2108. protected:
  2109. __declspec(dllexport) CDir();
  2110. __declspec(dllexport) static CDir* NewL();
  2111. __declspec(dllexport) void AddL(const TEntry& anEntry);
  2112. __declspec(dllexport) void ExtractL(TBool aRemove,CDir*& aDir);
  2113. __declspec(dllexport) void Compress();
  2114. protected:
  2115. CArrayPakFlat<TEntry> * iArray;
  2116. friend class RFs;
  2117. friend class TOpenFileScan;
  2118. };
  2119. class RFs : public RSessionBase
  2120. #line 1380
  2121. {
  2122. public:
  2123. __declspec(dllexport) TInt Connect(TInt aMessageSlots=KFileServerDefaultMessageSlots);
  2124. __declspec(dllexport) TVersion Version() const;
  2125. __declspec(dllexport) TInt AddFileSystem(const TDesC& aFileName) const;
  2126. __declspec(dllexport) TInt MountFileSystem(const TDesC& aFileSystemName,TInt aDrive) const;
  2127. __declspec(dllexport) TInt MountFileSystem(const TDesC& aFileSystemName,TInt aDrive, TBool aIsSync) const;
  2128. __declspec(dllexport) TInt MountFileSystemAndScan(const TDesC& aFileSystemName,TInt aDrive,TBool& aIsMountSuccess) const;
  2129. __declspec(dllexport) TInt MountFileSystem(const TDesC& aFileSystemName,const TDesC& aExtensionName,TInt aDrive);
  2130. __declspec(dllexport) TInt MountFileSystem(const TDesC& aFileSystemName,const TDesC& aExtensionName,TInt aDrive, TBool aIsSync);
  2131. __declspec(dllexport) TInt MountFileSystemAndScan(const TDesC& aFileSystemName,const TDesC& aExtensionName,TInt aDrive,TBool& aIsMountSuccess) const;
  2132. __declspec(dllexport) TInt DismountFileSystem(const TDesC& aFileSystemName,TInt aDrive) const;
  2133. __declspec(dllexport) TInt RemoveFileSystem(const TDesC& aFileSystemName) const;
  2134. __declspec(dllexport) TInt FileSystemName(TDes& aName,TInt aDrive) const;
  2135. __declspec(dllexport) TInt AddExtension(const TDesC& aFileName);
  2136. __declspec(dllexport) TInt MountExtension(const TDesC& aExtensionName,TInt aDrive);
  2137. __declspec(dllexport) TInt DismountExtension(const TDesC& aExtensionName,TInt aDrive);
  2138. __declspec(dllexport) TInt RemoveExtension(const TDesC& aExtensionName);
  2139. __declspec(dllexport) TInt ExtensionName(TDes& aExtensionName,TInt aDrive,TInt aPos);
  2140. __declspec(dllexport) TInt RemountDrive(TInt aDrive,const TDesC8* aMountInfo=0 ,TUint aFlags=0);
  2141. __declspec(dllexport) void NotifyChange(TNotifyType aType,TRequestStatus& aStat);
  2142. __declspec(dllexport) void NotifyChange(TNotifyType aType,TRequestStatus& aStat,const TDesC& aPathName);
  2143. __declspec(dllexport) void NotifyChangeCancel();
  2144. __declspec(dllexport) void NotifyChangeCancel(TRequestStatus& aStat);
  2145. __declspec(dllexport) void NotifyDiskSpace(TInt64 aThreshold,TInt aDrive,TRequestStatus& aStat);
  2146. __declspec(dllexport) void NotifyDiskSpaceCancel(TRequestStatus& aStat);
  2147. __declspec(dllexport) void NotifyDiskSpaceCancel();
  2148. __declspec(dllexport) TInt DriveList(TDriveList& aList) const;
  2149. __declspec(dllexport) TInt Drive(TDriveInfo& anInfo,TInt aDrive=KDefaultDrive) const;
  2150. __declspec(dllexport) TInt Volume(TVolumeInfo& aVol,TInt aDrive=KDefaultDrive) const;
  2151. __declspec(dllexport) TInt SetVolumeLabel(const TDesC& aName,TInt aDrive=KDefaultDrive);
  2152. __declspec(dllexport) TInt Subst(TDes& aPath,TInt aDrive=KDefaultDrive) const;
  2153. __declspec(dllexport) TInt SetSubst(const TDesC& aPath,TInt aDrive=KDefaultDrive);
  2154. __declspec(dllexport) TInt RealName(const TDesC& aName,TDes& aResult) const;
  2155.     __declspec(dllexport) TInt GetMediaSerialNumber(TMediaSerialNumber& aSerialNum, TInt aDrive);
  2156. __declspec(dllexport) TInt SessionPath(TDes& aPath) const;
  2157. __declspec(dllexport) TInt SetSessionPath(const TDesC& aPath);
  2158. __declspec(dllexport) TInt Parse(const TDesC& aName,TParse& aParse) const;
  2159. __declspec(dllexport) TInt Parse(const TDesC& aName,const TDesC& aRelated,TParse& aParse) const;
  2160. __declspec(dllexport) TInt MkDir(const TDesC& aPath);
  2161. __declspec(dllexport) TInt MkDirAll(const TDesC& aPath);
  2162. __declspec(dllexport) TInt RmDir(const TDesC& aPath);
  2163. __declspec(dllexport) TInt GetDir(const TDesC& aName,TUint anEntryAttMask,TUint anEntrySortKey,CDir*& anEntryList) const;
  2164. __declspec(dllexport) TInt GetDir(const TDesC& aName,TUint anEntryAttMask,TUint anEntrySortKey,CDir*& anEntryList,CDir*& aDirList) const;
  2165. __declspec(dllexport) TInt GetDir(const TDesC& aName,const TUidType& anEntryUid,TUint anEntrySortKey,CDir*& aFileList) const;
  2166. __declspec(dllexport) TInt Delete(const TDesC& aName);
  2167. __declspec(dllexport) TInt Rename(const TDesC& anOldName,const TDesC& aNewName);
  2168. __declspec(dllexport) TInt Replace(const TDesC& anOldName,const TDesC& aNewName);
  2169. __declspec(dllexport) TInt Att(const TDesC& aName,TUint& aAttValue) const;
  2170. __declspec(dllexport) TInt SetAtt(const TDesC& aName,TUint aSetAttMask,TUint aClearAttMask);
  2171. __declspec(dllexport) TInt Modified(const TDesC& aName,TTime& aTime) const;
  2172. __declspec(dllexport) TInt SetModified(const TDesC& aName,const TTime& aTime);
  2173. __declspec(dllexport) TInt Entry(const TDesC& aName,TEntry& anEntry) const;
  2174. __declspec(dllexport) TInt SetEntry(const TDesC& aName,const TTime& aTime,TUint aSetAttMask,TUint aClearAttMask);
  2175. __declspec(dllexport) TInt ReadFileSection(const TDesC& aName,TInt aPos,TDes8& aDes,TInt aLength) const;
  2176. __declspec(dllexport) static TBool IsValidDrive(TInt aDrive);
  2177. __declspec(dllexport) static TInt CharToDrive(TChar aChar,TInt& aDrive);
  2178. __declspec(dllexport) static TInt DriveToChar(TInt aDrive,TChar& aChar);
  2179. __declspec(dllexport) static TBool IsRomAddress(TAny* aAny);
  2180. __declspec(dllexport) void ResourceCountMarkStart() const;
  2181. __declspec(dllexport) void ResourceCountMarkEnd() const;
  2182. __declspec(dllexport) TInt ResourceCount() const;
  2183. __declspec(dllexport) TInt IsFileOpen(const TDesC& aFile,TBool& anAnswer) const;
  2184. __declspec(dllexport) TInt CheckDisk(const TDesC& aDrive) const;
  2185. __declspec(dllexport) TInt ScanDrive(const TDesC& aDrive) const;
  2186. __declspec(dllexport) TInt GetShortName(const TDesC& aLongName,TDes& aShortName) const;
  2187. __declspec(dllexport) TInt GetLongName(const TDesC& aShortName,TDes& aLongName) const;
  2188. __declspec(dllexport) TBool GetNotifyUser();
  2189. __declspec(dllexport) void SetNotifyUser(TBool aValue);
  2190. __declspec(dllexport) TUint8* IsFileInRom(const TDesC& aFileName) const;
  2191. __declspec(dllexport) TBool IsValidName(const TDesC& anEntryName) const;
  2192. __declspec(dllexport) TBool IsValidName(const TDesC& aFileName,TText& aBadChar) const;
  2193. __declspec(dllexport) TInt GetDriveName(TInt aDrive,TDes& aDriveName) const;
  2194. __declspec(dllexport) TInt SetDriveName(TInt aDrive,const TDesC& aDriveName);
  2195. __declspec(dllexport) TInt LoaderHeapFunction(TInt aFunction, TAny *aArg1=0 , TAny *aArg2=0 );
  2196. __declspec(dllexport) TInt SetErrorCondition(TInt anError,TInt aCount=0);
  2197. __declspec(dllexport) TInt SetDebugRegister(TInt aVal);
  2198. __declspec(dllexport) TInt SetAllocFailure(TInt aAllocNum);
  2199. __declspec(dllexport) void DebugNotify(TInt aDrive,TUint aNotifyType,TRequestStatus& aStat);
  2200. __declspec(dllexport) TInt ControlIo(TInt aDrive,TInt aCommand);
  2201. __declspec(dllexport) TInt ControlIo(TInt aDrive,TInt aCommand,TDes8& aParam1);
  2202. __declspec(dllexport) TInt ControlIo(TInt aDrive,TInt aCommand,TDes8& aParam1,TDes8& aParam2);
  2203. __declspec(dllexport) TInt ControlIo(TInt aDrive,TInt aCommand,TAny* aParam1,TAny* aParam2);
  2204. __declspec(dllexport) TInt LockDrive(TInt aDrv, const TMediaPassword &aOld, const TMediaPassword &aNew, TBool aStr);
  2205. __declspec(dllexport) TInt UnlockDrive(TInt aDrv, const TMediaPassword &Pswd, TBool aStr);
  2206. __declspec(dllexport) TInt ClearPassword(TInt aDrv, const TMediaPassword &aPswd);
  2207. __declspec(dllexport) TInt ErasePassword(TInt aDrv);
  2208. __declspec(dllexport) TInt SetSessionToPrivate(TInt aDrive);
  2209. __declspec(dllexport) TInt PrivatePath(TDes& aPath);
  2210. __declspec(dllexport) TInt CreatePrivatePath(TInt aDrive);
  2211. __declspec(dllexport) void StartupInitComplete(TRequestStatus& aStat);
  2212. __declspec(dllexport) TInt SetLocalDriveMapping(const TDesC8& aMapping);
  2213. __declspec(dllexport) TInt FinaliseDrives();
  2214. __declspec(dllexport) TInt SwapFileSystem(const TDesC& aOldFileSystemName,const TDesC& aNewFileSystemName,TInt aDrive) const;
  2215. __declspec(dllexport) TInt ReserveDriveSpace(TInt aDriveNo, TInt aSpace);
  2216. __declspec(dllexport) TInt GetReserveAccess(TInt aDriveNo);
  2217. __declspec(dllexport) TInt ReleaseReserveAccess(TInt aDriveNo);
  2218. __declspec(dllexport) TInt AddPlugin(const TDesC& aFileName) const;
  2219. __declspec(dllexport) TInt RemovePlugin(const TDesC& aPluginName) const;
  2220. __declspec(dllexport) TInt PluginName(TDes& aPluginName,TInt aDrive,TInt aPos);
  2221. __declspec(dllexport) TInt MountPlugin(const TDesC& aPluginName) const;
  2222. __declspec(dllexport) TInt MountPlugin(const TDesC& aPluginName,TInt aDrive) const;
  2223. __declspec(dllexport) TInt MountPlugin(const TDesC& aPluginName,TInt aDrive, TInt aPos) const;
  2224. __declspec(dllexport) TInt DismountPlugin(const TDesC& aPluginName) const;
  2225. __declspec(dllexport) TInt DismountPlugin(const TDesC& aPluginName,TInt aDrive) const;
  2226. __declspec(dllexport) TInt DismountPlugin(const TDesC& aPluginName,TInt aDrive,TInt aPos) const;
  2227. __declspec(dllexport) void NotifyDismount(TInt aDrive, TRequestStatus& aStat, TNotifyDismountMode aMode=EFsDismountRegisterClient) const;
  2228. __declspec(dllexport) void NotifyDismountCancel(TRequestStatus& aStat) const;
  2229. __declspec(dllexport) void NotifyDismountCancel() const;
  2230. __declspec(dllexport) TInt AllowDismount(TInt aDrive) const;
  2231.     __declspec(dllexport) TInt SetStartupConfiguration(TInt aCommand,TAny* aParam1,TAny* aParam2) const;
  2232. private:
  2233. void GetDirL(const TDesC& aMatchName,TUint anEntryAttMask,TUint anEntrySortKey,CDir*& anEntryList,CDir*& aDirList,RDir& aDir) const;
  2234. void GetDirL(const TDesC& aMatchName,TUint anEntryAttMask,TUint anEntrySortKey,CDir*& anEntryList,RDir& aDir) const;
  2235. void GetDirL(const TDesC& aMatchName,const TUidType& aUidType,TUint anEntrySortKey,CDir*& anEntryList,RDir& aDir) const;
  2236. void DoGetDirL(TUint anEntrySortKey,CDir*& anEntryList,RDir& aDir) const;
  2237. TInt GetOpenFileList(TInt& aSessionNum,TInt& aLocalPos,TThreadId& aThreadId,TEntryArray& anArray) const;
  2238. friend class TOpenFileScan;
  2239. };
  2240. #line 1569
  2241. class RFile : public RSubSessionBase
  2242. {
  2243. public:
  2244. __declspec(dllexport) TInt Open(RFs& aFs,const TDesC& aName,TUint aFileMode);
  2245. __declspec(dllexport) void Close();
  2246. __declspec(dllexport) TInt Create(RFs& aFs,const TDesC& aName,TUint aFileMode);
  2247. __declspec(dllexport) TInt Replace(RFs& aFs,const TDesC& aName,TUint aFileMode);
  2248. __declspec(dllexport) TInt Temp(RFs& aFs,const TDesC& aPath,TFileName& aName,TUint aFileMode);
  2249. __declspec(dllexport) TInt Read(TDes8& aDes) const;
  2250. __declspec(dllexport) void Read(TDes8& aDes,TRequestStatus& aStatus) const;
  2251. __declspec(dllexport) TInt Read(TDes8& aDes,TInt aLength) const;
  2252. __declspec(dllexport) void Read(TDes8& aDes,TInt aLength,TRequestStatus& aStatus) const;
  2253. __declspec(dllexport) TInt Read(TInt aPos,TDes8& aDes) const;
  2254. __declspec(dllexport) void Read(TInt aPos,TDes8& aDes,TRequestStatus& aStatus) const;
  2255. __declspec(dllexport) TInt Read(TInt aPos,TDes8& aDes,TInt aLength) const;
  2256. __declspec(dllexport) void Read(TInt aPos,TDes8& aDes,TInt aLength,TRequestStatus& aStatus) const;
  2257. __declspec(dllexport) void ReadCancel(TRequestStatus& aStatus) const;
  2258. __declspec(dllexport) void ReadCancel() const;
  2259. __declspec(dllexport) TInt Write(const TDesC8& aDes);
  2260. __declspec(dllexport) void Write(const TDesC8& aDes,TRequestStatus& aStatus);
  2261. __declspec(dllexport) TInt Write(const TDesC8& aDes,TInt aLength);
  2262. __declspec(dllexport) void Write(const TDesC8& aDes,TInt aLength,TRequestStatus& aStatus);
  2263. __declspec(dllexport) TInt Write(TInt aPos,const TDesC8& aDes);
  2264. __declspec(dllexport) void Write(TInt aPos,const TDesC8& aDes,TRequestStatus& aStatus);
  2265. __declspec(dllexport) TInt Write(TInt aPos,const TDesC8& aDes,TInt aLength);
  2266. __declspec(dllexport) void Write(TInt aPos,const TDesC8& aDes,TInt aLength,TRequestStatus& aStatus);
  2267. __declspec(dllexport) TInt Lock(TInt aPos,TInt aLength) const;
  2268. __declspec(dllexport) TInt UnLock(TInt aPos,TInt aLength) const;
  2269. __declspec(dllexport) TInt Seek(TSeek aMode,TInt& aPos) const;
  2270. __declspec(dllexport) TInt Flush();
  2271. __declspec(dllexport) TInt Size(TInt& aSize) const;
  2272. __declspec(dllexport) TInt SetSize(TInt aSize);
  2273. __declspec(dllexport) TInt Att(TUint& aAttValue) const;
  2274. __declspec(dllexport) TInt SetAtt(TUint aSetAttMask,TUint aClearAttMask);
  2275. __declspec(dllexport) TInt Modified(TTime& aTime) const;
  2276. __declspec(dllexport) TInt SetModified(const TTime& aTime);
  2277. __declspec(dllexport) TInt Set(const TTime& aTime,TUint aSetAttMask,TUint aClearAttMask);
  2278. __declspec(dllexport) TInt ChangeMode(TFileMode aNewMode);
  2279. __declspec(dllexport) TInt Rename(const TDesC& aNewName);
  2280. __declspec(dllexport) TInt Drive(TInt &aDriveNumber, TDriveInfo &aDriveInfo) const;
  2281. __declspec(dllexport) TInt Adopt(RFs& aFs, TInt aHandle);
  2282. __declspec(dllexport) TInt AdoptFromClient(const RMessage2& aMsg, TInt aFsHandleIndex, TInt aFileHandleIndex);
  2283. __declspec(dllexport) TInt AdoptFromServer(TInt aFsHandle, TInt aFileHandle);
  2284. __declspec(dllexport) TInt AdoptFromCreator(TInt aFsIndex, TInt aFileHandleIndex);
  2285. __declspec(dllexport) TInt Name(TDes& aName) const;
  2286. __declspec(dllexport) TInt TransferToServer(TIpcArgs& aIpcArgs, TInt aFsHandleIndex, TInt aFileHandleIndex) const;
  2287. __declspec(dllexport) TInt TransferToClient(const RMessage2& aMsg, TInt aFileHandleIndex) const;
  2288. __declspec(dllexport) TInt TransferToProcess(RProcess& aProcess, TInt aFsHandleIndex, TInt aFileHandleIndex) const;
  2289. __declspec(dllexport) TInt Duplicate(const RFile& aFile, TOwnerType aType=EOwnerProcess);
  2290. __declspec(dllexport) TInt FullName(TDes& aName) const;
  2291. private:
  2292. TInt DuplicateHandle(TInt& aSubSessionHandle) const;
  2293. };
  2294. class RDir : public RSubSessionBase
  2295. #line 1655
  2296. {
  2297. public:
  2298. __declspec(dllexport) TInt Open(RFs& aFs,const TDesC& aMatchName,const TUidType& aUidType);
  2299. __declspec(dllexport) TInt Open(RFs& aFs,const TDesC& aMatchName,TUint anAttMask);
  2300. __declspec(dllexport) void Close();
  2301. __declspec(dllexport) TInt Read(TEntryArray& anArray) const;
  2302. __declspec(dllexport) void Read(TEntryArray& anArray,TRequestStatus& aStatus) const;
  2303. __declspec(dllexport) TInt Read(TEntry& anEntry) const;
  2304. __declspec(dllexport) void Read(TPckg<TEntry>& anEntry,TRequestStatus& aStatus) const;
  2305. };
  2306. class RFormat : public RSubSessionBase
  2307. #line 1681
  2308. {
  2309. public:
  2310. __declspec(dllexport) TInt Open(RFs& aFs,const TDesC& aName,TUint aFormatMode,TInt& aCount);
  2311. __declspec(dllexport) TInt Open(RFs& aFs,const TDesC& aName,TUint aFormatMode,TInt& aCount,const TDesC8& anInfo);
  2312. __declspec(dllexport) void Close();
  2313. __declspec(dllexport) TInt Next(TInt& aStep);
  2314. __declspec(dllexport) void Next(TPckgBuf<TInt>& aStep,TRequestStatus& aStatus);
  2315. };
  2316. class RRawDisk : public RSubSessionBase
  2317. #line 1704
  2318. {
  2319. public:
  2320. __declspec(dllexport) TInt Open(RFs& aFs,TInt aDrive);
  2321. __declspec(dllexport) void Close();
  2322. __declspec(dllexport) TInt Read(TInt64 aPos,TDes8& aDes);
  2323. __declspec(dllexport) TInt Write(TInt64 aPos,TDesC8& aDes);
  2324. private:
  2325. TInt iDrive;
  2326. };
  2327. class CDirStack;
  2328. class CDirScan : public CBase
  2329. #line 1733
  2330.     {
  2331. public:
  2332. enum TScanDirection
  2333. {
  2334. EScanUpTree,
  2335. EScanDownTree
  2336. };
  2337. public:
  2338. __declspec(dllexport) static CDirScan* NewL(RFs& aFs);
  2339. __declspec(dllexport) static CDirScan* NewLC(RFs& aFs);
  2340. __declspec(dllexport) ~CDirScan();
  2341. __declspec(dllexport) void SetScanDataL(const TDesC& aMatchName,TUint anEntryAttMask,TUint anEntrySortMask,TScanDirection aScanDir=EScanDownTree);
  2342. __declspec(dllexport) void NextL(CDir*& aDirEntries);
  2343. __declspec(dllexport) TPtrC AbbreviatedPath();
  2344. __declspec(dllexport) TPtrC FullPath();
  2345. protected:
  2346. CDirScan(RFs& aFs);
  2347. private:
  2348. inline RFs& Fs();
  2349. void UpdateAbbreviatedPath();
  2350. void ScanUpTreeL(CDir*& aDirEntries);
  2351. void ScanDownTreeL(CDir*& aDirEntries);
  2352. void GetDirEntriesL(CDir*& aDirEntries);
  2353. private:
  2354. RFs* const iFs;
  2355. TParse iFullPath;
  2356. TPtrC iAbbreviatedPath;
  2357. TInt iAbbreviatedPathPos;
  2358. TUint iEntryAttMask;
  2359. TUint iEntrySortMask;
  2360. TBool iScanning;
  2361. TScanDirection iScanDir;
  2362. CDirStack* iStack;
  2363. };
  2364. enum TFileManError
  2365. #line 1792
  2366. {
  2367. ENoExtraInformation,
  2368. #line 1808
  2369. EInitializationFailed,
  2370. #line 1819
  2371. EScanNextDirectoryFailed,
  2372. ESrcOpenFailed,
  2373. ETrgOpenFailed,
  2374. ENoFilesProcessed
  2375. };
  2376. class MFileManObserver
  2377. #line 1868
  2378. {
  2379. public:
  2380. enum TControl
  2381. {
  2382. EContinue,
  2383. ERetry,
  2384. EAbort,
  2385. ECancel
  2386. };
  2387. public:
  2388. __declspec(dllexport) virtual TControl NotifyFileManStarted();
  2389. __declspec(dllexport) virtual TControl NotifyFileManOperation();
  2390. __declspec(dllexport) virtual TControl NotifyFileManEnded();
  2391. };
  2392. class CFileBase : public CBase
  2393. #line 1919
  2394. {
  2395. public:
  2396. __declspec(dllexport) void SetObserver(MFileManObserver* anObserver);
  2397. public:
  2398. __declspec(dllexport) const TEntry& CurrentEntry();
  2399. __declspec(dllexport) TPtrC AbbreviatedPath();
  2400. __declspec(dllexport) TPtrC FullPath();
  2401. __declspec(dllexport) TInt GetLastError();
  2402. __declspec(dllexport) TFileManError GetMoreInfoAboutError();
  2403. protected:
  2404. __declspec(dllexport) CFileBase(RFs& anFs);
  2405. __declspec(dllexport) void ConstructL();
  2406. __declspec(dllexport) ~CFileBase();
  2407. __declspec(dllexport) void RunL();
  2408. __declspec(dllexport) void RunInSeparateThreadL(TThreadFunction aThreadFunction);
  2409. virtual void CompleteOperationL() {};
  2410. virtual void DoOperationL() = 0;
  2411. protected:
  2412. RFs iFs;
  2413. RFs iFsOld;
  2414. RThread iFManThread;
  2415. RSemaphore iSynchronizer;
  2416. CDirScan* iScanner;
  2417. CDir* iDirList;
  2418. TInt iCurrentEntry;
  2419. TUint iMatchEntry;
  2420. TUint iSwitches;
  2421. TParse iSrcFile;
  2422. MFileManObserver* iObserver;
  2423. TInt iLastError;
  2424. TFileManError iErrorInfo;
  2425. TRequestStatus* iStatus;
  2426. HBufC* iSessionPath;
  2427. TInt iNumberOfFilesProcessed;
  2428. friend void DoFManBaseOperationL(TAny* aPtr);
  2429. friend TInt FManBaseThreadFunction(TAny* aPtr);
  2430. };
  2431. class CFileMan : public CFileBase
  2432. #line 2007
  2433. {
  2434. public:
  2435. enum TAction
  2436. {
  2437. ENone,
  2438. EAttribs,
  2439. ECopy,
  2440. EDelete,
  2441. EMove,
  2442. ERename,
  2443. ERmDir,
  2444. ERenameInvalidEntry,
  2445. ECopyFromHandle,
  2446. };
  2447. #line 2078
  2448. enum TSwitch
  2449. {
  2450. EOverWrite=1,
  2451. ERecurse=2
  2452. };
  2453. public:
  2454. __declspec(dllexport) static CFileMan* NewL(RFs& aFs);
  2455. __declspec(dllexport) static CFileMan* NewL(RFs& aFs,MFileManObserver* anObserver);
  2456. ~CFileMan();
  2457. __declspec(dllexport) TAction CurrentAction();
  2458. __declspec(dllexport) void GetCurrentTarget(TFileName& aFile);
  2459. __declspec(dllexport) void GetCurrentSource(TFileName& aFile);
  2460. __declspec(dllexport) TInt BytesTransferredByCopyStep();
  2461. public:
  2462. __declspec(dllexport) TInt Attribs(const TDesC& aName,TUint aSetMask,TUint aClearMask,const TTime& aTime,TUint aSwitch=0);
  2463. __declspec(dllexport) TInt Attribs(const TDesC& aName,TUint aSetMask,TUint aClearMask,const TTime& aTime,TUint aSwitch,TRequestStatus& aStatus);
  2464. __declspec(dllexport) TInt Copy(const TDesC& anOld,const TDesC& aNew,TUint aSwitch=EOverWrite);
  2465. __declspec(dllexport) TInt Copy(const TDesC& anOld,const TDesC& aNew,TUint aSwitch,TRequestStatus& aStatus);
  2466. __declspec(dllexport) TInt Delete(const TDesC& aName,TUint aSwitch=0);
  2467. __declspec(dllexport) TInt Delete(const TDesC& aName,TUint aSwitch,TRequestStatus& aStatus);
  2468. __declspec(dllexport) TInt Move(const TDesC& anOld,const TDesC& aNew,TUint aSwitch=EOverWrite);
  2469. __declspec(dllexport) TInt Move(const TDesC& anOld,const TDesC& aNew,TUint aSwitch,TRequestStatus& aStatus);
  2470. __declspec(dllexport) TInt Rename(const TDesC& anOld,const TDesC& aNew,TUint aSwitch=EOverWrite);
  2471. __declspec(dllexport) TInt Rename(const TDesC& anOld,const TDesC& aNew,TUint aSwitch,TRequestStatus& aStatus);
  2472. __declspec(dllexport) TInt RmDir(const TDesC& aDirName);
  2473. __declspec(dllexport) TInt RmDir(const TDesC& aDirName,TRequestStatus& aStatus);
  2474. __declspec(dllexport) TInt Copy(const RFile& anOld,const TDesC& aNew,TUint aSwitches=EOverWrite);
  2475. __declspec(dllexport) TInt Copy(const RFile& anOld,const TDesC& aNew,TUint aSwitches,TRequestStatus& aStatus);
  2476. protected:
  2477. CFileMan(RFs& aFs);
  2478. TInt RenameInvalidEntry(const TDesC& anOld,const TDesC& aNew,TUint aSwitch=EOverWrite);
  2479. private:
  2480. void CompleteOperationL();
  2481. void DoOperationL();
  2482. void CheckForDirectory();
  2483. void SetFlags(TBool aOverWrite,TBool aRecurse,TBool aScanDirection,TBool aMoveRename);
  2484. void GetSrcAndTrg(TParse& aSrcName,TFileName& aTrgName);
  2485. void DoSynchronize(TInt aRetVal);
  2486. TInt CheckRenameAllowed(const TDesC& aSrcName,const TDesC& aTrgName);
  2487. private:
  2488. void DoAttribsL();
  2489. void DoCopyOrMoveL();
  2490. void DoDeleteL();
  2491. void DoRenameL();
  2492. void DoRmDirL();
  2493. void DoCopyFromHandleL();
  2494. TInt DoCopy(const RFile& aSrcFile, RFile& aDstFile, TInt& aRet);
  2495. private:
  2496. TParse iTrgFile;
  2497. TAction iAction;
  2498. TUint iSetMask;
  2499. TUint iClearMask;
  2500. TTime iTime;
  2501. TInt iBytesTransferred;
  2502. RFile iSrcFileHandle;
  2503. friend void RenameInvalidEntryL(RFs& aFs,TParse& aSrcFile);
  2504. };
  2505. class TFindFile
  2506. #line 2167
  2507. {
  2508. public:
  2509. __declspec(dllexport) TFindFile(RFs& aFs);
  2510. __declspec(dllexport) TInt FindByPath(const TDesC& aFileName,const TDesC* aPathList);
  2511. __declspec(dllexport) TInt FindByDir(const TDesC& aFileName,const TDesC& aDirPath);
  2512. __declspec(dllexport) TInt Find();
  2513. __declspec(dllexport) TInt FindWildByPath(const TDesC& aFileName,const TDesC* aPathList,CDir*& aDirList);
  2514. __declspec(dllexport) TInt FindWildByDir(const TDesC& aFileName,const TDesC& aDirPath,CDir*& aDir);
  2515. __declspec(dllexport) TInt FindWild(CDir*& aDirList);
  2516. inline const TDesC& File() const;
  2517. private:
  2518. TInt DoFind();
  2519. TInt DoFindByPath(const TDesC& aFileName,const TDesC* aPathList);
  2520. TInt DoFindByDir(const TDesC& aFileName,const TDesC& aDir);
  2521. TInt DoFindInDir();
  2522. TInt DoFindNextInPath();
  2523. TInt DoFindNextInDriveList();
  2524. private:
  2525. RFs* const iFs;
  2526. TParse iFile;
  2527. TInt iPathPos;
  2528. TInt iCurrentDrive;
  2529. TInt iMode;
  2530. const TDesC* iPath;
  2531. TDriveList iDrvList;
  2532. CDir** iDir;
  2533. TUint32 iReserved;
  2534. };
  2535. #line 2208
  2536. typedef CDir CFileList;
  2537. class TOpenFileScan
  2538. #line 2226
  2539. {
  2540. public:
  2541. __declspec(dllexport) TOpenFileScan(RFs& aFs);
  2542. __declspec(dllexport) void NextL(CFileList*& aFileList);
  2543. __declspec(dllexport) TThreadId ThreadId() const;
  2544. private:
  2545. RFs* iFs;
  2546. TThreadId iThreadId;
  2547. TInt iScanPos;
  2548. TInt iEntryListPos;
  2549. };
  2550. class TFileText
  2551. {
  2552. public:
  2553. enum TFileState
  2554. {
  2555. EStartOfFile,
  2556. ENormal,
  2557. EReverse
  2558. };
  2559. public:
  2560. __declspec(dllexport) TFileText();
  2561. __declspec(dllexport) void Set(RFile& aFile);
  2562. __declspec(dllexport) TInt Read(TDes& aDes);
  2563. __declspec(dllexport) TInt Write(const TDesC& aDes);
  2564. __declspec(dllexport) TInt Seek(TSeek aMode);
  2565. private:
  2566. void NextRecord();
  2567. TInt CheckForTerminator(TBool& anAnswer);
  2568. TInt FillBuffer();
  2569. private:
  2570. const TText* iNext;
  2571. const TText* iEnd;
  2572. TFileState iState;
  2573. RFile iFile;
  2574. TBuf8<0x100> iReadBuf;
  2575. };
  2576. #line 2284
  2577. __declspec(dllexport) TBool FileNamesIdentical(const TDesC& aFileName1,const TDesC& aFileName2);
  2578. #line 2294
  2579. class TLocalDriveMappingInfo
  2580. {
  2581. public:
  2582. enum TDrvMapOperation {EWriteMappingsAndSet=0,EWriteMappingsNoSet=1,ESwapIntMappingAndSet=2};
  2583. public:
  2584. TInt iDriveMapping[KMaxLocalDrives];
  2585. TDrvMapOperation iOperation;
  2586.     };
  2587. typedef TPckgBuf<TLocalDriveMappingInfo> TLocalDriveMappingInfoBuf;
  2588. class RPlugin : public RSubSessionBase
  2589. {
  2590. public:
  2591. __declspec(dllexport) TInt Open(RFs& aFs, TInt aPos);
  2592. __declspec(dllexport) void Close();
  2593. protected:
  2594. __declspec(dllexport) void DoRequest(TInt aReqNo,TRequestStatus& aStatus) const;
  2595. __declspec(dllexport) void DoRequest(TInt aReqNo,TRequestStatus& aStatus,TDes8& a1) const;
  2596. __declspec(dllexport) void DoRequest(TInt aReqNo,TRequestStatus& aStatus,TDes8& a1,TDes8& a2) const;
  2597. __declspec(dllexport) TInt DoControl(TInt aFunction) const;
  2598. __declspec(dllexport) TInt DoControl(TInt aFunction,TDes8& a1) const;
  2599. __declspec(dllexport) TInt DoControl(TInt aFunction,TDes8& a1,TDes8& a2) const;
  2600. __declspec(dllexport) void DoCancel(TUint aReqMask) const;
  2601. };
  2602. #line 2334
  2603. const TInt KPluginAutoAttach = 0x19;
  2604. #line 2345
  2605. const TInt KPluginAutoLocate = 0xC8;
  2606. const TInt KFileServerUidValue = 0x100039e3;
  2607. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\f32file.inl" /* stack depth 9 */
  2608. #line 10
  2609. inline const TUid& TEntry::operator[](TInt anIndex) const
  2610. #line 21
  2611.     {return(iType[anIndex]);}
  2612. inline TBool TEntry::IsUidPresent(TUid aUid) const
  2613. #line 37
  2614.     {return(iType.IsPresent(aUid));}
  2615. inline TBool TEntry::IsTypeValid() const
  2616. #line 51
  2617.     {return(iType.IsValid());}
  2618. inline TUid TEntry::MostDerivedUid() const
  2619. #line 65
  2620.     {return(iType.MostDerived());}
  2621. inline TInt EntrySize(const TEntry& anEntry)
  2622. {return(sizeof(TUint)+sizeof(TInt)+sizeof(TTime)+sizeof(TInt)+sizeof(TUidType)+anEntry.iName.Size());}
  2623. inline const TDesC& TFindFile::File() const
  2624. #line 93
  2625. {return iFile.FullName();}
  2626. inline RFs& CDirScan::Fs()
  2627. {return(*iFs);}
  2628. inline TDriveUnit::operator TInt() const
  2629. {return(iDrive);}
  2630. #line 2355 "C:\Symbian\9.1\S60_3rd\epoc32\include\f32file.h" /* stack depth 8 */
  2631. #line 20 "C:\Symbian\9.1\S60_3rd\epoc32\include\fntstore.h" /* stack depth 7 */
  2632. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\gdi.h" /* stack depth 8 */
  2633. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\s32std.h" /* stack depth 9 */
  2634. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\s32strm.h" /* stack depth 10 */
  2635. #line 12
  2636. const TInt KMaxCardinality=0x1fffffff;
  2637. class MStreamBuf;
  2638. class RWriteStream;
  2639. #line 27
  2640. class RReadStream
  2641. {
  2642. public:
  2643. inline RReadStream();
  2644. inline RReadStream(MStreamBuf* aSource);
  2645. inline MStreamBuf* Source();
  2646. inline void Close();
  2647. __declspec(dllexport) void Release();
  2648. __declspec(dllexport) void PushL();
  2649. inline void Pop();
  2650. __declspec(dllexport) void ReadL(TDes8& aDes);
  2651. __declspec(dllexport) void ReadL(TDes8& aDes,TInt aLength);
  2652. __declspec(dllexport) void ReadL(TDes8& aDes,TChar aDelim);
  2653. __declspec(dllexport) void ReadL(TUint8* aPtr,TInt aLength);
  2654. __declspec(dllexport) void ReadL(TInt aLength);
  2655. inline void ReadL(RWriteStream& aStream);
  2656. inline void ReadL(RWriteStream& aStream,TInt aLength);
  2657. __declspec(dllexport) void ReadL(TDes16& aDes);
  2658. __declspec(dllexport) void ReadL(TDes16& aDes,TInt aLength);
  2659. __declspec(dllexport) void ReadL(TDes16& aDes,TChar aDelim);
  2660. __declspec(dllexport) void ReadL(TUint16* aPtr,TInt aLength);
  2661. __declspec(dllexport) TInt8 ReadInt8L();
  2662. __declspec(dllexport) TInt16 ReadInt16L();
  2663. __declspec(dllexport) TInt32 ReadInt32L();
  2664. __declspec(dllexport) TUint8 ReadUint8L();
  2665. __declspec(dllexport) TUint16 ReadUint16L();
  2666. __declspec(dllexport) TUint32 ReadUint32L();
  2667. __declspec(dllexport) TReal32 ReadReal32L() ;
  2668. __declspec(dllexport) TReal64 ReadReal64L() ;
  2669. protected:
  2670. inline void Attach(MStreamBuf* aSource);
  2671. inline void Detach();
  2672. private:
  2673. MStreamBuf* iSrc;
  2674. private:
  2675. friend class RWriteStream;
  2676. };
  2677. template <class T>
  2678. class MExternalizer;
  2679. class TStreamRef;
  2680. #line 82
  2681. class RWriteStream
  2682. {
  2683. public:
  2684. inline RWriteStream();
  2685. inline RWriteStream(const MExternalizer<TStreamRef>& anExter);
  2686. inline RWriteStream(MStreamBuf* aSink);
  2687. inline MStreamBuf* Sink();
  2688. __declspec(dllexport) void Close();
  2689. __declspec(dllexport) void Release();
  2690. __declspec(dllexport) void CommitL();
  2691. __declspec(dllexport) void PushL();
  2692. inline void Pop();
  2693. __declspec(dllexport) void WriteL(const TDesC8& aDes);
  2694. __declspec(dllexport) void WriteL(const TDesC8& aDes,TInt aLength);
  2695. __declspec(dllexport) void WriteL(const TUint8* aPtr,TInt aLength);
  2696. __declspec(dllexport) void WriteL(RReadStream& aStream);
  2697. __declspec(dllexport) void WriteL(RReadStream& aStream,TInt aLength);
  2698. __declspec(dllexport) void WriteL(const TDesC16& aDes);
  2699. __declspec(dllexport) void WriteL(const TDesC16& aDes,TInt aLength);
  2700. __declspec(dllexport) void WriteL(const TUint16* aPtr,TInt aLength);
  2701. __declspec(dllexport) void WriteInt8L(TInt aValue);
  2702. __declspec(dllexport) void WriteInt16L(TInt aValue);
  2703. __declspec(dllexport) void WriteInt32L(TInt32 aValue);
  2704. __declspec(dllexport) void WriteUint8L(TUint aValue);
  2705. __declspec(dllexport) void WriteUint16L(TUint aValue);
  2706. __declspec(dllexport) void WriteUint32L(TUint32 aValue);
  2707. __declspec(dllexport) void WriteReal32L(TReal aValue) ;
  2708. __declspec(dllexport) void WriteReal64L(TReal64 aValue) ;
  2709. protected:
  2710. inline void Attach(MStreamBuf* aSink);
  2711. inline void Detach();
  2712. private:
  2713. __declspec(dllexport) void WriteRefL(TStreamRef aRef);
  2714. private:
  2715. MStreamBuf* iSnk;
  2716. const MExternalizer<TStreamRef> * iExterL;
  2717. private:
  2718. friend class TStreamRef;
  2719. };
  2720. template <class T>
  2721. inline RWriteStream& operator<<(RWriteStream& aStream,const T& anObject);
  2722. template <class T>
  2723. inline RReadStream& operator>>(RReadStream& aStream,T& anObject);
  2724. #line 142
  2725. class TCardinality
  2726. {
  2727. public:
  2728. TCardinality() {}
  2729. inline TCardinality(TInt aCount);
  2730. inline operator TInt() const;
  2731. __declspec(dllexport) void ExternalizeL(RWriteStream& aStream) const;
  2732. __declspec(dllexport) void InternalizeL(RReadStream& aStream);
  2733. private:
  2734. TInt iCount;
  2735. private:
  2736. __declspec(dllexport) static void __DbgChkRange(TInt aCount);
  2737. };
  2738. typedef void (*TExternalizeFunction)(const TAny* aPtr,RWriteStream& aStream);
  2739. typedef void (*TInternalizeFunction)(TAny* aPtr,RReadStream& aStream);
  2740. #line 171
  2741. template <class T>
  2742. class TExternalizer
  2743. {
  2744. public:
  2745. inline void operator()(const T& anObject,RWriteStream& aStream) const;
  2746. inline static TExternalizeFunction Function();
  2747. private:
  2748. static void ExternalizeAsL(const TAny* aPtr,RWriteStream& aStream);
  2749. };
  2750. #line 188
  2751. template<> class TExternalizer<TAny>
  2752. {
  2753. public:
  2754. TExternalizer() {}
  2755. inline TExternalizer(TExternalizeFunction aFunction);
  2756. inline void operator()(const TAny* aPtr,RWriteStream& aStream) const;
  2757. inline TExternalizeFunction Function() const;
  2758. private:
  2759. TExternalizeFunction iFunc;
  2760. };
  2761. template <class T>
  2762. class TInternalizer
  2763. {
  2764. public:
  2765. inline void operator()(T& anObject,RReadStream& aStream) const;
  2766. inline static TInternalizeFunction Function();
  2767. private:
  2768. static void InternalizeAsL(TAny* aPtr,RReadStream& aStream);
  2769. };
  2770. template<> class TInternalizer<TAny>
  2771. {
  2772. public:
  2773. TInternalizer() {}
  2774. inline TInternalizer(TInternalizeFunction aFunction);
  2775. inline void operator()(TAny* aPtr,RReadStream& aStream) const;
  2776. inline TInternalizeFunction Function() const;
  2777. private:
  2778. TInternalizeFunction iFunc;
  2779. };
  2780. #line 258
  2781. template <class T>
  2782. class MExternalizer
  2783. {
  2784. public:
  2785. inline void operator()(const T& anObject,RWriteStream& aStream) const;
  2786. private:
  2787. virtual void ExternalizeL(const T& anObject,RWriteStream& aStream) const=0;
  2788. };
  2789. #line 281
  2790. template <class T>
  2791. class MInternalizer
  2792. {
  2793. public:
  2794. inline void operator()(T& anObject,RReadStream& aStream) const;
  2795. private:
  2796. virtual void InternalizeL(T& anObject,RReadStream& aStream) const=0;
  2797. };
  2798. class TStreamRef
  2799. {
  2800. public:
  2801. inline TStreamRef(const TAny* aPtr,TExternalizeFunction aFunction);
  2802. inline const TAny* Ptr() const;
  2803. inline TExternalizeFunction Function() const;
  2804. inline void ExternalizeL(RWriteStream& aStream) const;
  2805. private:
  2806. const TAny* iPtr;
  2807. TExternalizeFunction iFunc;
  2808. };
  2809. class Externalize
  2810. {
  2811. public:
  2812. class Member {};
  2813. class Function {};
  2814. };
  2815. class Internalize
  2816. {
  2817. public:
  2818. class Member {};
  2819. class Function {};
  2820. };
  2821. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\s32strm.inl" /* stack depth 11 */
  2822. inline RReadStream::RReadStream()
  2823. : iSrc(0 )
  2824. {}
  2825. inline RReadStream::RReadStream(MStreamBuf* aSource)
  2826. : iSrc(aSource)
  2827. {}
  2828. inline MStreamBuf* RReadStream::Source()
  2829. #line 32
  2830. {return iSrc;}
  2831. inline void RReadStream::Close()
  2832. {Release();}
  2833. inline void RReadStream::ReadL(RWriteStream& aStream)
  2834. {aStream.WriteL(*this);}
  2835. inline void RReadStream::ReadL(RWriteStream& aStream,TInt aLength)
  2836. {aStream.WriteL(*this,aLength);}
  2837. inline void RReadStream::Pop()
  2838. {CleanupStack::Pop();}
  2839. inline void RReadStream::Attach(MStreamBuf* aSource)
  2840. #line 66
  2841. {iSrc=aSource;}
  2842. inline void RReadStream::Detach()
  2843. {iSrc=0 ;}
  2844. inline RWriteStream::RWriteStream()
  2845. : iSnk(0 ),iExterL(0 )
  2846. {}
  2847. inline RWriteStream::RWriteStream(const MExternalizer<TStreamRef>& anExter)
  2848. : iSnk(0 ),iExterL(&anExter)
  2849. {}
  2850. inline RWriteStream::RWriteStream(MStreamBuf* aSink)
  2851. : iSnk(aSink),iExterL(0 )
  2852. {}
  2853. inline MStreamBuf* RWriteStream::Sink()
  2854. {return iSnk;}
  2855. inline void RWriteStream::Pop()
  2856. {CleanupStack::Pop();}
  2857. inline void RWriteStream::Attach(MStreamBuf* aSink)
  2858. #line 119
  2859. {iSnk=aSink;}
  2860. inline void RWriteStream::Detach()
  2861. {iSnk=0 ;}
  2862. inline TCardinality::TCardinality(TInt aCount)
  2863. :iCount(aCount)
  2864. {
  2865. __DbgChkRange(aCount);
  2866. }
  2867. inline TCardinality::operator TInt() const
  2868. {
  2869. __DbgChkRange(iCount);
  2870. return iCount;
  2871. }
  2872. template <class T>
  2873. inline void TExternalizer<T>::operator()(const T& anObject,RWriteStream& aStream) const
  2874. {aStream<<anObject;}
  2875. template <class T>
  2876. inline TExternalizeFunction TExternalizer<T>::Function()
  2877. {return &ExternalizeAsL;}
  2878. template <class T>
  2879. void TExternalizer<T>::ExternalizeAsL(const TAny* aPtr,RWriteStream& aStream)
  2880. {aStream<<*((const T*)aPtr);}
  2881. inline TExternalizer<TAny>::TExternalizer(TExternalizeFunction aFunction)
  2882. : iFunc(aFunction)
  2883. {}
  2884. inline void TExternalizer<TAny>::operator()(const TAny* aPtr,RWriteStream& aStream) const
  2885. {(*iFunc)(aPtr,aStream);}
  2886. inline TExternalizeFunction TExternalizer<TAny>::Function() const
  2887. {return iFunc;}
  2888. template <class T>
  2889. inline void TInternalizer<T>::operator()(T& anObject,RReadStream& aStream) const
  2890. {aStream>>anObject;}
  2891. template <class T>
  2892. inline TInternalizeFunction TInternalizer<T>::Function()
  2893. {return &InternalizeAsL;}
  2894. template <class T>
  2895. void TInternalizer<T>::InternalizeAsL(TAny* aPtr,RReadStream& aStream)
  2896. {aStream>> *((T*)aPtr);}
  2897. inline TInternalizer<TAny>::TInternalizer(TInternalizeFunction aFunction)
  2898. : iFunc(aFunction)
  2899. {}
  2900. inline void TInternalizer<TAny>::operator()(TAny* aPtr,RReadStream& aStream) const
  2901. {(*iFunc)(aPtr,aStream);}
  2902. inline TInternalizeFunction TInternalizer<TAny>::Function() const
  2903. {return iFunc;}
  2904. template <class T>
  2905. inline void MExternalizer<T>::operator()(const T& anObject,RWriteStream& aStream) const
  2906. {ExternalizeL(anObject,aStream);}
  2907. template <class T>
  2908. inline void MInternalizer<T>::operator()(T& anObject,RReadStream& aStream) const
  2909. {InternalizeL(anObject,aStream);}
  2910. inline TStreamRef::TStreamRef(const TAny* aPtr,TExternalizeFunction aFunction)
  2911. : iPtr(aPtr),iFunc(aFunction)
  2912. {}
  2913. inline const TAny* TStreamRef::Ptr() const
  2914. {return iPtr;}
  2915. inline TExternalizeFunction TStreamRef::Function() const
  2916. {return iFunc;}
  2917. inline void TStreamRef::ExternalizeL(RWriteStream& aStream) const
  2918. {aStream.WriteRefL(*this);}
  2919. __declspec(dllexport) void ExternalizeL(TInt64 anInt64,RWriteStream& aStream);
  2920. __declspec(dllexport) void InternalizeL(TInt64& anInt64,RReadStream& aStream);
  2921. __declspec(dllexport) void ExternalizeL(const TDesC8& aDes8,RWriteStream& aStream);
  2922. __declspec(dllexport) void ExternalizeL(const TDesC16& aDes16,RWriteStream& aStream);
  2923. __declspec(dllexport) void InternalizeL(TDes8& aDes8,RReadStream& aStream);
  2924. __declspec(dllexport) void InternalizeL(TDes16& aDes16,RReadStream& aStream);
  2925. __declspec(dllexport) void ExternalizeL(const TCheckedUid& aUid,RWriteStream& aStream);
  2926. __declspec(dllexport) void InternalizeL(TCheckedUid& aUid,RReadStream& aStream);
  2927. __declspec(dllexport) void ExternalizeL(TPoint aPoint,RWriteStream& aStream);
  2928. __declspec(dllexport) void ExternalizeL(TSize aSize,RWriteStream& aStream);
  2929. __declspec(dllexport) void ExternalizeL(const TRect& aRect,RWriteStream& aStream);
  2930. __declspec(dllexport) void InternalizeL(TPoint& aPoint,RReadStream& aStream);
  2931. __declspec(dllexport) void InternalizeL(TSize& aSize,RReadStream& aStream);
  2932. __declspec(dllexport) void InternalizeL(TRect& aRect,RReadStream& aStream);
  2933. __declspec(dllexport) void ExternalizeL(const CBufBase& aBuf,RWriteStream& aStream);
  2934. __declspec(dllexport) void InternalizeL(CBufBase& aBuf,RReadStream& aStream);
  2935. __declspec(dllexport) void ArrayExternalizeCountL(TInt aCount,RWriteStream& aStream);
  2936. __declspec(dllexport) void DoExternalizeAllL(const CArrayFixBase& anArray,RWriteStream& aStream,TExternalizer<TAny> anExter);
  2937. __declspec(dllexport) TInt ArrayInternalizeCountL(RReadStream& aStream);
  2938. __declspec(dllexport) void DoInternalizeAllL(CArrayFixBase& anArray,RReadStream& aStream,TInternalizer<TAny> anInter);
  2939. template <class T>
  2940. inline void ExternalizeCountL(const CArrayFix<T>& anArray,RWriteStream& aStream)
  2941. {ArrayExternalizeCountL(anArray.Count(),aStream);}
  2942. template <class T>
  2943. inline void ExternalizeAllL(const CArrayFix<T>& anArray,RWriteStream& aStream)
  2944. {DoExternalizeAllL(anArray,aStream,TExternalizer<T>::Function());}
  2945. template <class T>
  2946. void InternalizeCountL(CArrayFix<T>& anArray,RReadStream& aStream)
  2947. {
  2948. TInt n=ArrayInternalizeCountL(aStream);
  2949. anArray.ResizeL(n);
  2950. }
  2951. template <class T>
  2952. inline void InternalizeAllL(CArrayFix<T>& anArray,RReadStream& aStream)
  2953. {DoInternalizeAllL(anArray,aStream,TInternalizer<T>::Function());}
  2954. template <class T>
  2955. void ExternalizeL(const CArrayFix<T>& anArray,RWriteStream& aStream)
  2956. {
  2957. ExternalizeCountL(anArray,aStream);
  2958. ExternalizeAllL(anArray,aStream);
  2959. }
  2960. template <class T>
  2961. void InternalizeL(CArrayFix<T>& anArray,RReadStream& aStream)
  2962. {
  2963. InternalizeCountL(anArray,aStream);
  2964. InternalizeAllL(anArray,aStream);
  2965. }
  2966. template <class T>
  2967. inline void ExternalizeL(const T* aPtr,RWriteStream& aStream)
  2968. {aStream<<TStreamRef(aPtr,TExternalizer<T>::Function());}
  2969. template <class T>
  2970. inline void DoExternalizeL(const T& anObject,RWriteStream& aStream,Externalize::Member)
  2971. {anObject.ExternalizeL(aStream);}
  2972. template <class T>
  2973. inline void DoInternalizeL(T& anObject,RReadStream& aStream,Internalize::Member)
  2974. {anObject.InternalizeL(aStream);}
  2975. template <class T>
  2976. inline void DoExternalizeL(const T& anObject,RWriteStream& aStream,Externalize::Function)
  2977. {ExternalizeL(anObject,aStream);}
  2978. template <class T>
  2979. inline void DoInternalizeL(T& anObject,RReadStream& aStream,Internalize::Function)
  2980. {InternalizeL(anObject,aStream);}
  2981. inline Externalize::Member Externalization(const TAny*)
  2982. {return Externalize::Member();}
  2983. inline Internalize::Member Internalization(TAny*)
  2984. {return Internalize::Member();}
  2985. inline Externalize::Function Externalization(const TDesC8*)
  2986. {return Externalize::Function();}
  2987. inline Externalize::Function Externalization(const TDesC16*)
  2988. {return Externalize::Function();}
  2989. inline Internalize::Function Internalization(TDes8*)
  2990. {return Internalize::Function();}
  2991. inline Internalize::Function Internalization(TDes16*)
  2992. {return Internalize::Function();}
  2993. inline Externalize::Function Externalization(const CBufBase*)
  2994. {return Externalize::Function();}
  2995. inline Externalize::Function Externalization(const CArrayFixBase*)
  2996. {return Externalize::Function();}
  2997. inline Internalize::Function Internalization(CBufBase*)
  2998. {return Internalize::Function();}
  2999. inline Internalize::Function Internalization(CArrayFixBase*)
  3000. {return Internalize::Function();}
  3001. template <class T>
  3002. inline Externalize::Function Externalization(T*const*)
  3003. {return Externalize::Function();}
  3004. template <class T>
  3005. inline RWriteStream& operator<<(RWriteStream& aStream,const T& anObject)
  3006. {DoExternalizeL(anObject,aStream,Externalization(&anObject));return aStream;}
  3007. template <class T>
  3008. inline RReadStream& operator>>(RReadStream& aStream,T& anObject)
  3009. {DoInternalizeL(anObject,aStream,Internalization(&anObject));return aStream;}
  3010. inline RWriteStream& operator<<(RWriteStream& aStream,const TInt8& anInt8)
  3011. {aStream.WriteInt8L(anInt8);return aStream;}
  3012. inline RWriteStream& operator<<(RWriteStream& aStream,const TInt16& anInt16)
  3013. {aStream.WriteInt16L(anInt16);return aStream;}
  3014. inline RWriteStream& operator<<(RWriteStream& aStream,const TInt32& anInt32)
  3015. {aStream.WriteInt32L(anInt32);return aStream;}
  3016. inline RWriteStream& operator<<(RWriteStream& aStream,const TUint8& aUint8)
  3017. {aStream.WriteUint8L(aUint8);return aStream;}
  3018. inline RWriteStream& operator<<(RWriteStream& aStream,const TUint16& aUint16)
  3019. {aStream.WriteUint16L(aUint16);return aStream;}
  3020. inline RWriteStream& operator<<(RWriteStream& aStream,const TUint32& aUint32)
  3021. {aStream.WriteUint32L(aUint32);return aStream;}
  3022. inline RWriteStream& operator<<(RWriteStream& aStream,const TReal32& aReal32)
  3023. {aStream.WriteReal32L(aReal32);return aStream;}
  3024. inline RWriteStream& operator<<(RWriteStream& aStream,const TReal64& aReal64)
  3025. {aStream.WriteReal64L(aReal64);return aStream;}
  3026. inline RReadStream& operator>>(RReadStream& aStream,TInt8& anInt8)
  3027. {anInt8=aStream.ReadInt8L();return aStream;}
  3028. inline RReadStream& operator>>(RReadStream& aStream,TInt16& anInt16)
  3029. {anInt16=aStream.ReadInt16L();return aStream;}
  3030. inline RReadStream& operator>>(RReadStream& aStream,TInt32& anInt32)
  3031. {anInt32=aStream.ReadInt32L();return aStream;}
  3032. inline RReadStream& operator>>(RReadStream& aStream,TUint8& aUint8)
  3033. {aUint8=aStream.ReadUint8L();return aStream;}
  3034. inline RReadStream& operator>>(RReadStream& aStream,TUint16& aUint16)
  3035. {aUint16=aStream.ReadUint16L();return aStream;}
  3036. inline RReadStream& operator>>(RReadStream& aStream,TUint32& aUint32)
  3037. {aUint32=aStream.ReadUint32L();return aStream;}
  3038. inline RReadStream& operator>>(RReadStream& aStream,TReal32& aReal32)
  3039. {aReal32=aStream.ReadReal32L();return aStream;}
  3040. inline RReadStream& operator>>(RReadStream& aStream,TReal64& aReal64)
  3041. {aReal64=aStream.ReadReal64L();return aStream;}
  3042. inline RWriteStream& operator<<(RWriteStream& aStream,const TInt64& anInt64)
  3043. {ExternalizeL(anInt64,aStream);return aStream;}
  3044. inline RReadStream& operator>>(RReadStream& aStream,TInt64& anInt64)
  3045. {InternalizeL(anInt64,aStream);return aStream;}
  3046. inline RWriteStream& operator<<(RWriteStream& aStream,const TUid& aUid)
  3047. {return aStream<<aUid.iUid;}
  3048. inline RWriteStream& operator<<(RWriteStream& aStream,const TCheckedUid& aUid)
  3049. {ExternalizeL(aUid,aStream);return aStream;}
  3050. inline RReadStream& operator>>(RReadStream& aStream,TUid& aUid)
  3051. {return aStream>>aUid.iUid;}
  3052. inline RReadStream& operator>>(RReadStream& aStream,TCheckedUid& aUid)
  3053. {InternalizeL(aUid,aStream);return aStream;}
  3054. inline RWriteStream& operator<<(RWriteStream& aStream,const TPoint& aPoint)
  3055. {ExternalizeL(aPoint,aStream);return aStream;}
  3056. inline RWriteStream& operator<<(RWriteStream& aStream,const TSize& aSize)
  3057. {ExternalizeL(aSize,aStream);return aStream;}
  3058. inline RWriteStream& operator<<(RWriteStream& aStream,const TRect& aRect)
  3059. {ExternalizeL(aRect,aStream);return aStream;}
  3060. inline RReadStream& operator>>(RReadStream& aStream,TPoint& aPoint)
  3061. {InternalizeL(aPoint,aStream);return aStream;}
  3062. inline RReadStream& operator>>(RReadStream& aStream,TSize& aSize)
  3063. {InternalizeL(aSize,aStream);return aStream;}
  3064. inline RReadStream& operator>>(RReadStream& aStream,TRect& aRect)
  3065. {InternalizeL(aRect,aStream);return aStream;}
  3066. inline RWriteStream& operator<<(RWriteStream& aStream,const TStreamRef& aRef)
  3067. {aRef.ExternalizeL(aStream);return aStream;}
  3068. #line 351 "C:\Symbian\9.1\S60_3rd\epoc32\include\s32strm.h" /* stack depth 10 */
  3069. #line 8 "C:\Symbian\9.1\S60_3rd\epoc32\include\s32std.h" /* stack depth 9 */
  3070. const TUint32 KNullStreamIdValue=0;
  3071. const TUint32 KMaxStreamIdValue=0xfffffff;
  3072. const TUint32 KMaskStreamIdValue=0xfffffff;
  3073. const TInt KShiftStreamIdValue=28;
  3074. #line 28
  3075. class TStreamId
  3076. {
  3077. public:
  3078. TStreamId() {}
  3079. inline TStreamId(TUint32 aValue);
  3080. inline TBool operator==(TStreamId anId) const;
  3081. inline TBool operator!=(TStreamId anId) const;
  3082. inline void ExternalizeL(RWriteStream& aStream) const;
  3083. __declspec(dllexport) void InternalizeL(RReadStream& aStream);
  3084. inline TUint32 Value() const;
  3085. private:
  3086. TUint32 iVal;
  3087. private:
  3088. __declspec(dllexport) static void __DbgChkRange(TUint32 aValue);
  3089. };
  3090. class CStreamStore;
  3091. class RStoreReadStream : public RReadStream
  3092. {
  3093. public:
  3094. __declspec(dllexport) void OpenL(const CStreamStore& aStore,TStreamId anId);
  3095. __declspec(dllexport) void OpenLC(const CStreamStore& aStore,TStreamId anId);
  3096. };
  3097. #line 84
  3098. class RStoreWriteStream : public RWriteStream
  3099. {
  3100. public:
  3101. RStoreWriteStream() {}
  3102. inline RStoreWriteStream(const MExternalizer<TStreamRef>& anExter);
  3103. __declspec(dllexport) TStreamId CreateL(CStreamStore& aStore);
  3104. __declspec(dllexport) TStreamId CreateLC(CStreamStore& aStore);
  3105. __declspec(dllexport) void OpenL(CStreamStore& aStore,TStreamId anId);
  3106. __declspec(dllexport) void OpenLC(CStreamStore& aStore,TStreamId anId);
  3107. __declspec(dllexport) void ReplaceL(CStreamStore& aStore,TStreamId anId);
  3108. __declspec(dllexport) void ReplaceLC(CStreamStore& aStore,TStreamId anId);
  3109. __declspec(dllexport) void AppendL(CStreamStore& aStore,TStreamId anId);
  3110. __declspec(dllexport) void AppendLC(CStreamStore& aStore,TStreamId anId);
  3111. };
  3112. #line 115
  3113. class TSwizzleCBase
  3114. {
  3115. public:
  3116. inline TBool operator==(const TSwizzleCBase& aSwizzle) const;
  3117. inline TBool operator==(const TAny* aPtr) const;
  3118. inline TBool operator!=(const TSwizzleCBase& aSwizzle) const;
  3119. inline TBool operator!=(const TAny* aPtr) const;
  3120. inline TBool IsPtr() const;
  3121. inline TBool IsId() const;
  3122. __declspec(dllexport) TStreamId AsId() const;
  3123. __declspec(dllexport) void InternalizeL(RReadStream& aStream);
  3124. protected:
  3125. TSwizzleCBase() {}
  3126. inline TSwizzleCBase(const TAny* aPtr);
  3127. __declspec(dllexport) TSwizzleCBase(TStreamId anId);
  3128. inline TSwizzleCBase(TStreamRef aRef);
  3129. inline const TAny* Ptr() const;
  3130. __declspec(dllexport) void DoExternalizeL(RWriteStream& aStream,TExternalizer<TAny> anExter) const;
  3131. private:
  3132. __declspec(dllexport) static TBool IsPtrRep(const TAny* aPtr);
  3133. __declspec(dllexport) static TBool IsIdRep(const TAny* aPtr);
  3134. private:
  3135. const TAny* iPtr;
  3136. private:
  3137. __declspec(dllexport) static void __DbgChkPtr(const TAny* aPtr);
  3138. __declspec(dllexport) static void __DbgChkRef(TStreamRef aRef);
  3139. };
  3140. inline TBool operator==(const TAny* aPtr,const TSwizzleCBase& aSwizzle);
  3141. inline TBool operator!=(const TAny* aPtr,const TSwizzleCBase& aSwizzle);
  3142. #line 158
  3143. class TSwizzleBase : public TSwizzleCBase
  3144. {
  3145. protected:
  3146. TSwizzleBase() {}
  3147. inline TSwizzleBase(TAny* aPtr);
  3148. inline TSwizzleBase(TStreamId anId);
  3149. inline TAny* Ptr() const;
  3150. };
  3151. #line 184
  3152. template <class T>
  3153. class TSwizzle : public TSwizzleBase
  3154. {
  3155. public:
  3156. TSwizzle() {}
  3157. inline TSwizzle(T* aPtr);
  3158. inline TSwizzle(TStreamId anId);
  3159. inline TSwizzle<T>& operator=(T* aPtr);
  3160. inline T* AsPtr() const;
  3161. inline operator T*() const;
  3162. inline T& operator*() const;
  3163. inline T* operator->() const;
  3164. inline void ExternalizeL(RWriteStream& aStream) const;
  3165. };
  3166. #line 208
  3167. template<> class TSwizzle<TAny> : public TSwizzleBase
  3168. {
  3169. public:
  3170. TSwizzle() {}
  3171. inline TSwizzle(TAny* aPtr);
  3172. inline TSwizzle(TStreamId anId);
  3173. inline TSwizzle(const TSwizzleBase& aSwizzle);
  3174. inline TSwizzle<TAny>& operator=(TAny* aPtr);
  3175. inline TSwizzle<TAny>& operator=(const TSwizzleBase& aSwizzle);
  3176. inline TAny* AsPtr() const;
  3177. inline operator TAny*() const;
  3178. };
  3179. #line 242
  3180. template <class T>
  3181. class TSwizzleC : public TSwizzleCBase
  3182. {
  3183. public:
  3184. TSwizzleC() {}
  3185. inline TSwizzleC(const T* aPtr);
  3186. inline TSwizzleC(TStreamId anId);
  3187. inline TSwizzleC(TSwizzle<T> aSwizzle);
  3188. inline TSwizzleC<T>& operator=(const T* aPtr);
  3189. inline const T* AsPtr() const;
  3190. inline operator const T*() const;
  3191. inline const T& operator*() const;
  3192. inline const T* operator->() const;
  3193. inline void ExternalizeL(RWriteStream& aStream) const;
  3194. };
  3195. template<> class TSwizzleC<TAny> : public TSwizzleCBase
  3196. {
  3197. public:
  3198. TSwizzleC() {}
  3199. inline TSwizzleC(const TAny* aPtr);
  3200. inline TSwizzleC(TStreamId anId);
  3201. inline TSwizzleC(const TSwizzleCBase& aSwizzle);
  3202. inline TSwizzleC(TStreamRef aRef);
  3203. inline TSwizzleC<TAny>& operator=(const TAny* aPtr);
  3204. inline TSwizzleC<TAny>& operator=(const TSwizzleCBase& aSwizzle);
  3205. inline const TAny* AsPtr() const;
  3206. inline operator const TAny*() const;
  3207. };
  3208. #line 296
  3209. class CStoreMap : public CBase,public MExternalizer<TStreamRef>
  3210. {
  3211. public:
  3212. struct TEntry {TSwizzleC<TAny> swizzle;TStreamId id;};
  3213. typedef const TEntry* TIterator;
  3214. public:
  3215. __declspec(dllexport) static CStoreMap* NewL(CStreamStore& aStore);
  3216. __declspec(dllexport) static CStoreMap* NewLC(CStreamStore& aStore);
  3217. __declspec(dllexport) CStoreMap(CStreamStore& aStore);
  3218. __declspec(dllexport) ~CStoreMap();
  3219. __declspec(dllexport) void BindL(TSwizzleC<TAny> aSwizzle,TStreamId anId);
  3220. __declspec(dllexport) void Unbind(TSwizzleC<TAny> aSwizzle);
  3221. __declspec(dllexport) void Forget(TStreamId anId);
  3222. __declspec(dllexport) void Reset();
  3223. __declspec(dllexport) void ResetAndDestroy();
  3224. __declspec(dllexport) TStreamId At(TSwizzleC<TAny> aSwizzle) const;
  3225. __declspec(dllexport) TSwizzleC<TAny> Label(TStreamId anId) const;
  3226. __declspec(dllexport) TIterator Begin() const;
  3227. __declspec(dllexport) TIterator End() const;
  3228. private:
  3229. void ExternalizeL(const TStreamRef& aRef,RWriteStream& aStream) const;
  3230. private:
  3231. CArrayFixFlat<TEntry> iArray;
  3232. TStreamId iFree;
  3233. CStreamStore* iStore;
  3234. };
  3235. #line 343
  3236. class CStreamDictionary : public CBase
  3237. {
  3238. public:
  3239. __declspec(dllexport) static CStreamDictionary* NewL();
  3240. __declspec(dllexport) static CStreamDictionary* NewLC();
  3241. __declspec(dllexport) CStreamDictionary();
  3242. __declspec(dllexport) ~CStreamDictionary();
  3243. __declspec(dllexport) void AssignL(TUid aUid,TStreamId anId);
  3244. __declspec(dllexport) void Remove(TUid aUid);
  3245. __declspec(dllexport) TStreamId At(TUid aUid) const;
  3246. __declspec(dllexport) TBool IsNull() const;
  3247. __declspec(dllexport) void ExternalizeL(RWriteStream& aStream) const;
  3248. __declspec(dllexport) void InternalizeL(RReadStream& aStream);
  3249. private:
  3250. class TEntry
  3251. {
  3252. public:
  3253. TEntry() {}
  3254. inline TEntry(TUid aUid,TStreamId anId);
  3255. void ExternalizeL(RWriteStream& aStream) const;
  3256. void InternalizeL(RReadStream& aStream);
  3257. public:
  3258. TUid iUid;
  3259. TStreamId iId;
  3260. };
  3261. private:
  3262. CArrayFixSeg<TEntry> iArray;
  3263. };
  3264. #line 1 "C:\Symbian\9.1\S60_3rd\epoc32\include\s32std.inl" /* stack depth 10 */
  3265. inline TStreamId::TStreamId(TUint32 aValue)
  3266. : iVal(aValue)
  3267. #line 22
  3268. {
  3269. __DbgChkRange(aValue);
  3270. }
  3271. inline TBool TStreamId::operator==(TStreamId anId) const
  3272. {return iVal==anId.iVal;}
  3273. inline TBool TStreamId::operator!=(TStreamId anId) const
  3274. {return iVal!=anId.iVal;}
  3275. inline void TStreamId::ExternalizeL(RWriteStream& aStream) const
  3276. {
  3277. __DbgChkRange(iVal);
  3278. aStream<<iVal;
  3279. }
  3280. inline TUint32 TStreamId::Value() const
  3281. {
  3282. __DbgChkRange(iVal);
  3283. return iVal;
  3284. }
  3285. inline RStoreWriteStream::RStoreWriteStream(const MExternalizer<TStreamRef>& anExter)
  3286. : RWriteStream(anExter)
  3287. {}
  3288. inline TSwizzleCBase::TSwizzleCBase(TStreamRef aRef)
  3289. : iPtr(aRef.Ptr())
  3290. {
  3291. __DbgChkRef(aRef);
  3292.     }
  3293. inline TBool TSwizzleCBase::operator==(const TSwizzleCBase& aSwizzle) const
  3294. #line 97
  3295. {return iPtr==aSwizzle.iPtr;}
  3296. inline TBool TSwizzleCBase::operator==(const TAny* aPtr) const
  3297. #line 110
  3298. {return iPtr==aPtr;}
  3299. inline TBool TSwizzleCBase::operator!=(const TSwizzleCBase& aSwizzle) const
  3300. #line 126
  3301. {return iPtr!=aSwizzle.iPtr;}
  3302. inline TBool TSwizzleCBase::operator!=(const TAny* aPtr) const
  3303. #line 139
  3304. {return iPtr!=aPtr;}
  3305. inline TBool TSwizzleCBase::IsPtr() const
  3306. {return IsPtrRep(iPtr);}
  3307. inline TBool TSwizzleCBase::IsId() const
  3308. {return IsIdRep(iPtr);}
  3309. inline TSwizzleCBase::TSwizzleCBase(const TAny* aPtr)
  3310. : iPtr(aPtr)
  3311. {
  3312. __DbgChkPtr(aPtr);
  3313.     }
  3314. inline const TAny* TSwizzleCBase::Ptr() const
  3315. {
  3316. __DbgChkPtr(iPtr);
  3317. return iPtr;
  3318. }
  3319. inline TBool operator==(const TAny* aPtr,const TSwizzleCBase& aSwizzle)
  3320. {return aSwizzle==aPtr;}
  3321. inline TBool operator!=(const TAny* aPtr,const TSwizzleCBase& aSwizzle)
  3322. {return aSwizzle!=aPtr;}
  3323. inline TSwizzleBase::TSwizzleBase(TAny* aPtr)
  3324. : TSwizzleCBase(aPtr)
  3325. {}
  3326. inline TSwizzleBase::TSwizzleBase(TStreamId anId)
  3327. : TSwizzleCBase(anId)
  3328. {}
  3329. inline TAny* TSwizzleBase::Ptr() const
  3330. {return (TAny*)TSwizzleCBase::Ptr();}
  3331. template <class T>
  3332. inline TSwizzle<T>::TSwizzle(T* aPtr)
  3333. : TSwizzleBase(aPtr)
  3334. {}
  3335. template <class T>
  3336. inline TSwizzle<T>::TSwizzle(TStreamId anId)
  3337. : TSwizzleBase(anId)
  3338. {}
  3339. template <class T>
  3340. inline TSwizzle<T>& TSwizzle<T>::operator=(T* aPtr)
  3341. {return *this=TSwizzle<T>(aPtr);}
  3342. template <class T>
  3343. inline T* TSwizzle<T>::AsPtr() const
  3344. {return (T*)Ptr();}
  3345. template <class T>
  3346. inline TSwizzle<T>::operator T*() const
  3347. {return AsPtr();}
  3348. template <class T>
  3349. inline T& TSwizzle<T>::operator*() const
  3350. {return *AsPtr();}
  3351. template <class T>
  3352. inline T* TSwizzle<T>::operator->() const
  3353. {return AsPtr();}
  3354. template <class T>
  3355. inline void TSwizzle<T>::ExternalizeL(RWriteStream& aStream) const
  3356. #line 252
  3357. {TSwizzleBase::DoExternalizeL(aStream,TExternalizer<T>::Function());}
  3358. inline TSwizzle<TAny>::TSwizzle(TAny* aPtr)
  3359. : TSwizzleBase(aPtr)
  3360. {}
  3361. inline TSwizzle<TAny>::TSwizzle(TStreamId anId)
  3362. : TSwizzleBase(anId)
  3363. {}
  3364. inline TSwizzle<TAny>::TSwizzle(const TSwizzleBase& aSwizzle)
  3365. : TSwizzleBase(aSwizzle)
  3366. {}
  3367. inline TSwizzle<TAny>& TSwizzle<TAny>::operator=(TAny* aPtr)
  3368. {return *this=TSwizzle<TAny>(aPtr);}
  3369. inline TSwizzle<TAny>& TSwizzle<TAny>::operator=(const TSwizzleBase& aSwizzle)
  3370. {return *this=TSwizzle<TAny>(aSwizzle);}
  3371. inline TAny* TSwizzle<TAny>::AsPtr() const
  3372. {return Ptr();}
  3373. inline TSwizzle<TAny>::operator TAny*() const
  3374. {return AsPtr();}
  3375. template <class T>
  3376. inline TSwizzleC<T>::TSwizzleC(const T* aPtr)
  3377. : TSwizzleCBase(aPtr)
  3378. {}
  3379. template <class T>
  3380. inline TSwizzleC<T>::TSwizzleC(TStreamId anId)
  3381. : TSwizzleCBase(anId)
  3382. {}
  3383. template <class T>
  3384. inline TSwizzleC<T>::TSwizzleC(TSwizzle<T> aSwizzle)
  3385. : TSwizzleCBase(aSwizzle)
  3386. #line 328
  3387. {}
  3388. template <class T>
  3389. inline TSwizzleC<T>& TSwizzleC<T>::operator=(const T* aPtr)
  3390. {return *this=TSwizzleC<T>(aPtr);}
  3391. template <class T>
  3392. inline const T* TSwizzleC<T>::AsPtr() const
  3393. #line 350
  3394. {return (const T*)Ptr();}
  3395. template <class T>
  3396. inline TSwizzleC<T>::operator const T*() const
  3397. {return AsPtr();}
  3398. template <class T>
  3399. inline const T& TSwizzleC<T>::operator*() const
  3400. {return *AsPtr();}
  3401. template <class T>
  3402. inline const T* TSwizzleC<T>::operator->() const
  3403. #line 373
  3404. {return AsPtr();}
  3405. template <class T>
  3406. inline void TSwizzleC<T>::ExternalizeL(RWriteStream& aStream) const
  3407. #line 393
  3408. {TSwizzleCBase::DoExternalizeL(aStream,TExternalizer<T>::Function());}
  3409. inline TSwizzleC<TAny>::TSwizzleC(const TAny* aPtr)
  3410. : TSwizzleCBase(aPtr)
  3411. {}
  3412. inline TSwizzleC<TAny>::TSwizzleC(TStreamId anId)
  3413. : TSwizzleCBase(anId)
  3414. {}
  3415. inline TSwizzleC<TAny>::TSwizzleC(const TSwizzleCBase& aSwizzle)
  3416. : TSwizzleCBase(aSwizzle)
  3417. {}
  3418. inline TSwizzleC<TAny>::TSwizzleC(TStreamRef aRef)
  3419. : TSwizzleCBase(aRef)
  3420.   {}
  3421. inline TSwizzleC<TAny>& TSwizzleC<TAny>::operator=(const TAny* aPtr)
  3422. {return *this=TSwizzleC<TAny>(aPtr);}
  3423. inline TSwizzleC<TAny>& TSwizzleC<TAny>::operator=(const TSwizzleCBase& aSwizzle)
  3424. {return *this=TSwizzleC<TAny>(aSwizzle);}
  3425. inline const TAny* TSwizzleC<TAny>::AsPtr() const
  3426. {return Ptr();}
  3427. inline TSwizzleC<TAny>::operator const TAny*() const
  3428. {return AsPtr();}
  3429. #line 375 "C:\Symbian\9.1\S60_3rd\epoc32\include\s32std.h" /* stack depth 9 */
  3430. #line 21 "C:\Symbian\9.1\S60_3rd\epoc32\include\gdi.h" /* stack depth 8 */
  3431. const TInt KDefaultScreenNo = 0;
  3432. class TOpenFontCharMetrics;
  3433. const TInt KTwipsPerInch=1440;
  3434. const TInt KTwipsPerPoint=20;
  3435. const TInt KPointsPerInch=72;
  3436. const TInt KTwipsPerCm=567;
  3437. #line 131
  3438. enum TGdiPanic
  3439. {
  3440. EGdiPanic_Unknown = 0,
  3441. EGdiPanic_InvalidInputParam = 1,
  3442. EGdiPanic_OutOfText = 2,
  3443. EGdiPanic_Invariant = 3
  3444. };
  3445. #line 178
  3446. class TRgb
  3447. {
  3448. public:
  3449. inline TRgb();
  3450. inline TRgb(TUint32 aValue);
  3451. inline TRgb(TUint32 aInternalValue, TInt aAlpha);
  3452. inline TRgb(TInt aRed,TInt aGreen,TInt aBlue);
  3453. inline TRgb(TInt aRed, TInt aGreen, TInt aBlue, TInt aAlpha);
  3454. inline TInt Red() const;
  3455. inline TInt Green() const;
  3456. inline TInt Blue() const;
  3457. inline TInt Alpha() const;
  3458. __declspec(dllexport) void SetRed(TInt aRed);
  3459. __declspec(dllexport) void SetGreen(TInt aGreen);
  3460. __declspec(dllexport) void SetBlue(TInt aBlue);
  3461. __declspec(dllexport) void SetAlpha(TInt aAlpha);
  3462. __declspec(dllexport) static TRgb Gray2(TInt aGray2);
  3463. __declspec(dllexport) static TRgb Gray4(TInt aGray4);
  3464. __declspec(dllexport) static TRgb Gray16(TInt aGray16);
  3465. __declspec(dllexport) static TRgb Gray256(TInt aGray256);
  3466. __declspec(dllexport) static TRgb Color16(TInt aColor16);
  3467. __declspec(dllexport) static TRgb Color256(TInt aColor256);
  3468. __declspec(dllexport) static TRgb Color4K(TInt aColor4K);
  3469. __declspec(dllexport) static TRgb Color64K(TInt aColor64K);
  3470. __declspec(dllexport) static TRgb Color16M(TInt aColor16M);
  3471. __declspec(dllexport) TInt Gray2() const;
  3472. __declspec(dllexport) TInt Gray4() const;
  3473. __declspec(dllexport) TInt Gray16() const;
  3474. __declspec(dllexport) TInt Gray256() const;
  3475. __declspec(dllexport) TInt Color16() const;
  3476. __declspec(dllexport) TInt Color256() const;
  3477. __declspec(dllexport) TInt Color4K() const;
  3478. __declspec(dllexport) TInt Color64K() const;
  3479. __declspec(dllexport) TInt Color16M() const;
  3480. inline TBool operator==(const TRgb& aColor) const;
  3481. inline TBool operator!=(const TRgb& aColor) const;
  3482. inline TRgb operator~() const;
  3483. inline TRgb operator&(const TRgb& aColor);
  3484. inline TRgb operator|(const TRgb& aColor);
  3485. inline TRgb operator^(const TRgb& aColor);
  3486. inline TRgb& operator&=(const TRgb& aColor);