Visual C++ 2005 wgranie na urządzenie programu

0

Witam panowie, mam pytanie.
Mam urządzenie połączone z komputerem, i program który napisałem i nie ma błędów chcę zgrać na urządzenie.
Problem następującej treści.

Chcę zgrać programik, i chciałem pełen radości nacisnąć "Connect to device".
NIESTETY.
ta opcja jest zablokowana.
Przez Device emulator manager też nie pójdzie, ponieważ wybierając emulator i chcąc nacisnąć "Connect" ta opcja też jest zablokowana.

Panowie jak odblokować ten syf.
Jest to wersja Proffessional.

0

Czemu 2005? Bo programuje na WIN CE, tak tak wiem, stare, wyginęło, ale takie dostałem zadanie to robie.

Kodzik cacy bo jak robie build to 0 errorów. Ale żeby sprawdzić to niee... bo po co, Connect to device zablokowane...

0

A co to za urządzenie i jak je podłączasz? Obstawiam, że Visual Studio nie wykrywa tego podłączenia, może to być np. kwestia sterowników albo jakichś ustawień, i dlatego "connect" Ci nie działa.
Masz wszystkie aktualizacje do Visual Studio zainstalowane?

0

Jak zrobiłem by wyszukał aktualizacje to powiedziało, że nie ma aktualizacji.

Urządzenie to Scanpal 5100. Podłączone do stacji dokującej, przez USB (i oczywiście do prądu).

Komputer urządzenie widzi, ponieważ mogę np. zgrać zdjęcie tak jak się zgrywa na telefon na zasadzie kopiuj wklej, ale nie mogę przez program Visual c++ 2005.

Nie mogę tak zgrać też programu(copy paste) bo nie mam exe/cab wygenerowanego(btw. nie wiem jak to zrobić).

0

Zauwazylem ze jak robie attach device, to wywala mi błąd:

PB Debugger Debugger could not initialize connection.

Any idea?

0

To build solucji nie produkuje plików na Windowsa CE? Kiedyś się tym bawiłem i o ile dobrze pamiętam, to działało.
Masz dobre SDK zainstalowane?

0

Ciekawe, że takie urządzenie kosztuje ponad 1.5 klocka

0

na starszym windowsie (xp, 7) potrzebujesz ActiveSync. To, że widzisz dysk jako USB to o niczym nie świadczy.

0

A mam Windows 10, to co, maszyna wirtualna i windows XP?

Mam jakieś Standard SDK 5.0 win ce. Myślisz, że złe SDK? :<

0

z 10 nie pomogę - unikam jak mogę. Na W8.1 jest "centrum obsługi urządzeń z systemem windows mobile". Jak podłączę coś z WM 5 albo WM 6 to mi się pokazuje właśnie takie okno
Centrum obsługi urządzeń z systemem Windows Mobile.png
i dopiero jak to mi wyskoczy to mogę się z urządzeniem z VS połączyć.

0

Ale takie okno mam, i też po lewej na dole mam napisane "Połączono". A mimo to, nie mogę się połączyć..

0

Dobra, poradziłem sobie z tym problemem. Okazało się, że SDK było nieodpowiednie. Gapa ze mnie :<.
Ale teraz mam inny problem z kodem. 1 malutki error. Jak chcecie żeby założyć to w innym temacie, to mogę tak zrobić,ale do rzeczy.
W pliku: BCDApi.h jest zmienna szScanValue, która ma w sobie zawartość zeskanowanego kodu.
I jak chcę do maina wkleić do ListBoxa, tą zawartość(zmienną), to wypisało błąd, że jest to undeclared.
Od razu mówię: dołączyłem plik do maina, i mean: #include "BCDApi.h".
Ktoś, coś?

0

W pliku: BCDApi.h jest zmienna szScanValue

A jest? Patrzyłeś?

wypisało błąd, że jest to undeclared.

Może jest pod jakimś #ifdefem, którego nie masz zdefiniowanego?

0

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.

0
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;

Jedyne szScanValue to pole w strukturze SCAN_RESULT, a nie zmienna globalna.

0

Słuszna uwaga, nie wiem czemu wcześniej tak myślałem >.<

Dziękuję bardzo za pomoc.

Ostatnie pytanie do tematu.

Ostatnie.

Jak napiszę MessageBox to pojawia się MessageBox.

Ale jak kod który zapodałem wyżej (main) to mam białe pole. Jakbym otworzył pusty folder.

Może ktoś mnie naprowadzić czemu tak jest?

0

Mówię tu oczywiście o ekranie urządzenia, bo jak odpale kodzik na PC w sensie samo Winapi to eleganckie okienko mam.

1 użytkowników online, w tym zalogowanych: 0, gości: 1