My Project
fx_process.h
Go to the documentation of this file.
1 
20 #ifndef _FX_PROCESS_H_
21 #define _FX_PROCESS_H_
22 
23 #ifndef _FX_BASIC_H_
24  #include "fx_basic.h"
25 #endif
26 
27 #if _FX_OS_ == _FX_LINUX_DESKTOP_ || _FX_OS_ == _FX_LINUX_EMBEDDED_ || _FX_OS_ == _FX_ANDROID_ || _FX_OS_ == _FX_MACOSX_ || _FX_OS_ == _FX_IOS_
28  #include <time.h>
29  #include <sys/time.h>
30  #include <pthread.h>
31  #include <unistd.h>
32 #endif
33 
34 //external classes
35 class CFX_ProcessContext;
36 class CFX_ThreadContext;
37 class CFX_ExceptionContext;
38 
39 //*****************************************************************************
40 //* Time
41 //*****************************************************************************
42 #ifdef __cplusplus
43 extern "C" {
44 #endif
45 
50 
52 typedef struct _FX_SYSTEMTIME
53 {
54  FX_WORD wYear; //Year
55  FX_WORD wMonth; //Month, 1 - 12
56  FX_WORD wDayOfWeek; //Day of week, Sunday is 0, Monday is 1, ...
57  FX_WORD wDay; //Day of month, start from 1 - 31
58  FX_WORD wHour; //Hour, 0 - 23
59  FX_WORD wMinute; //Minute, 0 - 59
60  FX_WORD wSecond; //Second, 0 - 59
61  FX_WORD wMilliseconds; //Millisecond, 0 - 999
63 
71 void FX_Time_GetSystemTime(FX_SYSTEMTIME* pSystemTime);void FX_Time_GetLocalTime(FX_SYSTEMTIME* pSystemTime);
92 FX_DWORD FX_Time_Sleep(FX_DWORD dwMilliseconds);
93 
95 typedef struct _FXCRT_DATETIMEZONE
96 {
118  FX_INT32 tzHour;//TESTDOC: BUG#CORE-2923
122 
123 void FXCRT_GetCurrentSystemTime(FXCRT_DATETIMEZONE& dt);
124 
127 #ifdef __cplusplus
128 }
129 #endif
130 
131 //*****************************************************************************
132 //* Process
133 //*****************************************************************************
134 #ifdef __cplusplus
135 extern "C" {
136 #endif
137 
142 
143 #if _FX_OS_ == _FX_LINUX_DESKTOP_ || _FX_OS_ == _FX_MACOSX_ || _FX_OS_ == _FX_IOS_
144  typedef pid_t FX_PROCESSID;
145 #else
146  typedef FX_DWORD FX_PROCESSID;
147 #endif
148 
155 
164 void FX_Process_Initialize();
172 void FX_Process_Finalize();
178 FX_PROCESSID FX_Process_GetID();
179 
207 
215 CFX_ProcessContext* FX_Process_GetContext();
216 
219 #ifdef __cplusplus
220 }
221 #endif
222 
223 //*****************************************************************************
224 //* Thread
225 //*****************************************************************************
226 #ifdef __cplusplus
227 extern "C" {
228 #endif
229 
234 
236 FX_DEFINEHANDLE(FX_HTHREAD);
237 
238 /*
239 #if _FX_OS_ == _FX_LINUX_DESKTOP_ || _FX_OS_ == _FX_MACOSX_ || _FX_OS_ == _FX_IOS_
240  typedef pthread_t FX_THREADID;
241 #else
242  typedef FX_DWORD FX_THREADID;
243 #endif
244 */
245 
252 
254 #define FX_THREADPRIORITY_Lowest -2
255 
256 #define FX_THREADPRIORITY_Lower -1
257 
258 #define FX_THREADPRIORITY_Normal 0
259 
260 #define FX_THREADPRIORITY_Higher 1
261 
262 #define FX_THREADPRIORITY_Highest 2
263 
270 
271 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
272 typedef DWORD FX_ThreadResult;
273 # define THREAD_CALL_CONVENTION WINAPI
274 #else
275 typedef FX_LPVOID FX_ThreadResult;
276 # define THREAD_CALL_CONVENTION
277 #endif
278 
286 typedef FX_ThreadResult (THREAD_CALL_CONVENTION *FX_CALLBACK_ThreadProc)(FX_LPVOID param);
287 
297 typedef FX_ThreadResult (THREAD_CALL_CONVENTION *FX_CALLBACK_ThreadProxyProc)(FX_CALLBACK_ThreadProc threadProc, FX_LPVOID param);
298 
305 
311 typedef struct _FX_THREADHANDLER
312 {
315 
327  FX_HTHREAD (*CreateThread)(FX_LPVOID pUserData, FX_INT32 nPriority, size_t szStack, FX_CALLBACK_ThreadProc lpfThreadProc, FX_LPVOID param);
335  FX_BOOL (*ExitThread)(FX_LPVOID pUserData);
343  FX_HTHREAD (*GetCurrentThread)(FX_LPVOID pUserData);
354  void (*Yield)(FX_LPVOID pUserData);
363  FX_INT32 (*GetThreadPriority)(FX_LPVOID pUserData, FX_HTHREAD hThread);
373  void (*SetThreadPriority)(FX_LPVOID pUserData, FX_HTHREAD hThread, FX_INT32 nPriority);
382  FX_INT32 (*WaitForSingleThread)(FX_LPVOID pUserData, FX_HTHREAD hThread);
392  FX_INT32 (*WaitForMultipleThreads)(FX_LPVOID pUserData, const FX_HTHREAD* pThreads, FX_INT32 nCount);
394 
412 void FX_Thread_SetHandler(FX_THREADHANDLER* pThreadHandler);
413 
420 
431 FX_HTHREAD FX_Thread_Create(FX_INT32 nPriority, size_t szStack, FX_CALLBACK_ThreadProc threadProc, FX_LPVOID param);
432 
438 void FX_Thread_Exit();
439 
445 FX_HTHREAD FX_Thread_GetHandle();
446 
452 void FX_Thread_Yield();
453 
468 
496 
504 FX_INT32 FX_Thread_GetPriority(FX_HTHREAD hThread);
513 void FX_Thread_SetPriority(FX_HTHREAD hThread, FX_INT32 nPriority);
514 
522 FX_INT32 FX_Thread_WaitForSingleThread(FX_HTHREAD hThread);
531 FX_INT32 FX_Thread_WaitForMultipleThreads(const FX_HTHREAD* pThreads, FX_INT32 nCount);
532 
539 
545 CFX_ThreadContext* FX_Thread_GetContext();
546 
552 CFX_ExceptionContext* FX_Thread_GetExceptionContext();
553 
556 #ifdef __cplusplus
557 }
558 #endif
559 
560 //*****************************************************************************
561 //* Cocurrency controls
562 //*****************************************************************************
570 
571 #ifdef __cplusplus
572 extern "C" {
573 #endif
574 
590 void FX_Mutex_Destroy(FX_MUTEX* pMutex);
610 void FX_Mutex_Lock(FX_MUTEX* pMutex);
618 void FX_Mutex_Unlock(FX_MUTEX* pMutex);
619 
620 #ifdef __cplusplus
621 }
622 #endif
623 
634 
635 #ifdef __cplusplus
636 extern "C" {
637 #endif
638 
654 void FX_SpinLock_Destroy(FX_SPINLOCK* pSpinLock);
675 void FX_SpinLock_Lock(FX_SPINLOCK* pSpinLock);
683 void FX_SpinLock_Unlock(FX_SPINLOCK* pSpinLock);
692 
693 #ifdef __cplusplus
694 }
695 #endif
696 
697 #ifdef _FPDFAPI_MT_
698 
700 class CFX_SpinLock
701 {
702  public:
703  CFX_SpinLock() : m_pSpinLock(NULL) {}
704  CFX_SpinLock(FX_SPINLOCK* pSpinLock) : m_pSpinLock(pSpinLock) {if (m_pSpinLock) FX_SpinLock_Lock(m_pSpinLock);}
705  ~CFX_SpinLock() {if (m_pSpinLock) FX_SpinLock_Unlock(m_pSpinLock);}
706 
708  FX_BOOL TryLock() {return FX_SpinLock_TryLock(m_pSpinLock);}
710  void Lock() {FX_SpinLock_Lock(m_pSpinLock);}
712  void Unlock() {FX_SpinLock_Unlock(m_pSpinLock);}
714  FX_BOOL IsLocked() {return FX_SpinLock_IsLocked(m_pSpinLock);}
715 
716  FX_SPINLOCK* m_pSpinLock;
717 };
718 
723 #define FXMT_SPLOCK_THIS CFX_SpinLock _fx_splock((FX_SPINLOCK*)this)
724 
728 #define FXMT_SPLOCK_OBJ(lock) CFX_SpinLock _fx_splock(lock)
729 
730 #else
731 
733 class CFX_SpinLock {};
734 #define FXMT_SPLOCK_THIS
735 #define FXMT_SPLOCK_OBJ(lock)
736 
737 #endif
738 
748 
749 #ifdef __cplusplus
750 extern "C" {
751 #endif
752 
760 FX_BOOL FX_RWLock_Initialize(FX_RWLOCK* pRWLock);
768 void FX_RWLock_Destroy(FX_RWLOCK* pRWLock);
778 FX_BOOL FX_RWLock_TryReadLock(FX_RWLOCK* pRWLock);
789 void FX_RWLock_ReadLock(FX_RWLOCK* pRWLock);
797 void FX_RWLock_ReadUnlock(FX_RWLOCK* pRWLock);
807 FX_BOOL FX_RWLock_TryWriteLock(FX_RWLOCK* pRWLock);
818 void FX_RWLock_WriteLock(FX_RWLOCK* pRWLock);
826 void FX_RWLock_WriteUnlock(FX_RWLOCK* pRWLock);
827 
828 #ifdef __cplusplus
829 }
830 #endif
831 
832 #ifdef _FPDFAPI_MT_
833 
834 class CFX_RWLockObject : public CFX_Object
835 {
836  public:
838  CFX_RWLockObject() {FX_RWLock_Initialize(&m_Lock);}
840  ~CFX_RWLockObject() {FX_RWLock_Destroy(&m_Lock);}
841 
843  FX_BOOL TryReadLock() {return FX_RWLock_TryReadLock(&m_Lock);}
845  void ReadLock() {FX_RWLock_ReadLock(&m_Lock);}
847  void ReadUnlock() {FX_RWLock_ReadUnlock(&m_Lock);}
849  FX_BOOL TryWriteLock() {return FX_RWLock_TryWriteLock(&m_Lock);}
851  void WriteLock() {FX_RWLock_WriteLock(&m_Lock);}
853  void WriteUnlock() {FX_RWLock_WriteUnlock(&m_Lock);}
854 
855  protected:
856  /* Critical section. */
857  FX_RWLOCK m_Lock;
858  friend class CFX_RWLock;
859 };
860 
861 class CFX_RWLock
862 {
863  public:
864  CFX_RWLock() : m_pRWLock(NULL), m_nStatus(0) {}
865  CFX_RWLock(FX_RWLOCK* pRWLock, FX_INT32 nStatus) : m_pRWLock(NULL), m_nStatus(0)
866  {
867  Init(pRWLock, nStatus);
868  }
869  CFX_RWLock(CFX_RWLockObject* pRWLockObj, FX_INT32 nStatus) : m_pRWLock(NULL), m_nStatus(0)
870  {
871  Init(&pRWLockObj->m_Lock, nStatus);
872  }
873  ~CFX_RWLock()
874  {
875  if (!m_pRWLock || !m_nStatus) return;
876  if (m_nStatus < 0)
877  FX_RWLock_ReadUnlock(m_pRWLock);
878  else
879  FX_RWLock_WriteUnlock(m_pRWLock);
880  }
881 
883  FX_BOOL TryReadLock()
884  {
885  if (FX_RWLock_TryReadLock(m_pRWLock))
886  {
887  m_nStatus = -1;
888  return true;
889  }
890  return false;
891  }
893  void ReadLock()
894  {
895  FX_RWLock_ReadLock(m_pRWLock);
896  m_nStatus = -1;
897  }
899  void ReadUnlock()
900  {
901  m_nStatus = 0;
902  FX_RWLock_ReadUnlock(m_pRWLock);
903  }
905  FX_BOOL TryWriteLock()
906  {
907  if (FX_RWLock_TryWriteLock(m_pRWLock))
908  {
909  m_nStatus = 1;
910  return true;
911  }
912  return false;
913  }
915  void WriteLock()
916  {
917  FX_RWLock_WriteLock(m_pRWLock);
918  m_nStatus = 1;
919  }
921  void WriteUnlock()
922  {
923  m_nStatus = 0;
924  FX_RWLock_WriteUnlock(m_pRWLock);
925  }
926 
927  protected:
928  FX_RWLOCK* m_pRWLock;
929  FX_INT32 m_nStatus;
930 
931  void Init(FX_RWLOCK* pRWLock, FX_INT32 nStatus)
932  {
933  m_pRWLock = pRWLock, m_nStatus = nStatus;
934  if (!m_pRWLock || !m_nStatus) return;
935  if (m_nStatus < 0)
936  FX_RWLock_ReadLock(m_pRWLock);
937  else
938  FX_RWLock_WriteLock(m_pRWLock);
939  }
940 };
941 
943 #define FXMT_RWLOCK_THIS CFX_RWLock _fx_rwlock((CFX_RWLock*)this)
944 
945 #define FXMT_RWLOCK_OBJ(lock, s) CFX_RWLock _fx_rwlock(lock, s)
946 
947 #define FXMT_RWLOCK_DEFINEOBJ(rwLock, lock, s) CFX_RWLock rwLock(lock, s)
948 
950 #define FXMT_RWLOCKOBJECT_DEFINE(rwLockObj) CFX_RWLockObject rwLockObj
951 
952 #define FXMT_RWLOCKOBJECT_TRYREADLOCK(lockObj) (lockObj)->TryReadLock()
953 
954 #define FXMT_RWLOCKOBJECT_TRYREADLOCK_IF(lockObj) if ((lockObj)->TryReadLock())
955 
956 #define FXMT_RWLOCKOBJECT_READLOCK(lockObj) (lockObj)->ReadLock()
957 
958 #define FXMT_RWLOCKOBJECT_READUNLOCK(lockObj) (lockObj)->ReadUnlock()
959 
960 #define FXMT_RWLOCKOBJECT_TRYWRITELOCK(lockObj) (lockObj)->TryWriteLock()
961 
962 #define FXMT_RWLOCKOBJECT_TRYWRITELOCK_IF(lockObj) if ((lockObj)->TryWriteLock())
963 
964 #define FXMT_RWLOCKOBJECT_WRITELOCK(lockObj) (lockObj)->WriteLock()
965 
966 #define FXMT_RWLOCKOBJECT_WRITEUNLOCK(lockObj) (lockObj)->WriteUnlock()
967 #else
968 
970 class CFX_RWLock {};
971 #define FXMT_RWLOCK_THIS
972 #define FXMT_RWLOCK_OBJ(lock, s)
973 #define FXMT_RWLOCK_DEFINEOBJ(rwLock, lock, s)
974 
975 #define FXMT_RWLOCKOBJECT_DEFINE(rwLockObj)
976 #define FXMT_RWLOCKOBJECT_TRYREADLOCK(lockObj)
977 #define FXMT_RWLOCKOBJECT_TRYREADLOCK_IF(lockObj)
978 #define FXMT_RWLOCKOBJECT_READLOCK(lockObj)
979 #define FXMT_RWLOCKOBJECT_READUNLOCK(lockObj)
980 #define FXMT_RWLOCKOBJECT_TRYWRITELOCK(lockObj)
981 #define FXMT_RWLOCKOBJECT_TRYWRITELOCK_IF(lockObj)
982 #define FXMT_RWLOCKOBJECT_WRITELOCK(lockObj)
983 #define FXMT_RWLOCKOBJECT_WRITEUNLOCK(lockObj)
984 #endif
985 
988 //*****************************************************************************
989 //* Atomic Count
990 //*****************************************************************************
998 
999 #ifdef __cplusplus
1000 extern "C" {
1001 #endif
1002 
1011 FX_INT32 FX_Atom_Add32(volatile FX_INT32* pAddend, FX_INT32 nIncrement);
1020 FX_INT32 FX_Atom_Subtract32(volatile FX_INT32* pAddend, FX_INT32 nDecrement);
1029 FX_INT64 FX_Atom_Add64(volatile FX_INT64* pAddend, FX_INT64 nIncrement);
1038 FX_INT64 FX_Atom_Subtract64(volatile FX_INT64* pAddend, FX_INT64 nDecrement);
1039 
1040 #ifdef __cplusplus
1041 }
1042 #endif
1043 
1046 #endif /* _FX_PROCESS_H_ */
1047 
FX_BOOL FX_SpinLock_Initialize(FX_SPINLOCK *pSpinLock)
Initialize a spin lock.
void FX_Thread_SetPriority(FX_HTHREAD hThread, FX_INT32 nPriority)
Set thread priority.
unsigned long FX_DWORD
32-bit unsigned integer.
Definition: fx_system.h:703
FX_BOOL FX_RWLock_TryWriteLock(FX_RWLOCK *pRWLock)
Try to lock for exclusive write.
void FX_Mutex_Lock(FX_MUTEX *pMutex)
Lock a mutex.
FX_WORD minute
Minute, from 0 to 59.
Definition: fx_process.h:108
FX_ThreadResult(WINAPI * FX_CALLBACK_ThreadProc)(FX_LPVOID param)
Callback function of thread procedure.
Definition: fx_process.h:286
void FX_Thread_RemovePrivateData(FX_LPVOID key)
Remove private data in the current thread.
FX_WORD milliseconds
Millisecond, from 0 to 999. PDF standard doesn't support now, you can omit this field if it is not ap...
Definition: fx_process.h:112
void FX_Process_Initialize()
Initialize process.
FX_INT32 FX_Atom_Add32(volatile FX_INT32 *pAddend, FX_INT32 nIncrement)
Increase 32-bits integer value.
CFX_ExceptionContext * FX_Thread_GetExceptionContext()
Get the current thread exception context.
void FX_Thread_Exit()
Exit from the current thread.
void(* PD_CALLBACK_FREEDATA)(FX_LPVOID pData)
Definition: fx_basic.h:3228
FX_LPVOID pUserData
Pointer to user data.
Definition: fx_process.h:314
FX_INT32 tzHour
Hour of time zone, from -12 to 12.
Definition: fx_process.h:118
void FX_Thread_SetPrivateData(FX_LPVOID key, FX_LPVOID data, PD_CALLBACK_FREEDATA callback)
Set private data in the current thread.
void FX_SpinLock_Destroy(FX_SPINLOCK *pSpinLock)
Destroy a spin lock.
void FX_Thread_SetLastError(FX_INT32 nErr)
Set the last error code in the current thread.
FX_INT64 FX_Atom_Subtract64(volatile FX_INT64 *pAddend, FX_INT64 nDecrement)
Decrease 64-bits integer value.
FX_BOOL FX_SpinLock_IsLocked(FX_SPINLOCK *pSpinLock)
Determine whether specified spin lock is locked or not.
void FX_Process_RemovePrivateData(FX_LPVOID key)
Remove private data in the current process.
Thread handler for application extension.
Definition: fx_process.h:311
void FX_Thread_SetHandler(FX_THREADHANDLER *pThreadHandler)
Set the current thread handler.
void FX_RWLock_ReadUnlock(FX_RWLOCK *pRWLock)
Unlock for share read.
FX_THREADHANDLER * FX_Thread_GetHandler()
Get the current thread handler.
CFX_ProcessContext * FX_Process_GetContext()
Retrieve process context.
FX_INT32 FX_Thread_WaitForMultipleThreads(const FX_HTHREAD *pThreads, FX_INT32 nCount)
Wait for termination of multiple threads.
Structure of system time.
Definition: fx_process.h:52
void FX_SpinLock_Unlock(FX_SPINLOCK *pSpinLock)
Unlock a spin lock.
FX_WORD year
Year, a four-digit number, such as 2014.
Definition: fx_process.h:98
void * FX_LPVOID
Pointer to any type.
Definition: fx_system.h:633
FX_INT64 FX_Atom_Add64(volatile FX_INT64 *pAddend, FX_INT64 nIncrement)
Increase 64-bits integer value.
#define FX_DEFINEHANDLE(name)
Macro to define a handle type.
Definition: fx_system.h:753
void * FX_SPINLOCK
Definition for spinlock.
Definition: fx_system.h:1611
FX_INT32 FX_Thread_GetLastError()
Get the last error code in the current thread.
int FX_INT32
32-bit signed integer.
Definition: fx_system.h:662
FX_INT32 FX_Atom_Subtract32(volatile FX_INT32 *pAddend, FX_INT32 nDecrement)
Decrease 32-bits integer value.
FX_BOOL FX_RWLock_TryReadLock(FX_RWLOCK *pRWLock)
Try to lock for share read.
void FX_Time_GetSystemTime(FX_SYSTEMTIME *pSystemTime)
Retrieve the current system date and time.
FX_LPVOID FX_Process_GetPrivateData(FX_LPVOID key)
Get private data in the current process.
FX_DWORD FX_Time_Sleep(FX_DWORD dwMilliseconds)
Delay the current running for specified milliseconds.
FX_INT32 FX_Thread_GetPriority(FX_HTHREAD hThread)
Get thread priority.
unsigned short FX_WORD
16-bit unsigned integer.
Definition: fx_system.h:656
void FX_Process_SetPrivateData(FX_LPVOID key, FX_LPVOID data, PD_CALLBACK_FREEDATA callback)
Set private data in the current process.
void FX_RWLock_Destroy(FX_RWLOCK *pRWLock)
Destroy a read-write lock.
void FX_RWLock_WriteLock(FX_RWLOCK *pRWLock)
Lock for exclusive write.
void FX_Mutex_Unlock(FX_MUTEX *pMutex)
Unlock a mutex.
void FX_Mutex_Destroy(FX_MUTEX *pMutex)
Destroy a mutex.
FX_WORD hour
Hour, from 0 to 23.
Definition: fx_process.h:106
FX_LPVOID FX_Thread_GetPrivateData(FX_LPVOID key)
Get private data in the current thread.
#define NULL
The null-pointer value.
Definition: fx_system.h:773
FX_BOOL FX_Mutex_Initialize(FX_MUTEX *pMutex)
Initialize a mutex.
FX_WORD day
Day of month, from 1 to 31.
Definition: fx_process.h:102
void FX_RWLock_ReadLock(FX_RWLOCK *pRWLock)
Lock for share read.
int FX_BOOL
Boolean variable (should be TRUE or FALSE).
Definition: fx_system.h:670
FX_WORD dayOfWeek
Day of week, from 0 to 6. PDF standard doesn't support now, you can omit this field if it is not appl...
Definition: fx_process.h:104
Header file for basic data class.
Structure for date and time.
Definition: fx_process.h:95
Under non-threading mode, defines as empty implementation.
Definition: fx_process.h:970
FX_BOOL FX_SpinLock_TryLock(FX_SPINLOCK *pSpinLock)
Try to lock a spin lock.
void FX_RWLock_WriteUnlock(FX_RWLOCK *pRWLock)
Unlock for exclusive write.
FX_WORD month
Month, from 1 to 12.
Definition: fx_process.h:100
CFX_ThreadContext * FX_Thread_GetContext()
Get the current thread context.
FX_HTHREAD FX_Thread_GetHandle()
Get the current thread handle.
void FX_Time_GetLocalTime(FX_SYSTEMTIME *pSystemTime)
Retrieve the current local date and time.
FX_PROCESSID FX_Process_GetID()
Get the current process ID.
FX_INT32 FX_Thread_WaitForSingleThread(FX_HTHREAD hThread)
Wait for termination of a single thread.
void FX_SpinLock_Lock(FX_SPINLOCK *pSpinLock)
Lock a spin lock.
FX_BOOL FX_Mutex_TryLock(FX_MUTEX *pMutex)
Try to lock a mutex.
FX_WORD second
Second, from 0 to 60. 60 for leap second.
Definition: fx_process.h:110
FX_DWORD FX_Time_GetClock()
Get the clock ticks elapsed by calling process.
CRITICAL_SECTION FX_MUTEX
Definition for mutex/critical section and read-write lock.
Definition: fx_system.h:1581
FX_BOOL FX_RWLock_Initialize(FX_RWLOCK *pRWLock)
Initialize a read-write lock.
FX_ThreadResult(WINAPI * FX_CALLBACK_ThreadProxyProc)(FX_CALLBACK_ThreadProc threadProc, FX_LPVOID param)
Callback function of thread proxy procedure.
Definition: fx_process.h:297
void FX_Process_Finalize()
Finalize process.
FX_HTHREAD FX_Thread_Create(FX_INT32 nPriority, size_t szStack, FX_CALLBACK_ThreadProc threadProc, FX_LPVOID param)
Create a new thread.
void FX_Thread_Yield()
Yield the processor to another thread.
Under non-threading mode, defines as empty implementation.
Definition: fx_process.h:733
FX_WORD tzMinute
Minute of time zone, from 0 to 59.
Definition: fx_process.h:120

Foxit Software Corporation Logo
@2019 Foxit Software Incorporated. All rights reserved.