rattail-palm/src/AppMain.c

/******************************************************************************
 *
 * Copyright (c) 2007, ACCESS Systems Americas, Inc. All Rights Reserved.
 *
 * File: AppMain.c
 *
 *****************************************************************************/

#include <PalmOS.h>

// BCS2 Scanner
#include "BCS2ScannerLib.h"

// Janam Scanner
#include "JanamScnCompatible.h"
#include "ScanMgr.h"

// Rattail App
#include "AppResources.h"
#include "AppMain.h"


/***********************************************************************
 *
 *	Entry Points
 *
 ***********************************************************************/


/***********************************************************************
 *
 *	Internal Constants
 *
 ***********************************************************************/
#define appFileCreator			'RTTL'	// register your own at http://www.palmos.com/dev/creatorid/
#define appVersionNum			0x01
#define appPrefID				0x00
#define appPrefVersionNum		0x01
#define appDbRattail			"Rattail"
#define appDbRattailScan		"Rattail_Scan"

#define COLUMN_BARCODE			0
#define COLUMN_CASES			1
#define COLUMN_UNITS			2


/***********************************************************************
 *
 *	Global Variables
 *
 ***********************************************************************/
UInt16		cardNo = 0;
UInt16		gBcs2RefNum = 0;
Boolean		gBabbo = false;
//UInt16		gNumCols = 3;
//UInt16		gNumRows = 11;
//MemHandle	gHandles[11][3];
Int16		gTopVisibleRecord = -1;


/***********************************************************************
 *
 * FUNCTION:    AppHandleEvent
 *
 * DESCRIPTION: This routine loads form resources and set the event
 *              handler for the form loaded.
 *
 * PARAMETERS:  event  - a pointer to an EventType structure
 *
 * RETURNED:    true if the event has handle and should not be passed
 *              to a higher level handler.
 *
 * REVISION HISTORY:
 *
 *
 ***********************************************************************/
static Boolean AppHandleEvent(EventType* pEvent)
{
	UInt16 		formId;
	FormType* 	pForm;
	Boolean		handled = false;

	if (pEvent->eType == frmLoadEvent) {
		// Load the form resource.
		formId = pEvent->data.frmLoad.formID;
		
		pForm = FrmInitForm(formId);
		FrmSetActiveForm(pForm);

		// Set the event handler for the form.  The handler of the currently
		// active form is called by FrmHandleEvent each time is receives an
		// event.
		switch (formId) {
			case MainForm:
				FrmSetEventHandler(pForm, MainFormHandleEvent);
				break;

			default:
				break;
		}
		handled = true;
	}
	
	return handled;
}


/***********************************************************************
 *
 * FUNCTION:     AppStart
 *
 * DESCRIPTION:  Get the current application's preferences.
 *
 * PARAMETERS:   nothing
 *
 * RETURNED:     Err value errNone if nothing went wrong
 *
 * REVISION HISTORY:
 *
 *
 ***********************************************************************/
static Err AppStart(void)
{
	OpenBCS2Scanner();
	//OpenBabboScanner();
	
	FrmGotoForm(MainForm);
	return errNone;
}


/***********************************************************************
 *
 * FUNCTION:    AppStop
 *
 * DESCRIPTION: Save the current state of the application.
 *
 * PARAMETERS:  nothing
 *
 * RETURNED:    nothing
 *
 ***********************************************************************/
static void AppStop(void)
{
	CloseBCS2Scanner();
	//CloseBabboScanner();

	FrmCloseAllForms();
}


/***********************************************************************
 *
 * FUNCTION:    AppEventLoop
 *
 * DESCRIPTION: This routine is the event loop for the application.  
 *
 * PARAMETERS:  nothing
 *
 * RETURNED:    nothing
 *
 * REVISION HISTORY:
 *
 *
 ***********************************************************************/
static void AppEventLoop(void)
{
	Err			error;
	EventType	event;

	do {
		EvtGetEvent(&event, evtWaitForever);

		if (SysHandleEvent(&event))
			continue;
			
		if (MenuHandleEvent(0, &event, &error))
			continue;
			
		if (AppHandleEvent(&event))
			continue;
			
		FrmDispatchEvent(&event);

	} while (event.eType != appStopEvent);
}


/***********************************************************************
 *
 * FUNCTION:    CloseBabboScanner
 *
 ***********************************************************************/
