Myślę,że wklejenie kodu tu, będzie najelpszym wyjściem. Tak więc jedziem:
To jest header:
// The following ifdef block is the standard way of creating macros which make exporting
// from a DLL simpler. All files within this DLL are compiled with the BCDCORE_EXPORTS
// symbol defined on the command line. this symbol should not be defined on any project
// that uses this DLL. This way any other project whose source files include this file see
// BCDCORE_API functions as being imported from a DLL, wheras this DLL sees symbols
// defined with this macro as being exported.
#ifdef BCDCORE_EXPORTS
#define BCDCORE_API __declspec(dllexport)
#else
#define BCDCORE_API __declspec(dllimport)
#endif
// start define section ///////////////////////////////////////////////////////
// common define
// define for debug
#define DBG_COMMANDE 0
#define DBGSCAN 0
// define terminate
#define TERMINATOR_NONE 0x00
#define TERMINATOR_CRLF 0x01
#define TERMINATOR_SPACE 0x02
#define TERMINATOR_TAB 0x03
// define scan result
#define RESULT_USERMSG 0x00
#define RESULT_KBDMSG 0x01
#define RESULT_COPYPASTE 0x02
#define RESULT_EVENT 0x03
#define RESULT_CALLBACK 0x04
// etc define
#define STX 0x02
#define ETX 0x03
#define CR 0x0D
#define LF 0x0A
// 1D scanner
#define WM_SCANNED WM_USER+0x7777
// 2D scanner
#define WM_IMAGE WM_USER+0x7778
// select for scan mode or image mode
#define MODE_SCAN 0x00
#define MODE_IMAGE 0x01
// select for decode mode
#define STANDARD 0x00
#define ADVANCED_LINEAR 0x02
#define QUICK_OMNI 0x01
// end define section ///////////////////////////////////////////////////////
// start enum section ///////////////////////////////////////////////////////
// common enum
// scan result status(error code)
typedef enum _STATUS_BCD
{
ERROR_NO_ERROR = 0,
ERROR_NO_READ,
ERROR_UNKNOWN_TYPE,
ERROR_WRONG_DATA,
ERROR_NO_SCAN_DATA,
ERROR_SCAN_TIMEOUT,
} ERROR_BSCANNER;
// barcode type
typedef enum _BAR_TYPE
{
// 1D scanner
BAR_TYPE_ERROR =0x00,
BAR_UNKNOWN =0x00,
UPC_A =0x01, /* 0x41 */
UPC_E =0x02, /* 0x42 */
UPC_E1 =0x03, /* 0x43 */
EAN_8 =0x04, /* 0x44 */
EAN_13 =0x05, /* 0x45 */
BOOKLAND_EAN =0x06, /* 0x46 */
CODE_128 =0x07, /* 0x47 */
EAN_128 =0x08, /* 0x48 */
ISBT_128 =0x09, /* 0x49 */
CODE_39 =0x0A, /* 0x4A */
TRIOPTIC_CODE_39 =0x0B, /* 0x4B */
CODE_93 =0x0C, /* 0x4C */
CODE_11 =0x0D, /* 0x4D */
INTERLEAVED_2_OF_5 =0x0E, /* 0x4E */
DISCRETE_2_OF_5 =0x0F, /* 0x4F */
CODABAR =0x10, /* 0x50 */
MSI =0x11, /* 0x51 */
GS1_DATABAR_14 =0x12, /* 0x52 */
GS1_DATABAR_LIMITED =0x13, /* 0x53 */
GS1_DATABAR_EXPANDED =0x14, /* 0x54 */
UCC_COUPON =0x15, /* 0x55 */
CHINESE_2_OF_5 =0x16, /* 0x56 */
BAR_ALL =0x17,
// DUMMY
CODE_32 =0x18,
// 2D scanner
BAR_SYM_AZTEC = 0,
BAR_SYM_CODABAR,
BAR_SYM_CODE11,
BAR_SYM_CODE128,
BAR_SYM_CODE39,
BAR_SYM_CODE49,
BAR_SYM_CODE93,
BAR_SYM_COMPOSITE,
BAR_SYM_DATAMATRIX,
BAR_SYM_EAN8, // 10
BAR_SYM_EAN13,
BAR_SYM_INT25,
BAR_SYM_MAXICODE,
BAR_SYM_MICROPDF,
BAR_SYM_OCR,
BAR_SYM_PDF417,
BAR_SYM_POSTNET,
BAR_SYM_QR,
BAR_SYM_RSS,
BAR_SYM_UPCA, // 20
BAR_SYM_UPCE0,
BAR_SYM_BPO,
BAR_SYM_CANPOST,
BAR_SYM_AUSPOST,
BAR_SYM_IATA25,
BAR_SYM_CODABLOCK,
BAR_SYM_JAPOST,
BAR_SYM_PLANET,
BAR_SYM_DUTCHPOST,
BAR_SYM_MSI, // 30
BAR_SYM_TLCODE39,
BAR_SYM_TRIOPTIC,
BAR_SYM_CODE32,
BAR_SYM_MATRIX25,
BAR_SYM_PLESSEY,
BAR_SYM_CHINAPOST,
BAR_SYM_KOREAPOST,
BAR_SYM_TELEPEN,
BAR_SYM_CODE16K,
BAR_SYM_POSICODE, // 40
BAR_SYM_GS1_128,
BAR_SYM_USPS4CB,
BAR_SYM_IDTAG,
BAR_SYM_ISBT,
BAR_SYM_STRT25,
BAR_SYM_COUPONCODE,
BAR_SYM_LABEL,
BAR_SYM_HANXIN,
BAR_SYM_GRIDMATRIX,
BAR_SYM_UPCE1,
BAR_NUM_SYMBOLOGIES,
// 1D scanner 4813
IS4813_BAR_UNKNOWN =0x00,
IS4813_UPC_A,
IS4813_UPC_E,
IS4813_EAN_8,
IS4813_EAN_13,
IS4813_CODE_39,
IS4813_CODE_93,
IS4813_CODE_ITF_2OF5,
IS4813_CODE_128,
IS4813_CODABAR,
IS4813_MSI_PLESSEY, // 0x0A
IS4813_UK_PLESSEY,
IS4813_CODE_11,
IS4813_MATRIX_2OF5,
IS4813_STANDARD_2OF5,
IS4813_AIRLINE_2OF5_13_DIGIT,
IS4813_AIRLINE_2OF5_15_DIGIT,
IS4813_HONGKONG_2OF5, // 0x11
IS4813_NEC_2OF5,
IS4813_TELEPEN,
IS4813_TRIOPTIC,
IS4813_GS1_DATABAR_14,
IS4813_GS1_DATABAR_LIMITED,
IS4813_GS1_DATABAR_EXPANDED,
IS4813_BAR_ALL // 0x18
// DUMMY
}BAR_TYPE;
// scanner's orders(commands)
typedef enum
{
// common orders
ORDER_DEBUG00 = 0,
ORDER_DEBUG01,
ORDER_DEBUG02,
ORDER_PARAM_INIT,
ORDER_HWTRIGGERON,
ORDER_HWTRIGGEROFF,
ORDER_SETHWND,
ORDER_SCANNER_ENABLE,
ORDER_SCANNER_DISABLE,
ORDER_BEEP_ENABLE,
ORDER_BEEP_DISABLE,
ORDER_VIBRATE_ENABLE,
ORDER_VIBRATE_DISABLE,
ORDER_LED_ENABLE,
ORDER_LED_DISABLE,
ORDER_GETBARTYPE,
ORDER_GETBARSTRING,
ORDER_GETRESULT,
ORDER_AUTOSCAN_ON,
ORDER_AUTOSCAN_OFF,
ORDER_ISENABLED,
ORDER_TRIGGER_TIMEOUT,
ORDER_SCANNER_DEFAULT,
ORDER_SCANNER_GETPARAM,
ORDER_SCANNER_AUTOSCANINTERVAL,
ORDER_SETRESULTTYPE,
ORDER_SETTERMINATOR,
ORDER_SCANNER_GETTYPESTATUS,
ORDER_SETCONFIG,
ORDER_GETCONFIG,
ORDER_ENABLEPREFIX,
ORDER_ENABLEPOSTFIX,
ORDER_SETPREFIX,
ORDER_SETPOSTFIX,
ORDER_GETPREFIX,
ORDER_GETPOSTFIX,
ORDER_SETSCANKEY,
ORDER_SETSFILENAME,
ORDER_SETFFILENAME,
ORDER_SETVIBRATETIME_SUCCESS,
ORDER_SETVIBRATETIME_FAIL,
ORDER_GETSETTING,
ORDER_BARTYPE_DISABLE,
ORDER_BARTYPE_ENABLE,
ORDER_SET_CURBARCODE,
ORDER_SET_BARID,
ORDER_SET_BARLENGTH_MAX,
ORDER_SET_BARLENGTH_MIN,
ORDER_SET_BARFLAG_INDEX,
ORDER_SET_BARFLAG_BFLAG,
ORDER_GETBARFLAG,
ORDER_DETAIL_SET,
ORDER_VIBRATEOPERATION,
ORDER_TRANSMIT_ID,
ORDER_GETSCANNERVERSION,
ORDER_IS_TURNON,
ORDER_SWITCH_POWER,
ORDER_OEM_INIT,
ORDER_SET_TRIGGERENABLE,
ORDER_SET_TRIGGERDISABLE,
ORDER_SET_ISTRIGGERENABLE,
// 1D scanner(SE955)
ORDER_GETFIRMWAREVERSION,
ORDER_POWER_MAX,
ORDER_POWER_LOW,
ORDER_SET_LINEARSECURITYLEVEL,
ORDER_SET_BIDIRECTIONALMODE,
// 2D scanner(IT5300)
ORDER_ISSCANPCLK,
ORDER_SETSCANPCLK,
ORDER_GETCAPTURE,
ORDER_STOPSCAN,
ORDER_GET_DECODERREVISION,
ORDER_GET_APIREVISION,
ORDER_CENTERWINDOW_EANBLE,
ORDER_CENTERWINDOW_DISABLE,
ORDER_SET_DECODEMODE,
ORDER_SET_DELAYDECODING,
ORDER_IMAGESTREAM_INIT,
ORDER_IMAGESTREAM_START,
ORDER_IMAGESTREAM_READ,
ORDER_IMAGESTREAM_STOP,
ORDER_SETEXPOSURESETTINGS,
ORDER_AIMER_ON,
ORDER_AIMER_OFF,
ORDER_ILLUMINATION_ON,
ORDER_ILLUMINATION_OFF,
ORDER_SETSCANLIGHTSMODE,
ORDER_GETENGINECONFIG,
ORDER_GET_SCANDRVREVISION,
ORDER_SETSCANIMAGEMODE,
ORDER_GETDEFAULTSETTING,
ORDER_GETOCRFLAG,
ORDER_SETOCRFLAG,
ORDER_GETCONTINUOUSMODE,
ORDER_SETCONTINUOUSMODE,
// 1D scanner(IS4813)
ORDER_SETEXTRAREAD,
ORDER_SETEXTRAREADTIME,
ORDER_SETSTITCHINGENABLE,
ORDER_SETALLOWNONPROPORTIONAL,
ORDER_SETSTITCHINGLEVEL,
ORDER_SETROUNDINGUNCERTAINTYLEVEL,
// BEEP GET/SET SCALE/TIME
ORDER_GETBEEPSCALE,
ORDER_SETBEEPSCALE,
} Order_t;
// 1D scanner
// 2D scanner
// command for image action
enum
{
IMAGE_GET_START = 0,
IMAGE_GET_STOP,
};
// capture function
enum
{
IMAGE_WIDTH = 752,
IMAGE_HEIGHT = 480,
IMAGE_SIZE = IMAGE_WIDTH * IMAGE_HEIGHT,
NUM_OF_COLOR_INDEX = 256,
COLOR_TABLE_SIZE = sizeof(RGBQUAD) * NUM_OF_COLOR_INDEX,
BITMAPINFO_SIZE = sizeof(BITMAPINFOHEADER) + COLOR_TABLE_SIZE,
BMP_HEADER_SIZE = sizeof(BITMAPFILEHEADER) + BITMAPINFO_SIZE,
BMP_FILE_SIZE = BMP_HEADER_SIZE + IMAGE_SIZE,
BMP_IMAGE_OFFSET = BMP_HEADER_SIZE,
};
// scan light mode.
typedef enum SCANLIGHTSMODE SCANLIGHTSMODE;
enum SCANLIGHTSMODE
{
SCANLIGHTSMODE_OFF= 0, // Aimers and illumination off.
SCANLIGHTSMODE_ILLUM_ONLY_ON, // Illumination only on.
SCANLIGHTSMODE_AIMER_ONLY_ON, // Aimers only on.
SCANLIGHTSMODE_ON, // Both aimers and illumination on
};
// end enum section ///////////////////////////////////////////////////////
// start structure section ///////////////////////////////////////////////////////
// common structure
// scanner's configurations.
typedef struct _BCD_CONFIG
{
// common configurations
BOOL config_scannerenable; // status of scanner enable.
BOOL config_bautoscan; // status of auto scna mode.
DWORD config_dwtriggertimeout; // value of trigger timeout.
DWORD config_dwautoscantriggertime; // value of auto scan interval.
BYTE config_btresulttype; // status of result type.
BYTE config_btTerminator; // status of terminator character.
BYTE config_btscankey; // future use.
BOOL config_bprefix; // status of prefix enable.
BOOL config_bpostfix; // status of postfix enable.
TCHAR config_szprefix[MAX_PATH]; // value of prefix.
TCHAR config_szpostfix[MAX_PATH]; // value of postfix.
BOOL config_bbeep; // status of beep enable.
BOOL config_bvibrator; // status of vibrator enable.
BOOL config_bLED; // status of LED enable.
TCHAR config_szscansuccessfile[MAX_PATH]; // file name of scan success time.
TCHAR config_szscanfailfile[MAX_PATH]; // file name of scan fail time.
DWORD config_dwvibsuccesstime; // vibrator operate time at after scan success.
DWORD config_dwvibfailtime; // vibrator operate time at after scan fail.
BAR_TYPE config_BTcurbartype; // current barcode type(use for internal).
BYTE config_btcurindex; // current barcode index(use for internal).
BOOL config_bBarID; // status of barcode ID enable.
// 1D scanner(SE955)
BYTE config_btLinearSecurityLevel; // status of linear security level mode.
BOOL config_bBidirectional; // status of Bi-directional mode enable.
// 2D scanner(IS4813)
BOOL config_bCenterWindow; // status of center window enable.
BYTE config_btDecodeMode; // status of decode mode.
DWORD config_dwDelayDecoding; // value of delay decoding mode. if value is 0 then mode is disable.
DWORD config_dwMaxExposure; // value of max exposure.
DWORD config_dwMaxGain; // value of max gain.
DWORD config_dwTargetWhite; // value of target white.
DWORD config_dwTargetWhiteWindow; // value of target white window.
int config_nScanImageMode; // status of scan mode or image mode.
BOOL config_bImageAimer; // status of aimer mode.
BOOL config_bImageIllumination; // status of illumination mode.
// 1D scanner(IS4813)
BOOL config_bStitchingEnable; // status of Stitching mode enable.
BOOL config_bAllowNonProportional; // status of AllowNonProportiona mode enable.
DWORD config_dwStitchingLevel; // status of StitchingLevel level.
DWORD config_dwRoundingUncertaintyLevel; // status of RoundingUncertaintyLevel mode.
// Reserve field
DWORD config_Reserve01; // Reserve field 01.
DWORD config_Reserve02; // Reserve field 02.
DWORD config_Reserve03; // Reserve field 03.
DWORD config_Reserve04; // Reserve field 04.
} BCD_CONFIG, *PBCD_CONFIG;
// each barcode type's detail flag setting configuration.
typedef struct _BAR_FLAG
{
TCHAR wszFlagName[MAX_PATH]; // detail option subject
BOOL bFlag; // detail option subject flag
BYTE btDIndex; // detail option index
BYTE btDetail; // just flag for programming(ignore)
// 1D scanner
BYTE btparam; // just flag for programming(ignore)
DWORD dwDetailProperty; // barcode property only used IS4813 scanner.
// Reserve field
DWORD dwDetailReserve01; // Reserve field 01.
DWORD dwDetailReserve02; // Reserve field 02.
}BAR_FLAG, *PBAR_FLAG;
// each barcode setting's configuration.
struct structSSCannerSetting
{
TCHAR wszBarName[MAX_PATH]; // barcode name
BYTE btIndex; // barcode index
BYTE btMark; // barcode mark(ID)
char chparam; // read only(each barcode's parameter)
BOOL bCodeEnable; // barcode enable flag
BOOL bRange; // barcode range flag
int btLengthMin; // barcode length min
int btLengthMax; // barcode length max
PBAR_FLAG pBarFlag; // barcode detail setting structure.
// 1D scanner
int btRangeMin; // barcode range min
int btRangeMax; // barcode range max
DWORD dwSymID; // barcode SymID only used IS4813 scanner.
DWORD dwProperty; // barcode property only usewd IS4813 scanner.
int nExtraRead; // barcode ExtraRead only used IS4813 scanner.
int nExtraTime; // barcode ExtraTime only used IS4813 scanner.
// Reserve field
DWORD dwSetReserve01; // Reserve field 01.
DWORD dwSetReserve02; // Reserve field 02.
};
typedef struct _SCAN_RESULT
{
TCHAR szScanValue[MAX_PATH]; // barcode value(compatible to szScanMaxValue)
TCHAR szScanType[MAX_PATH]; // barcode name.
TCHAR tcCodeID; // barcode ID.
BAR_TYPE barType; // barcode type(BAR_TYPE).
TCHAR tcSymLetter; // barcode Letter(for 2D).
TCHAR tcSymModifier; // barcode Modifier(for 2D).
WORD unScanLength; // barcode value's length.
TCHAR szScanMaxValue[MAX_PATH*15]; // barcode value.(if you read to large barcode(have the many data) szScanValue is not enough fill scan data. so as use as possible this variable.
// Reserve field
DWORD dwDecodeTime; // DecodeTime (ms)
DWORD dwResultReserve02; // Reserve field 02.
} SCAN_RESULT, *PSCAN_RESULT;
// 1D scanner
// 2D scanner
// each OCR detail flag
typedef struct _OCR_FLAG
{
TCHAR szOCRTemplate[MAX_PATH]; // A null-terminated string that indicates one or more template patterns for the OCR decode.
TCHAR szOCRGroupG[MAX_PATH]; // A null-terminated string that defines the set of characters matching group "g" in a template.
TCHAR szOCRGroupH[MAX_PATH]; // A null-terminated string that defines the set of characters matching group "h" in a template.
TCHAR szOCRCheckChar[MAX_PATH]; // A null-terminated string that defines the legal characters for checksum computation in a decoded message.
}OCR_FLAG, *POCR_FLAG;
// for bitmap format when you use to image.
typedef struct BmpFormat BmpFormat;
struct BmpFormat
{
BITMAPFILEHEADER * pBitmapFileHeader;
unsigned int uBitmapFileHeaderSize;
BITMAPINFOHEADER * pBitmapInfoHeader;
unsigned int uBitmapInfoHeaderSize;
RGBQUAD * pRgbQuad;
unsigned int uRgbQuadSize;
unsigned char * pImageData;
unsigned int uImageDataSize;
};
// for scan engine configurations.
typedef struct ENGINECONFIG ENGINECONFIG;
struct ENGINECONFIG
{
DWORD dwIlluminationType; // Writeable 0 = Green, Non Zero = Red
DWORD dwLedControlMode; // Read Only at this time : status of interlaced mode or concurrent mode.
DWORD dwPixelFrequency; // Read Only at this time : status of 12Mh or 24Mh pixel frequency.
DWORD dwEngineId; // Read Only : Engine ID Number.
/*
0~2 BIT : Focus position of the lens(SF : 001, SR : 010)
3~4 BIT : Reserved.
5~6 BIT : Type of illumination populated(future use).
7~8 BIT : Reserved.
9~11 BIT : Aimer type(5000 LED : 000, 5100 Bright Aimer : 001, 5300 Laser : 010)
12~14 BIT : Imager type(future use).
15 BIT : Reserved.
*/
DWORD dwFirmwareCksum; // Read Only : FirmwareCksum
DWORD dwFirmwareVersion; // Read Only : FirmwareVersion
DWORD dwAimerCenterX; // Read Only : AimerCenterX
DWORD dwAimerCenterY; // Read Only : AimerCenterY
DWORD dwEngineSensorID; // Read Only : EngineSensorID
DWORD dwEngineID; // EngineIDs values.
/*
TYPE_NONE = 0, // No imager hardware
TYPE_IT4200 = 1,
TYPE_IT4000 = 5,
TYPE_IT4100 = 6,
TYPE_IT4300 = 7,
TYPE_IT5000VGA = 10,
TYPE_IT5000VGA_P = 11
*/
DWORD dwImagerRows; // Number of rows for a given imager.
DWORD dwImagerCols; // Number of columns for a given imager.
DWORD dwBitsPerPixel; // Typically this is 8 for byte pixels.
DWORD dwRotation; // RIGHT_SIDE_UP = 0, ROTATED_RIGHT, UPSIDE_DOWN, ROTATED_LEFT.
DWORD dwAimerXoffset; // This value represents the X coordinate for the center of the aimer pattern.
DWORD dwAimerYoffset; // This value represents the Y coordinate for the center of the aimer pattern.
DWORD dwYDepth; // This value represents the Y Depth
};
// ++ 2011-06-09 Samuel.Moon
// Beep Sound Changed
typedef enum
{
BEEP_SCALE_NONE = 0,
BEEP_SCALE_C4 = 1,
BEEP_SCALE_D4 ,
BEEP_SCALE_E4 ,
BEEP_SCALE_F4 ,
BEEP_SCALE_G4 ,
BEEP_SCALE_A4 ,
BEEP_SCALE_B4 ,
BEEP_SCALE_C5 ,
BEEP_SCALE_D5 ,
BEEP_SCALE_E5 ,
BEEP_SCALE_F5 ,
BEEP_SCALE_G5 ,
BEEP_SCALE_A5 ,
BEEP_SCALE_B5 ,
BEEP_SCALE_C6 ,
BEEP_SCALE_D6 ,
BEEP_SCALE_E6 ,
BEEP_SCALE_F6 ,
BEEP_SCALE_G6 ,
BEEP_SCALE_A6 ,
BEEP_SCALE_B6 ,
BEEP_SCALE_C7 ,
}BEEP_BUZZER_SCALE;
typedef struct _BCD_BEEP_LEVEL_SETTING
{
DWORD dwSize; // Struct Size
BYTE nBeepType; // Success Beep = 1 , Fail Beep = 2
BYTE nFirstBeep; // First Beep Level
BYTE nSecondBeep; // Second Beep Level
BYTE nValidBeep; // Not Used
WORD dwBeepTime; // First Beep and Second Beep Time value
WORD dwTimeReserve; // TimeReserved
DWORD dwReserved; // Reserved
}BCD_BEEP_LEVEL_SETTING, *PBCD_BEEP_LEVEL_SETTING;
// end struct section ///////////////////////////////////////////////////////
// start function's pointer define section ///////////////////////////////////////////////////////
// 1D&2D scanner ///////////////////////////////////////////////////////
typedef HANDLE (WINAPI *PFN_BcdOpen)(void);
typedef void (WINAPI *PFN_BcdClose)(void);
typedef void (WINAPI *PFN_BcdEnable)(BOOL);
typedef BOOL (WINAPI *PFN_BcdIsEnabled)(void);
typedef void (WINAPI *PFN_BcdSetHWND)(HWND);
typedef void (WINAPI *PFN_BcdSetTerminator)(BYTE);
typedef void (WINAPI *PFN_BcdSetResultType)(DWORD);
typedef BYTE (WINAPI *PFN_BcdGetResultType)(void);
typedef void (WINAPI *PFN_BcdEnableBeep)(BOOL);
typedef void (WINAPI *PFN_BcdEnableLED)(BOOL);
typedef void (WINAPI *PFN_BcdEnablePrefix)(BOOL);
typedef BOOL (WINAPI *PFN_BcdSetPrefix)(TCHAR*);
typedef void (WINAPI *PFN_BcdGetPrefix)(TCHAR*);
typedef void (WINAPI *PFN_BcdEnablePostfix)(BOOL);
typedef BOOL (WINAPI *PFN_BcdSetPostfix)(TCHAR*);
typedef void (WINAPI *PFN_BcdGetPostfix)(TCHAR*);
typedef void (WINAPI *PFN_BcdSetTrigTimeout)(DWORD);
typedef void (WINAPI *PFN_BcdEanbleAutoScan)(BOOL);
typedef void (WINAPI *PFN_BcdSetAutoScanInterval)(DWORD);
typedef void (WINAPI *PFN_BcdSetConfig)(PBCD_CONFIG);
typedef void (WINAPI *PFN_BcdGetConfig)(PBCD_CONFIG);
typedef LPWSTR (WINAPI *PFN_BcdGetBarTypeString)(BAR_TYPE);
typedef BOOL (WINAPI *PFN_BcdGetEnableLength)(BAR_TYPE);
typedef void (WINAPI *PFN_BcdGetBarLength)(BAR_TYPE, int*, int*);
typedef BOOL (WINAPI *PFN_BcdSetBarLength)(BAR_TYPE, int, int);
typedef void (WINAPI *PFN_BcdTransmitBarID)(BOOL);
typedef BYTE (WINAPI *PFN_BcdGetBarID)(BAR_TYPE);
typedef void (WINAPI *PFN_BcdSetBarID)(BAR_TYPE, BYTE);
typedef void (WINAPI *PFN_BcdSetDefault)(void);
typedef void (WINAPI *PFN_BcdEnableBarcode)(BAR_TYPE, BOOL);
typedef BOOL (WINAPI *PFN_BcdEnableALLBarcode)(BOOL);
typedef BOOL (WINAPI *PFN_BcdIsBarcodeEnabled)(BAR_TYPE);
typedef void (WINAPI *PFN_BcdSetBarFlag)(BAR_TYPE, int, BOOL);
typedef PBAR_FLAG (WINAPI *PFN_BcdGetBarFlagArrayPtr)(BAR_TYPE);
typedef void (WINAPI *PFN_BcdTrigTurnOn)(BOOL);
typedef PSCAN_RESULT (WINAPI *PFN_BcdGetResult)(void);
typedef LPWSTR (WINAPI *PFN_BcdGetString)(void);
typedef BAR_TYPE (WINAPI *PFN_BcdGetBarType)(void);
typedef UINT (WINAPI *PFN_BcdGetLength)(void);
typedef void (WINAPI *PFN_BcdGetVersion)(TCHAR*);
typedef void (WINAPI *PFN_BcdTriggerEnable)(BOOL);
typedef BOOL (WINAPI *PFN_BcdIsTriggerEnabled)(void);
typedef void (WINAPI *PFN_BcdSetContinuousMode)(BOOL);
typedef BOOL (WINAPI *PFN_BcdGetContinuousMode)(void);
// 1D scanner SE955
typedef void (WINAPI *PFN_BcdSetLinearSecurityLevel)(BYTE);
typedef void (WINAPI *PFN_BcdSetBidirectionalMode)(BOOL);
// 2D scanner IT5300
typedef void (WINAPI *PFN_BcdGetDefaultBarLength)(BAR_TYPE, int*, int*);
typedef OCR_FLAG (WINAPI *PFN_BcdGetOCRFlag)(void);
typedef void (WINAPI *PFN_BcdSetOCRFlag)(OCR_FLAG);
typedef void (WINAPI *PFN_BcdGetDecoderVersion)(TCHAR*);
typedef void (WINAPI *PFN_BcdGetApiVersion)(TCHAR*);
typedef void (WINAPI *PFN_BcdGetScanDriverVersion)(TCHAR*);
typedef void (WINAPI *PFN_BcdSetSCANPCLK)(DWORD);
typedef BOOL (WINAPI *PFN_BcdIs24MHzPCLK)(void);
typedef void (WINAPI *PFN_BcdEnableCenterWindow)(BOOL);
typedef void (WINAPI *PFN_BcdSetDecodeMode)(BYTE);
typedef void (WINAPI *PFN_BcdSetDelayDecoding)(DWORD);
typedef HBITMAP (WINAPI *PFN_BcdCreateDIBSection)(BmpFormat*, LONG, LONG);
typedef void (WINAPI *PFN_BcdDestroyDIBSection)(HBITMAP);
typedef BOOL (WINAPI *PFN_BcdGetCaptureImage)(PBYTE, DWORD*);
typedef BOOL (WINAPI *PFN_BcdImageStreamInit)(void);
typedef BOOL (WINAPI *PFN_BcdImageStreamStart)(void);
typedef BOOL (WINAPI *PFN_BcdImageStreamRead)(unsigned char*, DWORD*);
typedef BOOL (WINAPI *PFN_BcdImageStreamStop)(void);
typedef BOOL (WINAPI *PFN_BcdAimerOn)(BOOL);
typedef BOOL (WINAPI *PFN_BcdIlluminationOn)(BOOL);
typedef BOOL (WINAPI *PFN_BcdSetScanLightsMode)(SCANLIGHTSMODE);
typedef BOOL (WINAPI *PFN_BcdGetEngineConfig)(ENGINECONFIG*);
typedef void (WINAPI *PFN_BcdSetScanImageMode)(int);
// 1D scanner IS4813
typedef void (WINAPI *PFN_BcdSetExtraReads)(BAR_TYPE, int);
typedef BOOL (WINAPI *PFN_BcdSetExtraReadsEX)(BAR_TYPE, int);
typedef void (WINAPI *PFN_BcdGetExtraReads)(BAR_TYPE, int*);
typedef void (WINAPI *PFN_BcdSetExtraTime)(BAR_TYPE, int);
typedef BOOL (WINAPI *PFN_BcdSetExtraTimeEX)(BAR_TYPE, int);
typedef void (WINAPI *PFN_BcdGetExtraTime)(BAR_TYPE, int*);
typedef void (WINAPI *PFN_BcdSetStitchingEnable)(BOOL);
typedef void (WINAPI *PFN_BcdSetAllowNonProportional)(BOOL);
typedef void (WINAPI *PFN_BcdSetStitchingLevel)(DWORD);
typedef void (WINAPI *PFN_BcdSetRoundingUncertaintyLevel)(DWORD);
// other functions
typedef LPWSTR (WINAPI *PFN_BcdGetModelName)(void);
typedef LPWSTR (WINAPI *PFN_BcdGetModelSerialNumber)(void);
// Beep level settings...
// BCD0.dll v2.4 | BCD1.dll v2.4 | BCD2.dll v1.3
// BCDCore.dll v1.4 | ScanConfig.cpl v1.3
typedef DWORD (WINAPI *PFN_BcdGetBeepScale)(PBCD_BEEP_LEVEL_SETTING);
typedef DWORD (WINAPI *PFN_BcdSetBeepScale)(PBCD_BEEP_LEVEL_SETTING);
typedef void (WINAPI *PFN_BcdEnableVibrator)(BOOL);
typedef void (WINAPI *PFN_BcdSetVibratorInterval)(DWORD, DWORD);
// for C#
typedef POCR_FLAG (WINAPI *PFN_BcdGetOCRFlagEx)(void);
// end function's pointer define section ///////////////////////////////////////////////////////
typedef void (WINAPI *PFN_BcdDEBUG)(BOOL);
// start function declaration section ///////////////////////////////////////////////////////
// 1D&2D scanner
BCDCORE_API HANDLE BcdOpen(void);
BCDCORE_API void BcdClose(void);
BCDCORE_API void BcdEnable(BOOL bEnable);
BCDCORE_API BOOL BcdIsEnabled(void);
BCDCORE_API void BcdSetHWND(HWND hWnd);
BCDCORE_API void BcdSetTerminator(BYTE cTerminator);
BCDCORE_API void BcdSetResultType(DWORD dwType);
BCDCORE_API BYTE BcdGetResultType(void);
BCDCORE_API void BcdEnableBeep(BOOL bBeep);
BCDCORE_API void BcdEnableLED(BOOL bLED);
BCDCORE_API void BcdEnablePrefix(BOOL bPrefix);
BCDCORE_API BOOL BcdSetPrefix(TCHAR *szPrefix);
BCDCORE_API void BcdGetPrefix(TCHAR *szPrefix);
BCDCORE_API void BcdEnablePostfix(BOOL bPostfix);
BCDCORE_API BOOL BcdSetPostfix(TCHAR *szPostfix);
BCDCORE_API void BcdGetPostfix(TCHAR *szPostfix);
BCDCORE_API void BcdSetTrigTimeout(DWORD dwSeconds);
BCDCORE_API void BcdEanbleAutoScan(BOOL bAutoScan);
BCDCORE_API void BcdSetAutoScanInterval(DWORD dwInterval);
BCDCORE_API void BcdSetConfig(PBCD_CONFIG pbcdConfig);
BCDCORE_API void BcdGetConfig(PBCD_CONFIG pbcdConfig);
BCDCORE_API LPWSTR BcdGetBarTypeString(BAR_TYPE barType);
BCDCORE_API BOOL BcdGetEnableLength(BAR_TYPE barType);
BCDCORE_API void BcdGetBarLength(BAR_TYPE barType, int* puMin, int* puMax);
BCDCORE_API BOOL BcdSetBarLength(BAR_TYPE barType, int uMin, int uMax);
BCDCORE_API void BcdTransmitBarID(BOOL bTransmit);
BCDCORE_API BYTE BcdGetBarID(BAR_TYPE barType);
BCDCORE_API void BcdSetBarID(BAR_TYPE barType, BYTE barID);
BCDCORE_API void BcdSetDefault(void);
BCDCORE_API void BcdEnableBarcode(BAR_TYPE barType, BOOL bEnable);
BCDCORE_API BOOL BcdEnableALLBarcode(BOOL bEnable);
BCDCORE_API BOOL BcdIsBarcodeEnabled(BAR_TYPE barType);
BCDCORE_API void BcdSetBarFlag(BAR_TYPE barType, int nIndex, BOOL bEnable);
BCDCORE_API PBAR_FLAG BcdGetBarFlagArrayPtr(BAR_TYPE barType);
BCDCORE_API void BcdTrigTurnOn(BOOL bTrigger);
BCDCORE_API PSCAN_RESULT BcdGetResult(void);
BCDCORE_API LPWSTR BcdGetString(void);
BCDCORE_API BAR_TYPE BcdGetBarType(void);
BCDCORE_API UINT BcdGetLength(void);
BCDCORE_API void BcdGetVersion(TCHAR *szVersion);
BCDCORE_API void BcdTriggerEnable(BOOL bTrigger);
BCDCORE_API BOOL BcdIsTriggerEnabled(void);
BCDCORE_API void BcdSetContinuousMode(BOOL bEnable);
BCDCORE_API BOOL BcdGetContinuousMode(void);
// 1D scanner SE955
BCDCORE_API void BcdSetLinearSecurityLevel(BYTE btLevel);
BCDCORE_API void BcdSetBidirectionalMode(BOOL bBidirectional);
// 2D scanner IT5300
BCDCORE_API void BcdGetDefaultBarLength(BAR_TYPE barType, int* puMin, int* puMax);
BCDCORE_API OCR_FLAG BcdGetOCRFlag(void);
BCDCORE_API void BcdSetOCRFlag(OCR_FLAG OCRFlag);
BCDCORE_API void BcdGetDecoderVersion(TCHAR *szVersion);
BCDCORE_API void BcdGetApiVersion(TCHAR *szVersion);
BCDCORE_API void BcdGetScanDriverVersion(TCHAR *szVersion);
BCDCORE_API void BcdSetSCANPCLK(DWORD PCLK);
BCDCORE_API BOOL BcdIs24MHzPCLK(void);
BCDCORE_API void BcdEnableCenterWindow(BOOL bUse);
BCDCORE_API void BcdSetDecodeMode(BYTE btMode);
BCDCORE_API void BcdSetDelayDecoding(DWORD btDelay);
BCDCORE_API HBITMAP BcdCreateDIBSection(BmpFormat* pBmp, LONG lWidth, LONG lHeight);
BCDCORE_API void BcdDestroyDIBSection(HBITMAP hBitmap);
BCDCORE_API BOOL BcdGetCaptureImage(PBYTE pImageBuffer, DWORD * pImageSize);
BCDCORE_API BOOL BcdImageStreamInit(void);
BCDCORE_API BOOL BcdImageStreamStart(void);
BCDCORE_API BOOL BcdImageStreamRead(unsigned char * pImageBuffer, DWORD * pdwSize);
BCDCORE_API BOOL BcdImageStreamStop(void);
BCDCORE_API BOOL BcdAimerOn(BOOL enable);
BCDCORE_API BOOL BcdIlluminationOn(BOOL enable);
BCDCORE_API BOOL BcdSetScanLightsMode(SCANLIGHTSMODE mode);
BCDCORE_API BOOL BcdGetEngineConfig(ENGINECONFIG * pEngineConfig);
BCDCORE_API void BcdSetScanImageMode(int nMode);
// 1D scanner IS4813
BCDCORE_API void BcdSetExtraReads(BAR_TYPE barType, int nExtraRead);
BCDCORE_API BOOL BcdSetExtraReadsEX(BAR_TYPE barType, int nExtraRead);
BCDCORE_API void BcdGetExtraReads(BAR_TYPE barType, int* nExtraRead);
BCDCORE_API void BcdSetExtraTime(BAR_TYPE barType, int nExtraTime);
BCDCORE_API BOOL BcdSetExtraTimeEX(BAR_TYPE barType, int nExtraTime);
BCDCORE_API void BcdGetExtraTime(BAR_TYPE barType, int* nExtraTime);
BCDCORE_API void BcdSetStitchingEnable(BOOL bStitching);
BCDCORE_API void BcdSetAllowNonProportional(BOOL bAllow);
BCDCORE_API void BcdSetStitchingLevel(DWORD dwLevel);
BCDCORE_API void BcdSetRoundingUncertaintyLevel(DWORD dwLevel);
// other functions
BCDCORE_API LPWSTR BcdGetModelName(void);
BCDCORE_API LPWSTR BcdGetModelSerialNumber(void);
// Beep level settings...
// BCD0.dll v2.4 | BCD1.dll v2.4 | BCD2.dll v1.3
// BCDCore.dll v1.4 | ScanConfig.cpl v1.3
BCDCORE_API DWORD BcdGetBeepScale(PBCD_BEEP_LEVEL_SETTING);
BCDCORE_API DWORD BcdSetBeepScale(PBCD_BEEP_LEVEL_SETTING);
BCDCORE_API void BcdEnableVibrator(BOOL bVibrate);
BCDCORE_API void BcdSetVibratorInterval(DWORD dwSuccessInterval, DWORD dwFailInterval);
// for C#
BCDCORE_API POCR_FLAG BcdGetOCRFlagEx(void);
// end function declaration section ///////////////////////////////////////////////////////
A to jest main:
// asdkapppa.cpp : Defines the entry point for the application.
//
#include "stdafx.h"
#include "asdkapppa.h"
#include <windows.h>
#include <commctrl.h>
#define MAX_LOADSTRING 100
// Global Variables:
HINSTANCE g_hInst; // current instance
#ifdef SHELL_AYGSHELL
HWND g_hWndMenuBar; // menu bar handle
#else // SHELL_AYGSHELL
HWND g_hWndCommandBar; // command bar handle
#endif // SHELL_AYGSHELL
HWND hwnd,g_hPrzycisk,hEdit,hListBox;
// Forward declarations of functions included in this code module:
ATOM MyRegisterClass(HINSTANCE, LPTSTR);
BOOL InitInstance(HINSTANCE, int);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
#ifndef WIN32_PLATFORM_WFSP
INT_PTR CALLBACK About(HWND, UINT, WPARAM, LPARAM);
#endif // !WIN32_PLATFORM_WFSP
int WINAPI WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPTSTR lpCmdLine,
int nCmdShow)
{
g_hPrzycisk = CreateWindowEx( 0, L"BUTTON", L"Zapisz", WS_CHILD | WS_VISIBLE,
100, 150, 60, 30, hwnd, NULL, hInstance, NULL );
hEdit = CreateWindowEx( 0,
L"EDIT",
NULL,
WS_CHILD | WS_VISIBLE | WS_BORDER,
5, 10, 10, 5,
hwnd,
NULL,
hInstance,
NULL );
//15, 150, 60, 30,
SetWindowText( hEdit,
L"Wpisz" );
DWORD dlugosc = GetWindowTextLength( hEdit );
LPWSTR Bufor =( LPWSTR ) GlobalAlloc( GPTR, dlugosc + 1 );
GetWindowTextW( hEdit,
Bufor,
dlugosc + 1 );
hListBox = CreateWindowEx( WS_EX_CLIENTEDGE,
L"LISTBOX",
NULL,
WS_CHILD | WS_VISIBLE | WS_BORDER |
WS_VSCROLL | ES_MULTILINE | ES_AUTOVSCROLL,
15, 15, 150, 100,
hwnd,
NULL,
hInstance,
szScanValue );
MSG msg;
// Perform application initialization:
if (!InitInstance(hInstance, nCmdShow))
{
return FALSE;
}
#ifndef WIN32_PLATFORM_WFSP
HACCEL hAccelTable;
hAccelTable = LoadAccelerators( hInstance,
MAKEINTRESOURCE(IDC_ASDKAPPPA));
#endif // !WIN32_PLATFORM_WFSP
// Main message loop:
while (GetMessage(&msg, NULL, 0, 0))
{
#ifndef WIN32_PLATFORM_WFSP
if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
#endif // !WIN32_PLATFORM_WFSP
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
return (int) msg.wParam;
}
//
// FUNCTION: MyRegisterClass()
//
// PURPOSE: Registers the window class.
//
// COMMENTS:
//
ATOM MyRegisterClass(HINSTANCE hInstance, LPTSTR szWindowClass)
{
WNDCLASS wc;
wc.style = CS_HREDRAW | CS_VREDRAW;
wc.lpfnWndProc = WndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = hInstance;
wc.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_ASDKAPPPA));
wc.hCursor = 0;
wc.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
wc.lpszMenuName = 0;
wc.lpszClassName = szWindowClass;
return RegisterClass(&wc);
}
//
// FUNCTION: InitInstance(HINSTANCE, int)
//
// PURPOSE: Saves instance handle and creates main window
//
// COMMENTS:
//
// In this function, we save the instance handle in a global variable and
// create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
HWND hWnd;
TCHAR szTitle[MAX_LOADSTRING]; // title bar text
TCHAR szWindowClass[MAX_LOADSTRING]; // main window class name
g_hInst = hInstance; // Store instance handle in our global variable
#if defined(WIN32_PLATFORM_PSPC) || defined(WIN32_PLATFORM_WFSP)
// SHInitExtraControls should be called once during your application's initialization to initialize any
// of the device specific controls such as CAPEDIT and SIPPREF.
SHInitExtraControls();
#endif // WIN32_PLATFORM_PSPC || WIN32_PLATFORM_WFSP
LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
LoadString(hInstance, IDC_ASDKAPPPA, szWindowClass, MAX_LOADSTRING);
#if defined(WIN32_PLATFORM_PSPC) || defined(WIN32_PLATFORM_WFSP)
//If it is already running, then focus on the window, and exit
hWnd = FindWindow(szWindowClass, szTitle);
if (hWnd)
{
// set focus to foremost child window
// The "| 0x00000001" is used to bring any owned windows to the foreground and
// activate them.
SetForegroundWindow((HWND)((ULONG) hWnd | 0x00000001));
return 0;
}
#endif // WIN32_PLATFORM_PSPC || WIN32_PLATFORM_WFSP
if (!MyRegisterClass(hInstance, szWindowClass))
{
return FALSE;
}
hWnd = CreateWindow(szWindowClass, szTitle, WS_VISIBLE,
CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hInstance, NULL);
if (!hWnd)
{
return FALSE;
}
#ifdef WIN32_PLATFORM_PSPC
// When the main window is created using CW_USEDEFAULT the height of the menubar (if one
// is created is not taken into account). So we resize the window after creating it
// if a menubar is present
if (g_hWndMenuBar)
{
RECT rc;
RECT rcMenuBar;
GetWindowRect(hWnd, &rc);
GetWindowRect(g_hWndMenuBar, &rcMenuBar);
rc.bottom -= (rcMenuBar.bottom - rcMenuBar.top);
MoveWindow(hWnd, rc.left, rc.top, rc.right-rc.left, rc.bottom-rc.top, FALSE);
}
#endif // WIN32_PLATFORM_PSPC
ShowWindow(hWnd, nCmdShow);
UpdateWindow(hWnd);
#ifndef SHELL_AYGSHELL
if (g_hWndCommandBar)
{
CommandBar_Show(g_hWndCommandBar, TRUE);
}
#endif // !SHELL_AYGSHELL
return TRUE;
}
//
// FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
// PURPOSE: Processes messages for the main window.
//
// WM_COMMAND - process the application menu
// WM_PAINT - Paint the main window
// WM_DESTROY - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int wmId, wmEvent;
PAINTSTRUCT ps;
HDC hdc;
#if defined(SHELL_AYGSHELL) && !defined(WIN32_PLATFORM_WFSP)
static SHACTIVATEINFO s_sai;
#endif // SHELL_AYGSHELL && !WIN32_PLATFORM_WFSP
switch (message)
{
case WM_COMMAND:
wmId = LOWORD(wParam);
wmEvent = HIWORD(wParam);
// Parse the menu selections:
switch (wmId)
{
#ifndef WIN32_PLATFORM_WFSP
case IDM_HELP_ABOUT:
DialogBox(g_hInst, (LPCTSTR)IDD_ABOUTBOX, hWnd, About);
break;
#endif // !WIN32_PLATFORM_WFSP
#ifndef SHELL_AYGSHELL
case IDM_FILE_EXIT:
DestroyWindow(hWnd);
break;
#endif // !SHELL_AYGSHELL
#ifdef WIN32_PLATFORM_WFSP
case IDM_OK:
DestroyWindow(hWnd);
break;
#endif // WIN32_PLATFORM_WFSP
#ifdef WIN32_PLATFORM_PSPC
case IDM_OK:
SendMessage (hWnd, WM_CLOSE, 0, 0);
break;
#endif // WIN32_PLATFORM_PSPC
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
break;
case WM_CREATE:
#ifndef SHELL_AYGSHELL
g_hWndCommandBar = CommandBar_Create(g_hInst, hWnd, 1);
CommandBar_InsertMenubar(g_hWndCommandBar, g_hInst, IDR_MENU, 0);
CommandBar_AddAdornments(g_hWndCommandBar, 0, 0);
#endif // !SHELL_AYGSHELL
#ifdef SHELL_AYGSHELL
SHMENUBARINFO mbi;
memset(&mbi, 0, sizeof(SHMENUBARINFO));
mbi.cbSize = sizeof(SHMENUBARINFO);
mbi.hwndParent = hWnd;
mbi.nToolBarId = IDR_MENU;
mbi.hInstRes = g_hInst;
if (!SHCreateMenuBar(&mbi))
{
g_hWndMenuBar = NULL;
}
else
{
g_hWndMenuBar = mbi.hwndMB;
}
#ifndef WIN32_PLATFORM_WFSP
// Initialize the shell activate info structure
memset(&s_sai, 0, sizeof (s_sai));
s_sai.cbSize = sizeof (s_sai);
#endif // !WIN32_PLATFORM_WFSP
#endif // SHELL_AYGSHELL
break;
case WM_PAINT:
hdc = BeginPaint(hWnd, &ps);
// TODO: Add any drawing code here...
EndPaint(hWnd, &ps);
break;
case WM_DESTROY:
#ifndef SHELL_AYGSHELL
CommandBar_Destroy(g_hWndCommandBar);
#endif // !SHELL_AYGSHELL
#ifdef SHELL_AYGSHELL
CommandBar_Destroy(g_hWndMenuBar);
#endif // SHELL_AYGSHELL
PostQuitMessage(0);
break;
#if defined(SHELL_AYGSHELL) && !defined(WIN32_PLATFORM_WFSP)
case WM_ACTIVATE:
// Notify shell of our activate message
SHHandleWMActivate(hWnd, wParam, lParam, &s_sai, FALSE);
break;
case WM_SETTINGCHANGE:
SHHandleWMSettingChange(hWnd, wParam, lParam, &s_sai);
break;
#endif // SHELL_AYGSHELL && !WIN32_PLATFORM_WFSP
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return 0;
}
#ifndef WIN32_PLATFORM_WFSP
// Message handler for about box.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message)
{
case WM_INITDIALOG:
#ifndef SHELL_AYGSHELL
RECT rectChild, rectParent;
int DlgWidth, DlgHeight; // dialog width and height in pixel units
int NewPosX, NewPosY;
// trying to center the About dialog
if (GetWindowRect(hDlg, &rectChild))
{
GetClientRect(GetParent(hDlg), &rectParent);
DlgWidth = rectChild.right - rectChild.left;
DlgHeight = rectChild.bottom - rectChild.top ;
NewPosX = (rectParent.right - rectParent.left - DlgWidth) / 2;
NewPosY = (rectParent.bottom - rectParent.top - DlgHeight) / 2;
// if the About box is larger than the physical screen
if (NewPosX < 0) NewPosX = 0;
if (NewPosY < 0) NewPosY = 0;
SetWindowPos(hDlg, 0, NewPosX, NewPosY,
0, 0, SWP_NOZORDER | SWP_NOSIZE);
}
#endif // !SHELL_AYGSHELL
#ifdef SHELL_AYGSHELL
{
// Create a Done button and size it.
SHINITDLGINFO shidi;
shidi.dwMask = SHIDIM_FLAGS;
shidi.dwFlags = SHIDIF_DONEBUTTON | SHIDIF_SIPDOWN | SHIDIF_SIZEDLGFULLSCREEN | SHIDIF_EMPTYMENU;
shidi.hDlg = hDlg;
SHInitDialog(&shidi);
}
#endif // SHELL_AYGSHELL
return (INT_PTR)TRUE;
case WM_COMMAND:
#ifndef SHELL_AYGSHELL
if ((LOWORD(wParam) == IDOK) || (LOWORD(wParam) == IDCANCEL))
#endif // !SHELL_AYGSHELL
#ifdef SHELL_AYGSHELL
if (LOWORD(wParam) == IDOK)
#endif
{
EndDialog(hDlg, LOWORD(wParam));
return (INT_PTR)TRUE;
}
break;
case WM_CLOSE:
EndDialog(hDlg, message);
return (INT_PTR)TRUE;
}
return (INT_PTR)FALSE;
}
#endif // !WIN32_PLATFORM_WFSP
I mam małą prośbę, jeżeli coś mam źle, lub byście napisali inaczej, to pisać propozycje.