///////////////////////////////////////////////////////////////////////////// // // // PTRobot API Definition // // // // PTRobot is an API to allow third parties to integrate // // Primera disc publishing systems into their application. // // // // // // Copyright (C) 2005-6 Primera Technology Inc. // // // ///////////////////////////////////////////////////////////////////////////// // NOTE: See end of this file for pseudo-code example usage of the PTRobot API /////////////////////////////////////////////////////////////////// // // PTRobot Definitions // /////////////////////////////////////////////////////////////////// #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ #pragma once ////////////////////////////////////////////////// // // Return Values from PTRobot_xxxx API functions // /////////////////////////////////////////////////// #define PTROBOT_OK 0 #define PTROBOT_INTERNAL 500 #define PTROBOT_SEQUENCE 501 #define PTROBOT_INVALID_ROBOT 502 #define PTROBOT_INVALID_DRIVE 503 #define PTROBOT_INVALID_BIN 504 #define PTROBOT_NODRIVES 505 #define PTROBOT_OPENCLOSE_FAILED 506 #define PTROBOT_OVERFLOW 507 #define PTROBOT_NO_PRINTER 508 #define PTROBOT_PRINTFILE_INVALID 509 #define PTROBOT_PRINTAPP_NOT_INSTALLED 510 #define PTROBOT_PRINTFILE_NOT_FOUND 511 #define PTROBOT_PRN_INVALID 512 #define PTROBOT_UNSUPPORTED_OPTION 513 #define PTROBOT_DIRNOTFOUND 514 #define PTROBOT_INVALID_LOCATION 515 #define PTROBOT_MULTDRIVES 516 #define PTROBOT_INVALID_PRINTER_SETTINGS 517 #define PTROBOT_INVALID_DRIVE_POSITION 518 #define PTROBOT_INVALID_ACTION 519 #define PTROBOT_FEATURE_NOT_IMPLEMENTED 520 #define PTROBOT_PRINTAPP_OPEN 521 #define PTROBOT_MISSING_DLL 522 #define PTROBOT_DRIVE_NOT_READY 523 #define PTROBOT_INVALID_MEDIA 524 #define PTROBOT_NO_MEDIA 525 #define PTROBOT_INVALID_LANG 526 #define PTROBOT_INVALID_ERROR 527 #define PTROBOT_BUSY 528 #define PTROBOT_INVALID_EXTENSION 529 /////////////////////////// // // System Errors // (used by PTRobotStatus.dwSystemError) // /////////////////////////// #define SYSERR_NONE 0 #define SYSERR_PTR_TRAY 1 #define SYSERR_CART_CODE 2 #define SYSERR_INPUT_EMPTY 3 #define SYSERR_PTR_COMM 4 #define SYSERR_CLR_EMPTY 5 #define SYSERR_BLK_EMPTY 6 #define SYSERR_BOTH_EMPTY 7 #define SYSERR_PICK 8 #define SYSERR_ARM_MOVE 9 #define SYSERR_CART_MOVE 10 // 11 not used #define SYSERR_INTERNAL_SW 12 #define SYSERR_NO_ROBODRIVES 13 #define SYSERR_OFFLINE 14 #define SYSERR_COVER_OPEN 15 #define SYSERR_PRINTER_PICK 16 #define SYSERR_MULTIPLE_PICK 17 #define SYSERR_MULTIPLEDISCS_IN_PRINTER 18 #define SYSERR_MULTIPLEDISCS_IN_RECORDER 19 #define SYSERR_DROPPED_DISC_RECORDER 20 #define SYSERR_DROPPED_DISC_BIN1 28 #define SYSERR_DROPPED_DISC_BIN2 29 #define SYSERR_DROPPED_DISC_BIN3 30 #define SYSERR_DROPPED_DISC_BIN4 31 #define SYSERR_DROPPED_DISC_BIN5 32 #define SYSERR_DROPPED_DISC_PRINTER 33 #define SYSERR_DROPPED_DISC_REJECT 34 #define SYSERR_DROPPED_DISC_UNKNOWN 35 #define SYSERR_ALIGNNEEDED 36 #define SYSERR_COLOR_INVALID 37 #define SYSERR_BLACK_INVALID 38 #define SYSERR_BOTH_INVALID 39 #define SYSERR_NOCARTS 40 #define SYSERR_K_IN_CMY 41 #define SYSERR_CMY_IN_K 42 #define SYSERR_SWAPPED 43 #define SYSERR_PIGONPRO 44 #define SYSERR_ALIGNFAILED 45 #define SYSERR_DROPPED_DISC_PRINTER_FATAL 46 #define SYSERR_MULTIPLEDISCS_IN_RIGHTBIN 47 #define SYSERR_MULTIPLEDISCS_IN_LEFTBIN 48 #define SYSERR_CLR_EMPTY_FINAL 49 #define SYSERR_BLK_EMPTY_FINAL 50 #define SYSERR_BOTH_EMPTY_FINAL 51 #define SYSERR_WAITING_FOR_PRINTER 52 #define SYSERR_NO_DISC_IN_PRINTER 53 #define SYSERR_BUSY 54 #define SYSERR_PURGE 55 #define SYSERR_DOCK_SENSOR 56 #define SYSERR_ALREADY_PRINTED 57 #define SYSERR_UNKNOWN_HARDWARE 58 #define SYSERR_CARR_SERVO 59 #define SYSERR_CARR_STALL 60 #define SYSERR_PEN_DATA 61 #define SYSERR_PRINT_IMAGE 62 #define SYSERR_AMB_TEMP 63 #define SYSERR_PEN_SHORT 64 #define SYSERR_MODEL_NUM 65 #define SYSERR_BUFF_OVR 66 /////////////////////////// // // System State // (used by PTRobotStatus.dwSystemState) // ////////////////////////// #define SYSSTATE_IDLE 0 #define SYSSTATE_BUSY 1 #define SYSSTATE_ERROR 2 /////////////////////////// // // Robot Type // /////////////////////////// #define ROBOT_DISCPUBLISHER 0 #define ROBOT_DISCPUBLISHERII 1 #define ROBOT_DISCPUBLISHERPRO 2 #define ROBOT_COMPOSERMAX 3 #define ROBOT_RACKMOUNT_DPII 4 #define ROBOT_DISCPUBLISHER_XRP 5 #define ROBOT_DISCPUBLISHER_SE 6 #define ROBOT_DISCPUBLISHERPRO_XI 7 #define ROBOT_DISCPUBLISHER_4100 8 #define ROBOT_DISCPUBLISHER_4100_XRP 9 #define ROBOT_DISCPUBLISHER_4051 10 #define ROBOT_DISCPUBLISHER_SE3 11 #define ROBOT_DISCPUBLISHER_4200 12 #define ROBOT_DISCPUBLISHER_4200_XRP 13 #define ROBOT_DISCPUBLISHER_4052 14 /////////////////////////// // // Bin Auto Use // /////////////////////////// #define BIN_INPUT 0 #define BIN_OUTPUT 1 /////////////////////////// // // Robot Options // /////////////////////////// #define PTOPT_KIOSKMODE 0x00000001 /////////////////////////// // // Robot Actions // /////////////////////////// #define PTACT_ALIGNPRINTER 0x00000001 #define PTACT_IGNOREINKLOW 0x00000002 #define PTACT_DISABLEPWRBUTTON 0x00000004 #define PTACT_REINIT_DRIVES 0x00000008 #define PTACT_IDENTIFY 0x00000010 #define PTACT_CANCELCMD 0x00000020 #define PTACT_ENABLEPWRBUTTON 0x00000040 #define PTACT_RESETSYSTEM 0x00000080 #define PTACT_CHECKDISCS 0x00000100 // Check the number of discs in the bins #define PTACT_CLEANCARTRIDGES 0x00000200 // Clean the cartridges #define PTACT_CALIBRATE_ONE_DISC 0x00000400 // SE, II, Pro: Calibrate for one disc (user must put one disc in each bin). #define PTACT_CHANGE_CARTRIDGE 0x00000800 // SE, II, Pro: Start the cartridge change procedure #define PTACT_END_CARTRIDGE_CHANGE 0x00001000 // SE: End the cartridge change (can close lid also) #define PTACT_SHIP_POSITION 0x00002000 // SE, II, Pro: Move the picker to the shipping position #define PTACT_RESET_LEFT_INK_LEVELS 0x00004000 // II: Clears the ink spits for the LEFT cartridge #define PTACT_RESET_RIGHT_INK_LEVELS 0x00008000 // II: Clears the ink spits for the RIGHT cartridge #define PTACT_ALLOW_NO_CARTRIDGES 0x00010000 // SE, II, Pro: Allows unit to operate non-printing robotics without a cartridge #define PTACT_XI_LIGHT_OFF 0x00020000 #define PTACT_XI_LIGHT_ON 0x00040000 #define PTACT_XI_LIGHT_FLASH 0x00080000 #define PTACT_UNHOOK_PICKER 0x00100000 #define PTACT_AUTOPRINTER_MODE 0x00200000 // DP4100: can perform a faster multiple copy print-only job by calling PTRobot_SetPrintCopies() // prior to calling the print function (e.g. PTRobot_PrintFile()). #define PTACT_FAN_ON 0x00400000 // DP4100: turn on system fan #define PTACT_FAN_OFF 0x00800000 // DP4100: turn off system fan /////////////////////////// // // Print Quality // /////////////////////////// #define PQ_LOW 0 #define PQ_MED 1 #define PQ_BETTER 2 #define PQ_HIGH 3 #define PQ_BEST 4 /////////////////////////// // // Drive Open/Close // /////////////////////////// #define DRIVE_OPEN 0 #define DRIVE_CLOSE 1 /////////////////////////// // // Locations // /////////////////////////// #define LOCATION_AUTO 0 #define LOCATION_PRINTER 100 #define LOCATION_REJECT 200 /////////////////////////// // // Drive Bus Types // /////////////////////////// #define BUSTYPE_USB 0 #define BUSTYPE_1394 1 /////////////////////////// // // Clear Drive // /////////////////////////// #define CLEARDRIVE_NO 0 #define CLEARDRIVE_YES 1 /////////////////////////// // // Languages // /////////////////////////// #define ENGLISH 0 #define JAPANESE 1 #define GERMAN 2 #define FRENCH 3 #define SPANISH 4 #define ITALIAN 5 #define CHINESE 6 // Simplified #define KOREAN 7 #define POLISH 8 #define CHINESE_TRAD 9 // Traditional #define CZECH 10 #define LAST_LANGUAGE CZECH ////////////////////////////// // // Printer Tray Status // ////////////////////////////// #define PRINT_TRAY_IN_WITH_DISC 'D' #define PRINT_TRAY_IN_NO_DISC 'I' #define PRINT_TRAY_OUT 'O' //////////////////////////////// // // Disc Pick Switch Status // //////////////////////////////// #define DISC_PICKER_NO_DISC 'X' #define DISC_PICKER_HAS_DISC 'O' ///////////////////////////////// // // Cartridge Types // ///////////////////////////////// #define CARTRIDGE_NONE 0 #define CARTRIDGE_COLOR 1 #define CARTRIDGE_BLACK 2 #define CARTRIDGE_YELLOW 3 #define CARTRIDGE_CYAN 4 #define CARTRIDGE_MAGENTA 5 #define CARTRIDGE_COLORLOTUS 6 #define CARTRIDGE_RESERVED 7 ///////////////////////////////// // // Cartridges Installed // ///////////////////////////////// #define CARTRIDGE_INSTALLED_NONE 0 #define CARTRIDGE_INSTALLED_COLOR 1 #define CARTRIDGE_INSTALLED_BLACK 2 #define CARTRIDGE_INSTALLED_COLOR_AND_BLACK 3 #define CARTRIDGE_INSTALLED_COLOR_AND_COLOR 4 /////////////////////////////////////////////////////////////////// // // PTRobot Data Structures // /////////////////////////////////////////////////////////////////// /////////////////////////// // // PTDriveInfo Structure // /////////////////////////// typedef struct { HANDLE hDrive; //Drive Handle. TCHAR tszDriveName[132]; //Drive String (reported from drive) TCHAR tszFirmwareVer[40]; //Drive FW version TCHAR tszSerialNum[40]; //Drive Serial Number (bridge) HANDLE hRobot; DWORD dwDriveColumn; //Drive Column (0 based - 0 is leftmost column) DWORD dwDriveRow; //Drive Row (0 based - 0 is the top row) }PTDriveInfo, *pPTDriveInfo; /////////////////////////// // // PTDriveInfo2 Structure // /////////////////////////// typedef struct { PTDriveInfo DriveInfo; // PTDriveInfo structure TCHAR tszDriveSerialNum[40]; // Drive Serial Number }PTDriveInfo2, *pPTDriveInfo2; /////////////////////////// // // PTRobotInfo Structure // /////////////////////////// #define MAX_ROBOT_DRIVES 10 typedef struct { HANDLE hRobot; //Robot Handle TCHAR tszRobotDesc[100]; //Robot Description DWORD dwRobotType; //See "Robot Type" section above DWORD dwNumDrives; //Number of Recorders on this robot DWORD dwNumPrinters; //Number of Printers on this robot (0 or 1) DWORD dwNumBins; //Number of Bins on this robot DWORD dwDriveColumns; //Number of Drive Columns DWORD dwDriveRows; //Number of Drive Rows TCHAR tszRobotFirmware[20]; //String Containing the FW Version of the Robot DWORD dwSupportedOptions; //See "Robot Options" section above DWORD dwSupportedActions; //See "Robot Actions" section above HANDLE hDrives[MAX_ROBOT_DRIVES]; DWORD dwDriveBusType; //BusType of the Drives }PTRobotInfo, *pPTRobotInfo; /////////////////////////// // // PTRobotInfo2 Structure // /////////////////////////// #define MAX_CARTRIDGE_TYPES 8 typedef struct { DWORD dwNumCartridges; //Max Number of cartridges robot can hold DWORD dwCartridgeType[MAX_CARTRIDGE_TYPES]; // First element is left-most cartridge and last element is right-most cartridge // (from the user's viewpoint) // see "Cartridge Types" above DWORD dwFirmware2Code; DWORD dwPGA; DWORD dwModel; DWORD dwUSBSerialNum; DWORD dwMaxDiscsPerBin; // Added Version 1.22 DWORD dwReserved[9]; // reserved for future data }PTRobotInfo2, *pPTRobotInfo2; //To determine the BinLocation 1 represents the leftmost bin on the //duplicator and N represents the rightmost bin (where N is the number //of bins in the robot). /////////////////////////// // // PTRobotStatus Structure // /////////////////////////// typedef struct { DWORD dwSystemState; //See "System State" section above DWORD dwSystemError; //See "System Errors" section above DWORD dwCurrColorSpits; DWORD dwCurrBlackSpits; DWORD dwFullColorSpits; DWORD dwFullBlackSpits; }PTRobotStatus, *pPTRobotStatus; // Cartridge Status Information Values for bCartridgeStatus[] in PTRobotStatus2 below (for Bravo 4100) typedef enum { CARTRIDGE_INFO_STILL_READING, CARTRIDGE_INFO_UNUSED, CARTRIDGE_INFO_MISSING, CARTRIDGE_INFO_INVALID, CARTRIDGE_INFO_COMM_ERROR, CARTRIDGE_INFO_BAD_POSITION, CARTRIDGE_INFO_BAD_INSTALL, CARTRIDGE_INFO_INVALID2, CARTRIDGE_INFO_EMPTY, CARTRIDGE_INFO_EMPTY2, CARTRIDGE_INFO_EMPTY3, CARTRIDGE_INFO_OK // Valid cartridge } CartridgeInfoType; /////////////////////////// // // PTRobotStatus2 Structure // /////////////////////////// #define MAX_BINS 5 #define UNKNOWN_NUM_DISCS 255 #define NO_CARTRIDGE_INSTALLED 0 #define VALID_CARTRIDGE 1 #define INVALID_CARTRIDGE 2 typedef struct { DWORD dwCartridgeTypes; // See "Cartridges Installed" section above DWORD dwNumDiscsInBins[MAX_BINS]; // 0th element is left-most bin (values are UNKNOWN_NUM_DISCS if unknown) DWORD dwTotalPrints; // Total # of prints DWORD dwTotalPicks; // Total # of picks from input bin long lVerticalOffset; // Vertial print offset (300dpi units) - Ver 1.25 updated to long (can be negative) long lHorizontalOffset; // Horizontal print offset (300dpi units) - Ver 1.25 updated to long (can be negative) DWORD dwPrinterTrayStatus; // See "Printer Tray Status" section above DWORD dwDiscPickSwitchStatus; // See "Disc Pick Switch Status" section above DWORD dwCoverBeenOpenedFlag; // set to 1 if cover has been opened DWORD dwCartridgeInstalled[MAX_CARTRIDGE_TYPES]; // 0=not installed. 1=valid cartridge. 2=invalid cartridge (ver 1.22 added) DWORD dwCartridgeNeedsAlign[MAX_CARTRIDGE_TYPES]; // set to TRUE (1) if cartridge needs alignment (ver 1.22 added) DWORD dwSystemStateHW; // actual system state as reported directly from the printer (may be different than dwSystemState in PTRobotStatus) long lYellowInkRemaining; // Yellow % remaining (in ten thousandths of a percent). e.g. 891723 = 89.1723% long lMagentaInkRemaining; // Magenta % remaining (in ten thousandths of a percent). e.g. 891723 = 89.1723% long lCyanInkRemaining; // Cyan % remaining (in ten thousandths of a percent). e.g. 891723 = 89.1723% long lBlackInkRemaining; // Black % remaining (in ten thousandths of a percent). e.g. 891723 = 89.1723% // -BELOW VALUES ONLY VALID FOR DISC PUBLISHER 4100- BYTE bCartridgeStatusYellow; // See CartridgeInfoType above for valid values BYTE bCartridgeStatusMagenta; // See CartridgeInfoType above for valid values BYTE bCartridgeStatusCyan; // See CartridgeInfoType above for valid values BYTE bCartridgeStatusBlack; // See CartridgeInfoType above for valid values DWORD dwReserved[6]; // reserved for future data }PTRobotStatus2, *pPTRobotStatus2; /////////////////////////// // // PTPrinterSettings Structure // /////////////////////////// typedef struct { DWORD dwPrintQuality; //See "Print Quality" section above DWORD dwInnerDiam; //units in .1mm increments (150 - 500) DWORD dwOuterMargin; //units in .1mm increments (0 - 20) }PTPrinterSettings, *pPTPrinterSettings; /////////////////////////// // // PTPrinterSettings2 Structure // /////////////////////////// typedef struct { // NOTE: 0xffff is a special value depending on Get or Set-- // Get: 0xffff means that the setting is not supported // Set: 0xffff means to use the current driver setting DWORD dwPrintQuality; //See "Print Quality" section above DWORD dwInnerDiam; //units in .1mm increments (150 - 500) DWORD dwOuterMargin; //units in .1mm increments (0 - 20) DWORD dwCartridge; // Cartridge type to use. 1=Black 2=Color 3=Color+Black DWORD dwColorMatchType; // Color Rendering type. 0=Best for Graphics 1=Best for Photos DWORD dwColorTable; // Color Table number to use. Valid values: 1-6 DWORD dwSaturation; // Amount of saturation. 0-100 where 100 is full saturation DWORD dwPrintBidi; // Print bi-directionally or not. 0=No 1=Yes DWORD dwRotate180; // Rotate the image 180 degrees or not. 0=No 1=Yes DWORD dwKioskPrintOnly; // Kiosk mode when doing print-only. 0=No 1=Yes DWORD dwReserved[9]; }PTPrinterSettings2, *pPTPrinterSettings2; /////////////////////////// // // PTMediaInfo Structure // /////////////////////////// typedef struct { TCHAR tszMediaID[20]; TCHAR tszMediaType[20]; } PTMediaInfo, *pPTMediaInfo; /////////////////////////// // // PTManufactureInfo Structure // /////////////////////////// typedef struct { TCHAR tszSerialNum[11]; TCHAR tszManufactureDate[12]; DWORD dwFiller[20]; }PTManufactureInfo, *pPTManufactureInfo; //----------------------------------------------------------------- // PTRobot API Prototypes //----------------------------------------------------------------- //***************************************************************** // // PTRobot Initialization Functions // //***************************************************************** /////////////////////////// // // PTRobot_Initialize // // Description: // Function to initialize internal data structures of // the PTRobot module. // Params: // None // Notes: // Return: // PTROBOT_OK if Successful // PTROBOT_INTERNAL if an internal error occurred. // PTROBOT_MISSING_DLL if one of the support DLLs cannot be found // /////////////////////////// DWORD WINAPI PTRobot_Initialize(); /////////////////////////// // // PTRobot_Destroy // // Description: // Function to destroy internal data structures of // the PTRobot module. // Params: // None // Notes: // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // /////////////////////////// DWORD WINAPI PTRobot_Destroy(); /////////////////////////// // // PTRobot_SetupDebugging // // Description: // Function to setup logging in the PTRobot module. We advise that your // application has a "back door" method of turning debugging on. All debugging // is off by default. // Params: // szDbgFile full path to a debug file // dwDbgLvl debug Level (0-5) // 0 = off, 1 = errors, 2 = warnings // 3 = Info, 4 and 5 = more info // szTraceFile full path to a trace file // Notes: // If szDbgFile is NULL then debugging will be turned off. If szTraceFile is // NULL then function tracing will be off. Function tracing just logs the // API function calls including the parameters. // This function should be the very first PTRobot_xxxx function to be called. // Return: // PTROBOT_OK if Successful // PTROBOT_INTERNAL if an internal error occurred // /////////////////////////// DWORD WINAPI PTRobot_SetupDebugging(TCHAR * szDbgFile, DWORD dwDbgLvl, TCHAR * szTraceFile); /////////////////////////// // // PTRobot_EnumRobots // // Description: // Function to enumerate the Robots on the system. // Params: // phRobots points to an array of HANDLEs to store // the Robots found. // pdwNumRobots points to a DWORD containing the number of HANDLEs // in the phRobots array. This value is an input // and an output. The user should specify the size // (number of HANDLEs) of the phRobots array on input. // The value of the pdwNumRobots on output will be the // number of robots found. // // Notes: // Both params will be updated upon successful completion of this // command. phRobots will contain handles to robots connected to // this system. pdwNumRobots will will be updated with the number of // robots found. // Also, note that the hDrives[] array in the PTRobotInfo will not be // valid until PTRobot_EnumDrives is called. // // Return: // PTROBOT_OK if Successful // PTROBOT_INVALID_ROBOT if no robots found // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_OVERFLOW if the number of robots found is > the value in // pdwNumRobots // /////////////////////////// DWORD WINAPI PTRobot_EnumRobots(HANDLE * phRobots, DWORD * pdwNumRobots); /////////////////////////// // // PTRobot_EnumDrives // // Description: // Function to enumerate the drives on the system and // determine which drives are under the control of this // robot. // Params: // hRobot Handle to the robot to enumerate the drives of. // phDrives points to an array of DWORDS to store // the Drives found. // pdwNumDrives points to a DWORD containing the number of HANDLEs // in the phDrives array. This value is an input // and an output. The user should specify the size // (number of HANDLEs) of the phDrives array on input. // The value of the pdwNumDrives on output will be the // number of drives found. // // Notes: // Both params will be updated upon successful completion of this // command. phDrives will contain handles to drives connected to // this system. pdwNumDrives will will be updated with the number of // drives found. // // The format of the drive handles is the following: // // The least significant byte should contain the drive letter, the // other three bytes should contain the SCSI triple. // The drive can be identified by either of these methods. // // For Example: 0x01030044 would identify a drive with: // Host=1, ID = 3, LUN = 0, and a drive letter of "D" // // To identify the same drive the client could pass // down 0x01030000, 0x00000044, or 0x01030044. // // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence or after // PTRobot_EnumDrivesWithList // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // PTROBOT_OVERFLOW if the number of drives found is > the value in // pdwNumDrives // PTROBOT_MULTDRIVES if the module cannot determine which drives are // robotically controlled. The calling application // needs to use PTRobot_SetRoboticDrive to resolve // this error. // /////////////////////////// DWORD WINAPI PTRobot_EnumDrives(HANDLE hRobot, HANDLE * phDrives, DWORD * pdwNumDrives); /////////////////////////// // // PTRobot_EnumDrivesWithList // // Description: // Function to pass down drives enumerated by the calling app for // PTRobot to use in determining which drives are robotically controlled. // This is an alternative function to PTRobot_EnumDrives. // Params: // hRobot Handle to the robot. // phDrives points to an array of HANDLEs that contains the // drive handles of the drives in the system // pdwNumDrives points to a DWORD containing the number of HANDLEs // in the phDrives array. // phRobotDrives points to an array of HANDLEs that contains the // drive handles of the drives contained in this robot. // pdwNumRobotDrives points to a DWORD containing the number of drives // in the phRobotDrives array. // // Notes: // phRobotDrives and pdwNumRobotDrives will be updated upon successful // completion of this command. phRobotDrives will contain // handles to drives contained in the robot. pdwNumRobotDrives will be // updated with the number of drives found. // // The format of the drive handle is the following: // // The least significant byte should contain the drive letter, the // other three bytes should contain the SCSI triple. The drive can // be identified by either of these methods. // // For Example: 0x01030044 would identify a drive with: // Host=1, ID = 3, LUN = 0, and a drive letter of "D" // // To identify the same drive the client could pass down // 0x01030000, 0x00000044, or 0x01030044. // // This function should be called instead of PTRobot_EnumDrives if the // calling application wants to enumerate the drives and have PTRobot // select the Robotically controlled drives from the list the calling // application provides. // // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence or after // PTRobot_EnumDrives // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // PTROBOT_OVERFLOW if the number of robotic drives found is > the value // in pdwDrives // PTROBOT_MULTDRIVES if the module cannot determine which drives are // robotically controlled. // /////////////////////////// DWORD WINAPI PTRobot_EnumDrivesWithList(HANDLE hRobot, HANDLE * phDrives, DWORD * pdwNumDrives, HANDLE * phRobotDrives, DWORD * pdwNumRobotDrives); /////////////////////////// // // PTRobot_SetRoboticDrive // // Description: // Function to set a drive's position within the duplicator when // the PTROBOT_MULTDRIVES error is returned from either of the // EnumDrives functions. // Params: // hRobots Handle to the Robot. // hDrive Handle to the Drive // dwColIndex Index identifying the column that the drive is in. // (0 based where 0 is the left-most column) // dwRowIndex Index identifying the row that the drive is in. // (0 based where 0 is the top row) // Notes: // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // PTROBOT_INVALID_DRIVE if the drive handle is invalid // PTROBOT_INVALID_DRIVE_POSITION if column/row ids are invalid. // /////////////////////////// DWORD WINAPI PTRobot_SetRoboticDrive(HANDLE hRobot, HANDLE hDrive, DWORD dwColIndex, DWORD dwRowIndex); /////////////////////////// // // PTRobot_SetOpenCloseFunction // // Description: // Function to set a calling application provided drive open/close // function. // Params: // pvOpenClose pointer to a function to open and close the drive. // (setting to NULL will cause non-callback open/close // to be used). // Notes: // This function allows the calling application to provide the drive // open/closing functionality through their recording engine. If this // function is not called then the drive will be opened/closed via OS // calls. The function pointed to by the pvOpenClose param should be // defined as follows: // // void OpenCloseDrive(DWORD hDrive, DWORD dwOpen); // // Please see the "Drive Open/Close" definitions above for the dwOpen // param. // // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // /////////////////////////// DWORD WINAPI PTRobot_SetOpenCloseFunction(void * pvOpenClose); /////////////////////////// // // PTRobot_SetRobotOptions // // Description: // Function to set the current robot options. // Params: // hRobot Handle to the robot // dwRobotOptions DWORD containing the options to set. // See "Robot Options" defines above // Notes: // You should call PTRobot_GetRobotOptions to get the current Options // and then set the options you want to change prior to calling // this function. // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // PTROBOT_UNSUPPORTED_OPTION if the option is unsupported on that robot // /////////////////////////// DWORD WINAPI PTRobot_SetRobotOptions(HANDLE hRobot, DWORD dwRobotOptions); /////////////////////////// // // PTRobot_GetRobotOptions // // Description: // Function to get the current robot options. // Params: // hRobot Handle to the robot // pdwRobotOptions points to a DWORD. // See "Robot Options" defines above // Notes: // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // /////////////////////////// DWORD WINAPI PTRobot_GetRobotOptions(HANDLE hRobot, DWORD *pdwRobotOptions); //***************************************************************** // // PTRobot Info/Status Functions // //***************************************************************** /////////////////////////// // // PTRobot_GetDriveInfo // // Description: // Function to get the drive info for a particular // drive handle. // Params: // hDrive Handle to the drive (from EnumDrives) // pDrvInfo points to a PTDriveInfo structure. // Notes: // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_DRIVE if the drive handle is invalid // /////////////////////////// DWORD WINAPI PTRobot_GetDriveInfo(HANDLE hDrive, PTDriveInfo* pDrvInfo); // Adds Drive Serial number in addition to the bridge serial number DWORD WINAPI PTRobot_GetDriveInfo2(HANDLE hDrive, PTDriveInfo2* pDrvInfo2); /////////////////////////// // // PTRobot_GetRobotInfo // // Description: // Function to get the robot info for a particular // robot handle. // Params: // hRobot Handle to the robot (from EnumRobots) // pRobotInfo points to a PTRobotInfo structure. // Notes: // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // /////////////////////////// DWORD WINAPI PTRobot_GetRobotInfo(HANDLE hRobot, PTRobotInfo *pRobotInfo); /////////////////////////// // // PTRobot_GetRobotInfo2 // // Description: // Function to get ADDITIONAL robot info for a particular // robot handle. // Params: // hRobot Handle to the robot (from EnumRobots) // pRobotInfo2 points to a PTRobotInfo structure. // Notes: // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // /////////////////////////// DWORD WINAPI PTRobot_GetRobotInfo2(HANDLE hRobot, PTRobotInfo2 *pRobotInfo2); /////////////////////////// // // PTRobot_GetRobotStatus // // Description: // Function to get the current status for a particular // robot. // Params: // hRobot Handle to the robot (from EnumRobots) // pRobotStatus points to a PTRobotStatus structure. // Notes: // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // /////////////////////////// DWORD WINAPI PTRobot_GetRobotStatus(HANDLE hRobot, PTRobotStatus *pRobotStatus); /////////////////////////// // // PTRobot_GetRobotStatus2 // // Description: // Function to get the Additional current status for a particular // robot. // Params: // hRobot Handle to the robot (from EnumRobots) // pRobotStatus2 points to a PTRobotStatus2 structure. // Notes: // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // PTROBOT_BUSY if no response from robot // /////////////////////////// DWORD WINAPI PTRobot_GetRobotStatus2(HANDLE hRobot, PTRobotStatus2 *pRobotStatus2); /////////////////////////// // // PTRobot_GetManufactureInfo // // Description: // Function to get manufacture info // Params: // hRobot Handle to the robot (from EnumRobots) // pPTManufactureInfo points to a PTManufactureInfo structure. // Notes: // // Return: // PTROBOT_OK if Successful (and fills in pPTManufactureInfo) // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if invalid robot specified // /////////////////////////// DWORD WINAPI PTRobot_GetManufactureInfo( HANDLE hRobot, PTManufactureInfo * pManufactureInfo); //***************************************************************** // // PTRobot Robotic Functions // //***************************************************************** /////////////////////////// // // PTRobot_LoadDrive // // Description: // Function to load a drive from an input location // Params: // hRobot Handle to the robot (from EnumRobots) // hDrive Handle to the drive (from EnumDrives) // dwFromLocation DWORD containing the "from" location // 0 = Auto // 1 = Bin1 (right-most bin) // 2 = Bin2 // ... // 100 = Printer // dwClearDrive Clear drive before loading. // (See Clear Drive section) // // Notes: // Clear drive before loading should be done the first loading. This will // cause the picker to attempt to pick discs out of the drive to determine // if any discs were left in the drive from a previous job. // Notes: // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // PTROBOT_INVALID_DRIVE if the drive handle is invalid // PTROBOT_INVALID_LOCATION if the location is invalid // /////////////////////////// DWORD WINAPI PTRobot_LoadDrive(HANDLE hRobot, HANDLE hDrive, DWORD dwFromLocation, DWORD dwClearDrive); /////////////////////////// // // PTRobot_LoadPrinter // // Description: // Function to load the printer from an input bin location // Params: // hRobot Handle to the robot (from EnumRobots) // dwFromLocation DWORD containing the "from" location // 0 = Auto // 1 = Bin1 (right-most bin) // 2 = Bin2 // ... // // Notes: // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // PTROBOT_NO_PRINTER if the robot doesn't have a printer // PTROBOT_INVALID_LOCATION if the location is invalid // /////////////////////////// DWORD WINAPI PTRobot_LoadPrinter(HANDLE hRobot, DWORD dwFromLocation); /////////////////////////// // // PTRobot_LoadPrinterFromDrive // // Description: // Function to load the printer from a drive // Params: // hRobot Handle to the robot (from EnumRobots) // hDrive Handle to the drive (from EnumDrives) // Notes: // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // PTROBOT_INVALID_DRIVE if the drive handle is invalid // PTROBOT_NO_PRINTER if the robot doesn't have a printer // /////////////////////////// DWORD WINAPI PTRobot_LoadPrinterFromDrive(HANDLE hRobot, HANDLE hDrive); /////////////////////////// // // PTRobot_UnLoadDrive // // Description: // Function to unload the drive to an output position. // Params: // hRobot Handle to the robot (from EnumRobots) // hDrive Handle to the drive (from EnumDrives) // dwToLocation DWORD containing the "to" location // 0 = Auto // 1 = Bin1 (right-most bin) // 2 = Bin2 // ... // 100 = Printer // 200 = Reject // // Notes: // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // PTROBOT_INVALID_DRIVE if the drive handle is invalid // PTROBOT_INVALID_LOCATION if the location is invalid // /////////////////////////// DWORD WINAPI PTRobot_UnLoadDrive(HANDLE hRobot, HANDLE hDrive, DWORD dwToLocation); /////////////////////////// // // PTRobot_UnLoadPrinter // // Description: // Function to unload the printer to an output position. // Params: // hRobot Handle to the robot (from EnumRobots) // dwToLocation DWORD containing the "to" location // 0 = Auto // 1 = Bin1 (right-most bin) // 2 = Bin2 // ... // 200 = Reject // // Notes: // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // PTROBOT_NO_PRINTER if the robot doesn't have a printer // PTROBOT_INVALID_LOCATION if the location is invalid // // /////////////////////////// DWORD WINAPI PTRobot_UnLoadPrinter(HANDLE hRobot, DWORD dwToLocation); /////////////////////////// // // PTRobot_MoveDiscBetweenLocations // // Description: // Function to move disc from one bin to another bin // Params: // hRobot Handle to the robot (from EnumRobots) // dwFromLocation DWORD containing the from location // 1 = Bin1 (right-most bin) // 2 = Bin2 // ... // dwToLocation DWORD containing the "to" location // 1 = Bin1 (right-most bin) // 2 = Bin2 // ... // 100 = Printer // 200 = Reject // // Notes: // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // PTROBOT_INVALID_LOCATION if the location is invalid // /////////////////////////// DWORD WINAPI PTRobot_MoveDiscBetweenLocations(HANDLE hRobot, DWORD dwFromLocation, DWORD dwToLocation); /////////////////////////// // // PTRobot_SetPrintCopies // // Description: // This function is used for a multiple auto-print job. // This function is called each time prior to calling one of the print functions // (e.g. PTRobot_PrintFile() ). The number of copies is set back to 1 after printing // Not all robots support this feature (PTACT_AUTOPRINTER_MODE specifies support) // e.g. Bravo 4100 prints mulitple copies faster with this method. // // // Params: // // Notes: // Return: // PTROBOT_OK if Successful // // /////////////////////////// DWORD WINAPI PTRobot_SetPrintCopies(HANDLE hRobot, DWORD dwCopies ); /////////////////////////// // // PTRobot_PrintFile // // Description: // Function to print a Surething image (.STD), raster image (.JPG, .BMP, .TIF, // etc.), or .PRN file to the printer. // Params: // hRobot Handle to the robot (from EnumRobots) // tszFile File to print (.STD, .PRN, .JPG, .BMP) // // Notes: // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // PTROBOT_NO_PRINTER if the robot doesn't have a printer // PTROBOT_PRN_INVALID if the prn file is not valid for the printer // PTROBOT_PRINTFILE_INVALID if unknown print file // PTROBOT_PRINTFILE_NOT_FOUND if the file doesn't exist (or if Merge file not found) // PTROBOT_PRINTAPP_NOT_INSTALLED if the required print application is not installed. // /////////////////////////// DWORD WINAPI PTRobot_PrintFile(HANDLE hRobot, TCHAR * tszFile, DWORD dwPrintIndex); /////////////////////////// // // PTRobot_PrintFileWithMerge // // Description: // Function to print a Surething .STD file that has Merge Text/Photos. // The Merge Text and/or Photos can be specified in a variable number of // arguments passed into this function. The Surething file should be designed // with the same number of merge strings passed in here. // // Params: // hRobot Handle to the robot (from EnumRobots) // tszFile Surething (.STD) File to print. // dwNumMergeStrings Number of merge strings to follow // ... Variable number of pointers to TCHAR strings // These are the merge strings or photo names (including // path) to be printed. // NOTE: For the strings that follow dwMergeStrings to // be used, the user must have �Set Merge File� within the .STD file // ** Limit each string to 256 characters or less ** // // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // PTROBOT_NO_PRINTER if the robot doesn't have a printer // PTROBOT_PRINTFILE_NOT_FOUND if the file doesn't exist // PTROBOT_PRINTAPP_NOT_INSTALLED if the required print application is not // installed. // PTROBOT_PRINTFILE_INVALID if the filename is not .STD // /////////////////////////// DWORD WINAPI PTRobot_PrintFileWithMerge(HANDLE hRobot, TCHAR * tszFile, DWORD dwNumMergeStrings, ...); /////////////////////////////// // // PTRobot_PrintFileWithMerge2 // // Description: // Function to print a Surething .STD file that has Merge Text/Photos. // The Merge Text and/or Photos MUST be specified BEFORE THIS CALL, by // calling PTRobot_AddMergeFields(). PTRobot_AddMergeFields() must be called // once for every Merge field that is designed into the SureThing file. // Then, this function is called to print the file with the specified Merge data. // // Params: // hRobot Handle to the robot (from EnumRobots) // tszFile Surething (.STD) File to print. // fClearMergeList Whether or not to clear the list of merge strings (or photo names) // that were stored from previous calls to PTRobot_AddMergeFields(). // If doing mutiple discs with the same merge data then set to FALSE. // If merge data will be changing for each disc then set to TRUE. // // NOTE: For this to work, the user must have �Set Merge File� within the .STD file // // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // PTROBOT_NO_PRINTER if the robot doesn't have a printer // PTROBOT_PRINTFILE_NOT_FOUND if the file doesn't exist // PTROBOT_PRINTAPP_NOT_INSTALLED if the required print application is not // installed. // PTROBOT_PRINTFILE_INVALID if the filename is not .STD // ////////////////////////////// DWORD WINAPI PTRobot_PrintFileWithMerge2(HANDLE hRobot, TCHAR * tszFile, BOOL fClearMergeList); DWORD WINAPI PTRobot_PrintFileWithMergeFile(HANDLE hRobot, TCHAR * tszFile, TCHAR * tszMergeFile); /////////////////////////// // // PTRobot_AddMergeFields // // Description: // This function is used in conjuction with PTRobot_PrintMergeFile2() // to print a SureThing file with merge/replaceable text fields (or photos). // DESIGN TIME: // User first designs a SureThing (.STD) file with replaceable Text and/or // photos and then sets the Merge file (using Tools/Set Merge File). // RUN TIME: // This function is called repeatedly, passing in the text you want printed // (and/or the name & path of the photo you want printed). // The number of times this function is called should be equal to the number of // Merge Fields inserted at design time. // Then, call PTRobot_PrintFileWithMerge2() to print the SureThing file, using // the merge fields set with this call. // // Params: // dwAppID Application ID specified by Primera // // Notes: // Return: // PTROBOT_OK if Successful // // /////////////////////////// DWORD WINAPI PTRobot_AddMergeFields(HANDLE hRobot, const TCHAR * tszField ); /////////////////////////// // // PTRobot_ClearMergeList // // Description: // Function to clear the List of Merge strings (or photo names) // that were stored from previous calls to PTRobot_AddMergeFields(). // This function would be used if doing a print preview of a STD file // that has merge fields (ie. using PTRobot_GetSureThingPreview() ). // This function is NOT needed if only printing a SureThing file with merge fields // because PTRobot_PrintFileWithMerge2() has a flag to clear the merge list after printing. // So, the use of this function would be like this: // PTRobot_AddMergeFields() // PTRobot_AddMergeFields()... // PTRobot_GetSureThingPreview() // PTRobot_ClearMergeList() // // NOTE: For this to work, the user must have �Set Merge File� within the .STD file // Params: // hRobot Handle to the robot (from EnumRobots) // Return: // PTROBOT_OK // /////////////////////////// DWORD WINAPI PTRobot_ClearMergeList( HANDLE hRobot ); /////////////////////////// // // PTRobot_GetSureThingPreview // // Description: // Function to get a preview of a SureThing file // Params: // tszSureThingFile The SureThing file to get a preview of // tszOutputFile The file name (including path) of desired output file // (NOTE: must have extension of .JPG, .BMP, or .PNG) // dwResolution Resolution (in DPI) of output file (Valid values: 50-600) // Notes: // 1)This function returns immediately, but the output file may take several seconds // to generate. Caller should keep checking for the output file's existence. // 2)The output file is NOT deleted. Caller is responsible for deleting, if desired. // // Return: // PTROBOT_OK if Successful // PTROBOT_PRINTFILE_INVALID if fails to generate preview // PTROBOT_INVALID_EXTENSION if not a valid output file extension (.JPG, .BMP, .PNG) // // /////////////////////////// DWORD WINAPI PTRobot_GetSureThingPreview(TCHAR * tszSureThingFile, TCHAR * tszOutputFile, DWORD dwResolution); /////////////////////////// // // PTRobot_SetPrinterSettings // // Description: // Function to set some printer driver settings // Params: // hRobot Handle to the robot (from EnumRobots) // pPrinterSettings points to a PTPrinterSettings structure. // // Notes: // If this function is not called the default print settings will be used. This // function will change the system default print settings. // As of Version 1.2.0 the system default print settings will restored after a print // is sent via PTRobot_PrintFile() or PTRobot_PrintFileWithMerge(). // // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // PTROBOT_NO_PRINTER if the robot doesn't have a printer // PTROBOT_INVALID_PRINTER_SETTINGS if the printer settings are invalid // /////////////////////////// DWORD WINAPI PTRobot_SetPrinterSettings(HANDLE hRobot, PTPrinterSettings *pPrinterSettings); /////////////////////////// // // PTRobot_GetPrinterSettings // // Description: // Function to get some printer driver settings // Params: // hRobot Handle to the robot (from EnumRobots) // pPrinterSettings points to a PTPrinterSettings structure. // // Notes: // If this function is not called the default print settings will be used. // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // PTROBOT_NO_PRINTER if the robot doesn't have a printer // /////////////////////////// DWORD WINAPI PTRobot_GetPrinterSettings(HANDLE hRobot, PTPrinterSettings *pPrinterSettings); /////////////////////////// // // PTRobot_SetPrinterSettings2 // // Description: // Function to set additional printer driver settings // Params: // hRobot Handle to the robot (from EnumRobots) // pPrinterSettings2 points to a PTPrinterSettings2 structure. // // Notes: // If this function is not called the default print settings will be used. This // function will change the system default print settings. // As of Version 1.2.0 the system default print settings will restored after a print // is sent via PTRobot_PrintFile() or PTRobot_PrintFileWithMerge(). // // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // PTROBOT_NO_PRINTER if the robot doesn't have a printer // PTROBOT_INVALID_PRINTER_SETTINGS if the printer settings are invalid // /////////////////////////// DWORD WINAPI PTRobot_SetPrinterSettings2(HANDLE hRobot, PTPrinterSettings2 *pPrinterSettings2); /////////////////////////// // // PTRobot_GetPrinterSettings2 // // Description: // Function to get some additional printer driver settings // Params: // hRobot Handle to the robot (from EnumRobots) // pPrinterSettings2 points to a PTPrinterSettings2 structure. // // Notes: // If this function is not called the default print settings will be used. // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // PTROBOT_NO_PRINTER if the robot doesn't have a printer // /////////////////////////// DWORD WINAPI PTRobot_GetPrinterSettings2(HANDLE hRobot, PTPrinterSettings2 *pPrinterSettings2); /////////////////////////// // // PTRobot_KillSystemError // // Description: // Function to kill a system error. // Params: // hRobot Handle to the robot (from EnumRobots) // dwResetPrinter DWORD to notify if the printer should be reset. // 1 = Reset the printer // 0 = do not reset the printer // // Notes: // If there is no system error and dwResetPrinter is set to 1 the // printer will be reset. Otherwise if there is a system error, that error // will be cleared (if possible) and the printer will be reset if the // dwResetPrinter is set to 1. // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // /////////////////////////// DWORD WINAPI PTRobot_KillSystemError(HANDLE hRobot, DWORD dwResetPrinter); /////////////////////////// // // PTRobot_SystemAction // // Description: // Function to instruct the system to perform a specifc action. // Params: // hRobot Handle to the robot (from EnumRobots) // dwAction Action to perform // // Notes: // This function is used to perform a specific function on a // robot. The defined actions and their descriptions are detailed // below. // // Action: // PTACT_ALIGNPRINTER -> Align the Printer (Disc Publisher PRO only) // Description: // This will cause an alignment print to occur on the printer and // this function will return when the alignment is complete. // // Action: // PTACT_IGNOREINKLOW -> Ignore Ink Low (Disc Publisher PRO only) // Description: // This will cause an ink low system error to be ignored. // // Action: // PTACT_DISABLEPWRBUTTON -> Disable Power Button // Description: // This will disable the power button on Disc Publisher II and PRO. // // Action: // PTACT_REINIT_DRIVES -> Re-initialize drives // Description: // PTRobot maintains Registry values for persistent settings including drive // serial numbers. This action will clear the drive serial numbers stored // which will force the user to re-identify the robotically controlled drives. // Action: // PTACT_IDENTIFY -> Identify a robot // Description: // This will cause the robot to do something to visually identify itself // For example the Bravo units will move their printer tray. // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_ROBOT if the robot handle is invalid // PTROBOT_INVALID_ACTION if the robot action is invalid // /////////////////////////// DWORD WINAPI PTRobot_SystemAction(HANDLE hRobot, DWORD dwAction); /////////////////////////// // // PTRobot_OpenCloseDrive // // Description: // Function to open or close a drive // Params: // hDrive Handle to the drive (from EnumDrives) // dwOpen See (Drive Open/Close) section above // (DRIVE_OPEN=0 DRIVE_CLOSE=1) // // Notes: // Return: // PTROBOT_OK if Successful // PTROBOT_SEQUENCE if this command is called out of sequence // PTROBOT_INTERNAL if an internal error occurred // PTROBOT_INVALID_DRIVE if the drive handle is invalid // /////////////////////////// DWORD WINAPI PTRobot_OpenCloseDrive(HANDLE hDrive, DWORD dwOpen ); /////////////////////////// // // PTRobot_GetErrorString // // Description: // Function to get the error string for a specific system // error or PTRobot API Return error. // // Params: // hRobot Robot that the error is on. // dwErrorNum System Error Number // pwszErrorString Error string returned // (Note wide characters. Calling application must // allocate this memory). // dwMaxLength Length of buffer pointed to by pwszErrorString // (number of wide characters) // dwLanguage Language of string to return (See "Languages" // definitions above) // // Notes: // dwErrorNum can be either dwSystemError from PTRobotStatus structure (which is // returned by PTRobot_GetRobotStatus()) or dwErrorNum can be an error returned // from a PTRobot_xxxxx call (e.g. PTROBOT_INVALID_ROBOT). // // // Return: // PTROBOT_OK if Successful // PTROBOT_INVALID_LANG if language is invalid // PTROBOT_INVALID_ERROR if error is invalid // PTROBOT_INTERNAL if buffer is undersized, etc. // /////////////////////////// DWORD WINAPI PTRobot_GetErrorString(HANDLE hRobot, DWORD dwErrorNum, WCHAR * pwszErrorString, DWORD dwMaxLength, DWORD dwLanguage); /////////////////////////// // // PTRobot_GetMediaInfo // // Description: // This function will get information on the media that // is loaded in the drive. // Params: // hDrive Handle to the drive (from EnumDrives) // PTMediaInfo * Media info // // Notes: // Return: // PTROBOT_OK if successful and media is found and the media is valid. // PTROBOT_INVALID_MEDIA if the media is not valid // PTROBOT_NO_MEDIA if no media is found // PTROBOT_INVALID_DRIVE if the drive is not valid // PTROBOT_INTERNAL some other error // /////////////////////////// DWORD WINAPI PTRobot_GetMediaInfo(HANDLE hDrive, PTMediaInfo * pDiscInfo ); /////////////////////////// // // PTRobot_SetApplicationID // // Description: // Function to set the Application ID. // This value is assigned for each application by Primera as needed. // Only applications that require special functionality will require this. // (note most applications will not need this). // // Params: // dwAppID Application ID specified by Primera // // Notes: // Return: // PTROBOT_OK if Successful // PTROBOT_INTERNAL if an internal error occurred // /////////////////////////// DWORD WINAPI PTRobot_SetApplicationID( DWORD dwAppID ); DWORD WINAPI PTRobot_SetRoboticDriveWithoutEnum(HANDLE hRobot, HANDLE hDrive, TCHAR *tszSerial, DWORD dwColIndex, DWORD dwRowIndex, BOOL fProgramFlash); DWORD WINAPI PTRobot_GetDriveSerialFromFlash(HANDLE hRobot, DWORD dwColIndex, DWORD dwRowIndex, TCHAR * tszSerial); //----------------------------------------------------------------- // end of PTRobot API Prototypes //----------------------------------------------------------------- /***************************************************************************** PTRobot Usage: Below is PSUEDO-CODE for how a calling application should use PTRobot to implement robotics into its application. PTRobot_Initialize PTRobot_EnumRobots - if the number of robots is greater than 1 then the calling application will need to provide some logic/ui to determine which robot to use. The app can use PTRobot_GetRobotInfo to get details about each robot. PTRobot_EnumDrives or PTRobot_EnumDrivesWithList - This will cause PTRobot to determine which drives are robotically controlled by enumerating the drives themselves (PTRobot_EnumDrives) or based off a list of drives passed in (PTRobot_EnumDrivesWithList) PTRobot_GetDriveInfo for all drives returned - This will allow the calling app to know which drive is which PTRobot_LoadDrive(Robot, Drive, TRUE) - This will load a disc into the drive from the input bin (should set parameter 3 to TRUE if first round of the job) PTRobot_GetRobotStatus - This would be called in a loop until dwSystemState is set to SYSSTATE_IDLE or SYSSTATE_ERROR. .. Client application will perform operations on the disc in the drive. if the operations are successful PTRobot_LoadPrinterFromDrive(Robo, Drive) PTRobot_GetRobotStatus -See Above- PTRobot_PrintFile(szPrintFile) or PTRobot_PrintFileWithMerge(...) PTRobot_GetRobotStatus -See Above- PTRobot_UnloadPrinter(Robot, 0) PTRobot_GetRobotStatus -See Above- else PTRobot_UnloadDrive(Robot, Drive, 100) PTRobot_GetRobotStatus -See Above- PTRobot_Destroy ***/ #ifdef __cplusplus } #endif