/*
static void CloseBabboScanner()
{
	if (! gBabbo)
		return;
	
	ScnCmdScanDisable();
	ScnCloseDecoder();	
	gBabbo = false;
}
*/


/***********************************************************************
 *
 * FUNCTION:    CloseBCS2Scanner
 *
 ***********************************************************************/

static void CloseBCS2Scanner()
{
	LocalID		dbId;
	
	if (! gBcs2RefNum)
		return;

	dbId = DmFindDatabase(cardNo, appDbRattail);
	if (dbId)
		SysNotifyUnregister(cardNo, dbId, BCS2BarCodeReadyNotification, 
							sysNotifyNormalPriority);
	BCS2LibClose(gBcs2RefNum);
	SysLibRemove(gBcs2RefNum);
	gBcs2RefNum = 0;
}


/***********************************************************************
 *
 * FUNCTION:    CreateScanDatabase
 *
 ***********************************************************************/

static DmOpenRef CreateScanDatabase()
{
	Err			err;
	LocalID		dbId;
	UInt16		attrs, version;
	DmOpenRef	db;
	
	err = DmCreateDatabase(cardNo, appDbRattailScan, appFileCreator, 'SCAN', false);
	if (err != errNone)
		return NULL;
	
	dbId = DmFindDatabase(cardNo, appDbRattailScan);
	if (dbId == 0)
		return NULL;

	// Set backup flag, version for database.
	attrs = dmHdrAttrBackup;
	version = 1;
	DmSetDatabaseInfo(cardNo, dbId, NULL, &attrs, &version, NULL,
						NULL, NULL, NULL, NULL, NULL, NULL, NULL);
	
	db = DmOpenDatabase(cardNo, dbId, dmModeWrite);
	if (db == 0)
		return NULL;
	
	return db;
}


/***********************************************************************
 *
 * FUNCTION:    DrawCustomTableItem
 *
 ***********************************************************************/

static void DrawCustomTableItem(void* table, Int16 row, Int16 col, RectangleType* bounds)
{
	Char *	text;
	UInt16	size;
	Coord	x;
	
	text = (Char *) TblGetItemPtr(table, row, col);
	if (*text != 0) {
		size = StrLen(text);
		
		if (col == 0) { // barcode
			WinDrawChars(text, size, bounds->topLeft.x, bounds->topLeft.y);
			
		} else { // cases or units
			
			// Only draw value if nonzero.
			if (StrCompareAscii(text, "0") != 0) {
				
				// Draw value right-aligned.
				x = bounds->topLeft.x + bounds->extent.x - FntCharsWidth(text, size);
				WinDrawChars(text, size, x, bounds->topLeft.y);
			}
		}
			
	}
}


/***********************************************************************
 *
 * FUNCTION:    GetActiveFieldId
 *
 ***********************************************************************/

static UInt16 GetActiveFieldId(FormPtr form)
{
	FieldPtr	field;
	UInt16		index;
	
	field = FrmGetActiveField(form);
	if (field == NULL) {
		return NULL;
	}
	
	index = FrmGetObjectIndexFromPtr(form, field);
	if (index == frmInvalidObjectId) {
		return NULL;
	}
	
	return FrmGetObjectId(form, index);
}

/***********************************************************************
 *
 * FUNCTION:    GetCheckedValue
 *
 ***********************************************************************/
 
static Int16 GetCheckedValue(UInt16 objId)
{
	FormPtr		form;
	ControlPtr	check;
	
	form = FrmGetActiveForm();
	check = GetObjectPtrById(form, objId);
	if (check == NULL) {
		return false;
	}
	
	return CtlGetValue(check);
}

/***********************************************************************
 *
 * FUNCTION:    GetObjectPtrById
 *
 ***********************************************************************/

static void *GetObjectPtrById(FormPtr form, UInt16 objId)
{
	UInt16	index;
	
	index = FrmGetObjectIndex(form, objId);
	if (index == frmInvalidObjectId) {
		return NULL;
	}
	
	return FrmGetObjectPtr(form, index);
}


/***********************************************************************
 *
 * FUNCTION:    MainFormDoCommand
 *
 * DESCRIPTION: This routine performs the menu command specified.
 *
 * PARAMETERS:  command  - menu item id
 *
 * RETURNED:    nothing
 *
 * REVISION HISTORY:
 *
 *
 ***********************************************************************/
