L_RedirectIO
#include "l_bitmap.h"
L_VOID EXT_FUNCTION L_RedirectIO(pfnOpen, pfnRead, pfnWrite, pfnSeek, pfnClose, pUserData)
REDIRECTOPEN pfnOpen; |
/* far pointer to an open procedure */ |
REDIRECTREAD pfnRead; |
/* far pointer to a read procedure */ |
REDIRECTWRITE pfnWrite; |
/* far pointer to a write procedure */ |
REDIRECTSEEK pfnSeek; |
/* far pointer to a seek procedure */ |
REDIRECTCLOSE pfnClose; |
/* far pointer to a close procedure */ |
/* pointer to additional parameters */ |
Lets you replace the LEADTOOLS input/output functions for opening, reading, writing, seeking, and closing files.
Parameter |
Description |
pfnOpen |
Far pointer to an open procedure. Use NULL to reset to the default. For a description of the callback function syntax, refer to REDIRECTOPEN Callback Function. |
pfnRead |
Far pointer to a read procedure. Use NULL to reset to the default. For a description of the callback function syntax, refer to REDIRECTREAD Callback Function. |
pfnWrite |
Far pointer to a write procedure. Use NULL to reset to the default For a description of the callback function syntax, refer to REDIRECTWRITE Callback Function. |
pfnSeek |
Far pointer to a seek procedure. Use NULL to reset to the default. For a description of the callback function syntax, refer to REDIRECTSEEK Callback Function. |
pfnClose |
Far pointer to a close procedure. Use NULL to reset to the default. For a description of the callback function syntax, refer to REDIRECTCLOSE Callback Function. |
pUserData |
A void pointer that you can use to access a variable or structure containing data that your callback function needs. This gives you a way to receive data indirectly from the function that uses this callback function. (This is the same pointer that you pass in the pUserData parameter of the calling function.) |
|
Keep in mind that this is a void pointer, which must be cast to the appropriate data type within your callback function. |
Returns
None.
Comments
For example, you can redirect all of the LEADTOOLS I/O functions by using the multimedia extensions, or you can redirect all the toolkit I/O functions to your own I/O functions.
Use a NULL argument to reset an I/O function to its default setting. The redefinition of the I/O process is left to you to define.
This function cannot be used in combination with L_FeedLoad, L_LoadBitmapMemory, L_LoadMemory, L_StartFeedLoad, L_StopFeedLoad, L_SaveBitmapMemory, and L_SaveFileMemory.
Note: |
This function does not support Kodak PhotoCD (PCD), FlashPix (FPX), or Microsoft FAX (AWD) files. |
Required DLLs and Libraries
LTKRN For a listing of the exact DLLs and Libraries needed, based on the toolkit version, refer to Files To Be Included With Your Application. |
Platforms
Windows 95 / 98 / Me, Windows 2000 / XP, Windows CE.
See Also
Topics: |
|
|
Example
For complete sample code, refer to the REDIRECT example.
/* This example loads a file using redirected
input and output.
Refer to the individual callback function descriptions to see how they
are implemented. */
/************************** Global Declarations **********************************/
typedef struct tagDATA
{
HPALETTE hPalette; /* Logical palette for painting. */
L_TCHAR szFilename[128]; /* File name to load. */
FILEINFO FileInfo; /* FILEINFO structure. */
BITMAPHANDLE BitmapHandle; /* BITMAP HANDLE to hold the image. */
} DATA;
typedef struct tagUSERDATA
{
L_INT32 dwSize; /* Size of the buffer. */
L_INT32 dwUsed; /* Number of bytes used. */
L_CHAR L_HUGE *pData; /* Pointer to the buffer. */
L_CHAR L_HUGE *pCurData; /* Current pointer location. */
} USERDATA, L_FAR * LPUSERDATA;
/* Proc pointers for callback functions */
REDIRECTREAD lpfnCallBackRead; /* For MakeProcInstance */
REDIRECTOPEN lpfnCallBackOpen; /* For MakeProcInstance */
REDIRECTWRITE lpfnCallBackWrite; /* For MakeProcInstance */
REDIRECTSEEK lpfnCallBackSeek; /* For MakeProcInstance */
REDIRECTCLOSE lpfnCallBackClose; /* For MakeProcInstance */
DATA Data; /* Pointer to DATA structure */
HANDLE hInst; /* Current instance of the application */
HANDLE hBuf; /* Handle for globally allocated memory */
USERDATA UserData; /* User structure for I/O operation */
/* Prototypes for callback functions */
L_INT L_FAR L_EXPORT WindowsClose (L_INT FD, L_VOID L_FAR* pUserData);
L_INT32 L_FAR L_EXPORT WindowsSeek (L_INT FD, L_INT32 lnPos, L_INT nCount,
L_VOID L_FAR* pUserData);
L_UINT L_FAR L_EXPORT WindowsWrite (L_INT FD, L_CHAR L_FAR * pBuf, L_UINT
uCount, L_VOID L_FAR* pUserData);
L_UINT L_FAR L_EXPORT WindowsRead (L_INT FD, L_CHAR L_FAR * pBuf, L_UINT
uCount, L_VOID L_FAR* pUserData);
L_INT L_FAR L_EXPORT WindowsOpen (const L_CHAR L_FAR * pFile, L_INT nMode,
L_INT nShare, L_VOID L_FAR* pUserData);
/***************************************************************************************/
BOOL Window_OnCreate (HWND hWnd, CREATESTRUCT FAR * lpCreateStruct)
{
L_INT32 lSizeToRead;
HFILE hFile;
L_INT nRet;
UNREFERENCED_PARAMETER (lpCreateStruct);
/* We will allocate a buffer of the image size and read the image into
it,
then all of our I/O operations will be operate on this buffer */
#ifdef UNICODE
hFile = _wopen (Data.szFilename, OF_READ | OF_SHARE_DENY_WRITE);
#else
hFile = _lopen (Data.szFilename, OF_READ | OF_SHARE_DENY_WRITE);
#endif
UserData.dwSize = _llseek (hFile, 0, FILE_END);
_llseek (hFile, 0, FILE_BEGIN);
/* Allocate a buffer to hold the file. */
hBuf = GlobalAlloc (GMEM_MOVEABLE, UserData.dwSize);
UserData.pData = (L_CHAR L_FAR *)GlobalLock (hBuf);
UserData.pCurData = UserData.pData;
UserData.dwUsed = 0;
lSizeToRead = 0;
/* Read the file in a loop, because the file could be larger than a single
read can request. */
while (lSizeToRead < UserData.dwSize)
{
nRet = _lread (hFile, (L_VOID L_HUGE *) UserData.pCurData,
(L_INT) min (UserData.dwSize - lSizeToRead, 32000));
lSizeToRead += nRet;
UserData.pCurData += nRet;
}
UserData.pCurData = UserData.pData;
_lclose (hFile);
/* Create instances of each I/O function*/
lpfnCallBackOpen = (REDIRECTOPEN) MakeProcInstance ((FARPROC) WindowsOpen, hInst);
lpfnCallBackRead = (REDIRECTREAD) MakeProcInstance ((FARPROC) WindowsRead, hInst);
lpfnCallBackWrite = (REDIRECTWRITE) MakeProcInstance ((FARPROC) WindowsWrite, hInst);
lpfnCallBackSeek = (REDIRECTSEEK) MakeProcInstance ((FARPROC) WindowsSeek, hInst);
lpfnCallBackClose = (REDIRECTCLOSE) MakeProcInstance ((FARPROC) WindowsClose, hInst);
/* Initialize the bitmap to the image width, height, and 8 bits per pixel. */
L_InitBitmap (&Data.BitmapHandle, sizeof(BITMAPHANDLE), Data.FileInfo.Width,
Data.FileInfo.Height, 8);
/* Use our own routines to replace the internal I/O calls */
L_RedirectIO ((REDIRECTOPEN) lpfnCallBackOpen,
(REDIRECTREAD) lpfnCallBackRead,
(REDIRECTWRITE) lpfnCallBackWrite,
(REDIRECTSEEK) lpfnCallBackSeek,
(REDIRECTCLOSE) lpfnCallBackClose, &UserData);
/* Load the bitmap as an 8 bit */
nRet = L_LoadBitmap (Data.szFilename, &Data.BitmapHandle, sizeof(BITMAPHANDLE), 8, ORDER_RGB, NULL, NULL);
/* Reset the I/O routines to the default ones. */
L_RedirectIO (NULL, NULL, NULL, NULL, NULL, NULL);
/* Free the function instances */
FreeProcInstance ((FARPROC) lpfnCallBackOpen);
FreeProcInstance ((FARPROC) lpfnCallBackRead);
FreeProcInstance ((FARPROC) lpfnCallBackWrite);
FreeProcInstance ((FARPROC) lpfnCallBackClose);
FreeProcInstance ((FARPROC) lpfnCallBackSeek);
FORWARD_WM_QUERYNEWPALETTE (hWnd, SendMessage);
GlobalUnlock (hBuf);
GlobalFree (hBuf);
return (nRet); /* SUCCESS (TRUE) if creation is OK */
}