static Boolean MainFormDoCommand(UInt16 command)
{
	Boolean handled = false;
	FormType * pForm;

	switch (command) {
		case MainOptionsAboutStarterApp:
			pForm = FrmInitForm(AboutForm);
			FrmDoDialog(pForm);					// Display the About Box.
			FrmDeleteForm(pForm);
			handled = true;
			break;

	}
	
	return handled;
}


/***********************************************************************
 *
 * FUNCTION:    MainFormHandleEvent
 *
 * DESCRIPTION: This routine is the event handler for the 
 *              "MainForm" of this application.
 *
 * PARAMETERS:  pEvent  - a pointer to an EventType structure
 *
 * RETURNED:    true if the event has handle and should not be passed
 *              to a higher level handler.
 *
 * REVISION HISTORY:
 *
 *
 ***********************************************************************/
static Boolean MainFormHandleEvent(EventPtr event)
{
	Boolean 	handled = false;
	FormPtr		form;
	TablePtr	table;
	UInt16		objId;
	
	switch (event->eType) {
		
		case frmOpenEvent:
			form = FrmGetActiveForm();
			MainFormInit(form);
			FrmDrawForm(form);
			handled = true;
			break;
			
		case menuEvent:
			handled = MainFormDoCommand(event->data.menu.itemID);
			break;
			
		case sclRepeatEvent:
			if (event->data.sclRepeat.newValue > event->data.sclRepeat.value)
				gTopVisibleRecord += (event->data.sclRepeat.newValue - event->data.sclRepeat.value);
			else {
				gTopVisibleRecord -= (event->data.sclRepeat.value - event->data.sclRepeat.newValue);
			}
			form = FrmGetActiveForm();
			table = GetObjectPtrById(form, MainFormScanRecords);
			MainFormLoadTable(table, false);
			TblRedrawTable(table);
			break;
			
		case keyDownEvent:
			form = FrmGetActiveForm();
			
			// Pressing the ENTER (line feed) key will either advance focus
			// to the next quantity field marked to be stopped upon, or else
			// will validate and store the current data as a new scan record.
			if (event->data.keyDown.chr == 10) { // line feed (ENTER)
				objId = GetActiveFieldId(form);
				if (objId == MainFormBarcode) {
					ProcessScan();
				} else if (objId == MainFormCases) {
					if (GetCheckedValue(MainFormStopOnUnits)) {
						SetFieldFocus(MainFormUnits);
					} else {
						StoreScanData();
					}
				} else if (objId == MainFormUnits) {
					StoreScanData();
				}
				
			// Until I have more to go on, I'm assuming that if a handheld has
			// a BCS2-capable scanner, then it is an Aceeca Meazura, and that its
			// "center" navigational (hardware) key should be used as the scan
			// trigger.
			} else if (event->data.keyDown.chr == MzVCentreKey) {
				if (gBcs2RefNum) {
					if (FrmGetFocus(form) == FrmGetObjectIndex(form, MainFormBarcode))
						BCS2LibTriggerOn(gBcs2RefNum);
				}

			/*				
			// Handle Babbo key
			} else if ((event->data.keyDown.chr & vchrScanKey &&
						(event->data.keyDown.keyCode == scanBitHard1)) ||
						((event->data.keyDown.chr & vchrScanKey) &&
						(event->data.keyDown.keyCode == scanBitHard2))) {
				if (gBabbo) {
					if (ScnCmdStartDecode() != STATUS_OK) {
						SysFatalAlert("Start decode failed!");
					}
					handled = true;
				}
			*/
			}
			break;

		/*
		// This event is passed by Babbo scanners (Janam handhelds).
		case scanDecodeEvent:
			if (gBabbo) { // just to be sure?
				if (ScnCmdBeep(One_Short_Low) != STATUS_OK) {
					SysFatalAlert("Beep failed!");
				}
			}
			break;
		*/
			
		default:
			break;
	}
	
	return handled;
}


/***********************************************************************
 *
 * FUNCTION:    MainFormInit
 *
 ***********************************************************************/

static void MainFormInit(FormPtr form)
{
	TablePtr	table;
	Int16		cols, col, rows, row;
	UInt16		index;
	ControlPtr	ctrl;
	
	table = GetObjectPtrById(form, MainFormScanRecords);
	//TblHasScrollBar(table, true);
	
	cols = TblGetNumberOfColumns(table);
	rows = TblGetNumberOfRows(table);
	for (col = 0; col < cols; col++) {
		TblSetCustomDrawProcedure(table, col, DrawCustomTableItem);
		TblSetColumnUsable(table, col, true);
		for (row = 0; row < rows; row++) {
			TblSetItemStyle(table, row, col, customTableItem);
			TblSetRowUsable(table, row, false);
		}
	}
	
	MainFormLoadTable(table, true);
	TblRedrawTable(table);
	
	index = FrmGetObjectIndex(form, MainFormCases);
	ctrl = FrmGetObjectPtr(form, index);
	FldInsert((FieldPtr) ctrl, "0", 1);
	
	// Unit quantity field is "stoppable" by default, unless the scanner is
	// BCS2-capable, in which case I assume the handheld is an Aceeca Meazura
	// model.  Since this model doesn't have numeric keys, I figure it can't
	// really support counting (yet?).
	if (! gBcs2RefNum) {
		index = FrmGetObjectIndex(form, MainFormStopOnUnits);
		ctrl = FrmGetObjectPtr(form, index);
		CtlSetValue(ctrl, 1);
	}
	
	index = FrmGetObjectIndex(form, MainFormUnits);
	ctrl = FrmGetObjectPtr(form, index);
	FldInsert((FieldPtr) ctrl, "1", 1);
	
	index = FrmGetObjectIndex(form, MainFormBarcode);
	FrmSetFocus(form, index);
}


/***********************************************************************
 *
 * FUNCTION:    MainFormLoadTable
 *
 ***********************************************************************/

static void MainFormLoadTable(TablePtr table, Boolean updateScroll)
{
	DmOpenRef			db;
	UInt16				numRecords;
	MemHandle			recordH;
	RatScanDbRecord*	recordP;
	UInt16				rows, row, rowId;
	FormPtr				form;
	ScrollBarPtr		scroll;
	
	db = OpenScanDatabase();
	if (db == NULL)
		return;

	numRecords = DmNumRecords(db);
	rows = (numRecords < 12) ? numRecords : 12;
	if (gTopVisibleRecord < 0)
		gTopVisibleRecord = (numRecords > 12) ? (numRecords - 12) : 0;

	for (row = 0; row < rows; row++) {
		rowId = gTopVisibleRecord + row;
		recordH = DmGetRecord(db, rowId);
		recordP = (MemPtr) MemHandleLock(recordH);
		TblSetItemPtr(table, row, 0, &recordP->barcode);
		if (StrCompareAscii(recordP->cases, "0") != 0)
			TblSetItemPtr(table, row, 1, &recordP->cases);
		else
			TblSetItemPtr(table, row, 1, "");
		if (StrCompareAscii(recordP->units, "0") != 0)
			TblSetItemPtr(table, row, 2, &recordP->units);
		else
			TblSetItemPtr(table, row, 2, "");
		MemHandleUnlock(recordH);
		DmReleaseRecord(db, rowId, false);
		TblSetRowID(table, row, rowId);
		TblSetRowUsable(table, row, true);
	}
	
	DmCloseDatabase(db);
	TblMarkTableInvalid(table);
	
	if (updateScroll) {
		form = FrmGetActiveForm();
		scroll = GetObjectPtrById(form, MainFormScroller);
		if (numRecords <= 12)
			SclSetScrollBar(scroll, 0, 0, 0, 0);
		else
			SclSetScrollBar(scroll, gTopVisibleRecord, 0, numRecords - 12, 11);
	}
}


/***********************************************************************
 *
 * FUNCTION:    OpenBabboScanner
 *
 ***********************************************************************/
/*
static Boolean OpenBabboScanner()
{
	Err		err;
	
	if (! ScnIsJanamUnit()) {
		SysFatalAlert("Not a Janam unit!");
		return false;
	}

	err = ScnOpenDecoder();
	if (err) {
		SysFatalAlert("Open decoder failed!");
		return false;
	}
	
	if (ScnCmdScanEnable() != STATUS_OK) {
		SysFatalAlert("Enable scanner failed!");
		ScnCloseDecoder();
		return false;
	}
	
	gBabbo = true;
	return true;
}
*/


/***********************************************************************
 *
 * FUNCTION:    OpenBCS2Scanner
 *
 ***********************************************************************/

static Boolean OpenBCS2Scanner()
{
	Err			err;
	LocalID		dbId;

	err = SysLibLoad('libr', 'BcAp', &gBcs2RefNum);
	if (err) {
		/*
		switch (err) {
			case sysErrLibNotFound:
				SysFatalAlert("BCS2 library not found!");
				break;
			case sysErrNoFreeRAM:
				SysFatalAlert("Out of memory (RAM)!");
				break;
			case sysErrNoFreeLibSlots:
				SysFatalAlert("No free library slots!");
				break;
			default:
				SysFatalAlert("BCS2 library load failed!");
				break;
		}
		*/
		gBcs2RefNum = 0;
		return false;
	}
	
	err = BCS2LibOpen(gBcs2RefNum);
	if (err) {
		/*
		switch (err) {
			case errBCS2MemoryError:
				SysFatalAlert("BCS2 threw memory error");
				break;
			default:
				SysFatalAlert("BCS2 library open failed!");
				break;
		}
		*/
		SysLibRemove(gBcs2RefNum);
		gBcs2RefNum = 0;
		return false;
	}
	
	dbId = DmFindDatabase(cardNo, appDbRattail);
	if (! dbId) {
		/*
		SysFatalAlert("Find database failed!");
		*/
		SysLibRemove(gBcs2RefNum);
		gBcs2RefNum = 0;
		return false;
	}
	
	err = SysNotifyRegister(cardNo, dbId, 
							BCS2BarCodeReadyNotification, NULL,
							sysNotifyNormalPriority, NULL);
	if (err != errNone) {
		/*
		SysFatalAlert("Notify registration failed!");
		*/
		SysLibRemove(gBcs2RefNum);
		gBcs2RefNum = 0;
		return false;
	}
	
	return true;
}


/***********************************************************************
 *
 * FUNCTION:    OpenScanDatabase
 *
 ***********************************************************************/

static DmOpenRef OpenScanDatabase()
{
	LocalID		dbId;
	DmOpenRef	db;
	
	dbId = DmFindDatabase(cardNo, appDbRattailScan);
	if (dbId == 0)
		return CreateScanDatabase();
	
	db = DmOpenDatabase(cardNo, dbId, dmModeWrite);
	if (db == 0)
		return NULL;
	
	return db;
}


/***********************************************************************
 *
 * FUNCTION:    ProcessScan
 *
 ***********************************************************************/
 
static void ProcessScan()
{
	if (GetCheckedValue(MainFormStopOnCases)) {
		SetFieldFocus(MainFormCases);
	} else if (GetCheckedValue(MainFormStopOnUnits)) {
		SetFieldFocus(MainFormUnits);
	}
}


/***********************************************************************
 *
 * FUNCTION:    SetFieldFocus
 *
 ***********************************************************************/
 
static void SetFieldFocus(UInt16 objId)
{
	FormPtr		form;
	UInt16		index;
	FieldPtr	field;
	
	form = FrmGetActiveForm();
	if (form == NULL) {
		return;
	}
	
	index = FrmGetObjectIndex(form, objId);
	if (index == frmInvalidObjectId) {
		return;
	}
	
	field = FrmGetObjectPtr(form, index);
	FldSetSelection(field, 0, FldGetTextLength(field));
	FrmSetFocus(form, index);
}


/***********************************************************************
 *
 * FUNCTION:    StoreScanData
 *
 ***********************************************************************/
 
static Boolean StoreScanData()
{
	FormPtr		form;
	FieldPtr	barcode, cases, units;
	UInt16		fieldIndex;
	UInt32		size, offset;
	DmOpenRef	db;
	UInt16		recordIndex;
	MemHandle	recordH;
	MemPtr		recordP;	
	TablePtr	table;
	UInt16		row;
	
	// Get form and barcode field pointers.
	form = FrmGetActiveForm();
	barcode = GetObjectPtrById(form, MainFormBarcode);
	if (barcode == NULL)
		return false;

	// Set focus to barcode field if empty.
	size = FldGetTextLength(barcode);
	if (size == 0) {
		fieldIndex = FrmGetObjectIndex(form, MainFormBarcode);
		if (fieldIndex != frmInvalidObjectId)
			FrmSetFocus(form, fieldIndex);
		return false;
	}
	
	// Get case and unit field pointers.
	cases = GetObjectPtrById(form, MainFormCases);
	if (cases == NULL)
		return false;
	units = GetObjectPtrById(form, MainFormUnits);
	if (units == NULL)
		return false;
	
	// Open the database and create a new record.
	db = OpenScanDatabase();
	if (db == NULL)
		return false;
	recordIndex = dmMaxRecordIndex;
	recordH = DmNewRecord(db, &recordIndex, sizeof(RatScanDbRecord));
	if (recordH == 0) {
		DmCloseDatabase(db);
		return false;
	}
	
	// Write scan data to the record...
	recordP = MemHandleLock(recordH);
	offset = 0;

	size = FldGetTextLength(barcode);
	DmWrite(recordP, offset, FldGetTextPtr(barcode), size);
	offset += size;
	
	size = 15 - size;
	DmSet(recordP, offset, size, 0);
	offset += size;
	
	size = FldGetTextLength(cases);
	DmWrite(recordP, offset, FldGetTextPtr(cases), size);
	offset += size;

	size = 4 - size;
	DmSet(recordP, offset, size, 0);
	offset += size;
	
	size = FldGetTextLength(units);
	DmWrite(recordP, offset, FldGetTextPtr(units), size);
	offset += size;
	
	size = 4 - size;
	DmSet(recordP, offset, size, 0);
	
	// ...then close the record and database.
	MemHandleUnlock(recordH);
	DmReleaseRecord(db, recordIndex, false);
	DmCloseDatabase(db);
	
	// Redraw the table.
	table = GetObjectPtrById(form, MainFormScanRecords);
	row = TblGetLastUsableRow(table);
	if (row == tblUnusableRow)
		gTopVisibleRecord = 0;
	else if (row == 11)
		gTopVisibleRecord = TblGetRowID(table, 1);
	MainFormLoadTable(table, true);
	TblRedrawTable(table);

	SetFieldFocus(MainFormBarcode);
	return true;
}


/***********************************************************************
 *
 * FUNCTION:    PilotMain
 *
 * DESCRIPTION: This is the main entry point for the application.
 *
 * PARAMETERS:  cmd - word value specifying the launch code. 
 *              cmdPB - pointer to a structure that is associated with the launch code. 
 *              launchFlags -  word value providing extra information about the launch.
 * RETURNED:    Result of launch
 *
 * REVISION HISTORY: 
 *
 *
 ***********************************************************************/
UInt32 PilotMain(UInt16 cmd, MemPtr cmdPBP, UInt16 launchFlags)
{
	Err					error = errNone;
	SysNotifyParamType*	notifyParams = (SysNotifyParamType *) cmdPBP;
	FormPtr		form;
	FieldPtr	barcode;
	MemHandle	barcodeH;
	MemPtr		barcodeP;
	Char *		scancode;

	switch (cmd) {
		case sysAppLaunchCmdNormalLaunch:
			if ((error = AppStart()) == 0) {			
				AppEventLoop();
				AppStop();
			}
			break;
			
		case sysAppLaunchCmdNotify:
			if (notifyParams->notifyType == BCS2BarCodeReadyNotification) {
				scancode = (Char *) notifyParams->notifyDetailsP + 1;
				if (StrCompareAscii(scancode, "NO READ")) { // (means good read)
					form = FrmGetActiveForm();
					barcode = GetObjectPtrById(form, MainFormBarcode);
					barcodeH = FldGetTextHandle(barcode);
					FldSetTextHandle(barcode, NULL);
					if (! barcodeH)
						barcodeH = MemHandleNew(15); // ugh
					barcodeP = MemHandleLock(barcodeH);
					StrCopy((Char *) barcodeP, scancode);
					MemHandleUnlock(barcodeH);
					FldSetTextHandle(barcode, barcodeH);
					FldDrawField(barcode);
					if (GetCheckedValue(MainFormStopOnCases))
						SetFieldFocus(MainFormCases);
					else if (GetCheckedValue(MainFormStopOnUnits))
						SetFieldFocus(MainFormUnits);
					else {
						if (StoreScanData())
							SndPlaySystemSound(sndInfo);
					}
				}
			}
			break;

		default:
			break;
	}
	
	return error;
}