mars_nwe/mars-flaim
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
9ca6ef1b890f01e7cb6c3bf2cc43eb6a95c19010
mars-flaim/flaim/util/fform.cpp
dsandersoremutah c55dab446f Renamed version4 to flaim and version5 to xflaim 
git-svn-id: https://svn.code.sf.net/p/flaim/code/trunk@7 0109f412-320b-0410-ab79-c3e0c5ffbbe6
2006-01-27 21:06:39 +00:00

7547 lines
166 KiB
C++
Raw Blame History

//-------------------------------------------------------------------------
// Desc: FlmForm class
// Tabs: 3
//
// Copyright (c) 1999-2003,2005-2006 Novell, Inc. All Rights Reserved.
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of version 2 of the GNU General Public
// License as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, contact Novell, Inc.
//
// To contact Novell about this file by physical or electronic mail,
// you may find current contact information at www.novell.com
//
// $Id: fform.cpp 12329 2006-01-20 17:49:30 -0700 (Fri, 20 Jan 2006) ahodgkinson $
//-------------------------------------------------------------------------
#include "fform.h"
#include "flaimsys.h"
#define COLUMN_DIFF(uiCol1,uiCol2) \
(FLMUINT)(((uiCol1) <= (uiCol2)) \
? (FLMUINT)((uiCol2) - (uiCol1)) \
: (FLMUINT)((uiCol1) - (uiCol2)))
FSTATIC FLMBOOL flmIsUnsigned(
char * pszEditBuf,
FLMUINT * puiValue,
char * pszErrMsg);
FSTATIC RCODE flintRecEditKeyHook(
F_RecEditor * pRecEditor,
NODE * pCurNd,
FLMUINT uiKeyIn,
void * UserData,
FLMUINT * puiKeyOut);
FSTATIC FLMBOOL pulldownKeyFunc(
FlmPulldownList * pPulldown,
FLMUINT uiKeyIn,
FLMUINT * puiKeyOut,
void * pvAppData);
/*===========================================================================
Desc: Initializes variables
===========================================================================*/
FlmForm::FlmForm()
{
m_pScreen = NULL;
m_pThread = NULL;
m_bMonochrome = FALSE; // Future support
m_pDisplayWindow = NULL;
m_pStatusWindow = NULL;
m_uiRows = 0;
m_uiCols = 0;
m_uiUpperLeftRow = 0;
m_uiUpperLeftColumn = 0;
m_uiBackColor = WPS_BLUE;
m_uiForeColor = WPS_WHITE;
m_uiTopFormRow = 0;
m_pCurObject = NULL;
m_pFirstObject = NULL;
m_pLastObject = NULL;
m_pEventCB = NULL;
m_pvAppData = NULL;
m_bGetKeyStrokes = FALSE;
m_bShowingHelpStatus = FALSE;
m_uiLastTimeBeeped = 0;
m_bValuesChanged = FALSE;
m_bInteracting = FALSE;
m_pszEditBuf = NULL;
m_uiEditBufSize = 0;
m_uiMaxCharsToEnter = 0;
m_uiNumCharsEntered = 0;
m_uiEditColumn = 0;
m_uiEditRow = 0;
m_uiEditWidth = 0;
m_uiEditBufPos = 0;
m_uiEditBufLeftColPos = 0;
}
FlmForm::~FlmForm()
{
FlmFormObject * pFormObject;
FlmFormObject * pNextObject;
// Delete all form objects
pFormObject = m_pFirstObject;
while (pFormObject)
{
pNextObject = pFormObject->getNextObject();
pFormObject->Release();
pFormObject = pNextObject;
if (pFormObject == m_pFirstObject)
{
break;
}
}
// Release the windows
if (m_pDisplayWindow)
{
(void)FTXWinFree( &m_pDisplayWindow);
}
if (m_pStatusWindow)
{
(void)FTXWinFree( &m_pStatusWindow);
}
if (m_pszEditBuf)
{
f_free( &m_pszEditBuf);
}
}
/*===========================================================================
Desc: Initializes variables
===========================================================================*/
RCODE FlmForm::init(
FTX_SCREEN_p pScreen,
FlmThreadContext * pThread,
const char * pszTitle,
FLMUINT uiTitleBackColor,
FLMUINT uiTitleForeColor,
const char * pszHelp,
FLMUINT uiHelpBackColor,
FLMUINT uiHelpForeColor,
FLMUINT uiULX,
FLMUINT uiULY,
FLMUINT uiLRX,
FLMUINT uiLRY,
FLMBOOL bCreateStatusBar,
FLMBOOL bCreateBorder,
FLMUINT uiBackColor,
FLMUINT uiForeColor)
{
RCODE rc = FERR_OK;
FLMUINT uiNumCols;
FLMUINT uiNumRows;
FLMUINT uiStartCol;
// Form must not already have been initialized.
if (m_pDisplayWindow)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
m_pScreen = pScreen;
m_pThread = pThread;
if( !uiLRX && !uiLRY)
{
if( FTXScreenGetSize( pScreen,
&uiNumCols, &uiNumRows) != FTXRC_SUCCESS)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
uiNumRows -= uiULY;
uiNumCols -= uiULX;
}
else
{
uiNumRows = (uiLRY - uiULY) + 1;
uiNumCols = (uiLRX - uiULX) + 1;
}
uiStartCol = uiULX;
if (bCreateStatusBar)
{
uiNumRows -= 2; // Add 2 to account for the status bar
}
// Create the display window of the appropriate size.
if (FTXWinInit( pScreen, uiNumCols,
uiNumRows, &m_pDisplayWindow) != FTXRC_SUCCESS)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
// Position the window on the screen.
m_uiUpperLeftRow = uiULY;
m_uiUpperLeftColumn = uiStartCol;
if (FTXWinMove( m_pDisplayWindow, uiStartCol, uiULY) != FTXRC_SUCCESS)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
// Prevent window from scrolling.
if (FTXWinSetScroll( m_pDisplayWindow, FALSE) != FTXRC_SUCCESS)
{
flmAssert( 0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// Don't wrap lines.
if (FTXWinSetLineWrap( m_pDisplayWindow, FALSE) != FTXRC_SUCCESS)
{
flmAssert( 0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// Input cursor should not be present initially.
if (FTXWinSetCursorType( m_pDisplayWindow,
WPS_CURSOR_INVISIBLE) != FTXRC_SUCCESS)
{
flmAssert( 0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// Set foreground and background color for window.
if (FTXWinSetBackFore( m_pDisplayWindow,
m_bMonochrome ? WPS_BLACK : uiBackColor,
m_bMonochrome ? WPS_WHITE : uiForeColor) != FTXRC_SUCCESS)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
m_uiBackColor = uiBackColor;
m_uiForeColor = uiForeColor;
// Clear the window
if (FTXWinClear( m_pDisplayWindow) != FTXRC_SUCCESS)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
if (bCreateBorder)
{
if (FTXWinDrawBorder( m_pDisplayWindow) != FTXRC_SUCCESS)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
m_uiUpperLeftRow++;
m_uiUpperLeftColumn++;
}
if (pszTitle && *pszTitle)
{
if (FTXWinSetTitle( m_pDisplayWindow, pszTitle,
uiTitleBackColor, uiTitleForeColor) != FTXRC_SUCCESS)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
}
if (pszHelp && *pszHelp)
{
if (FTXWinSetHelp( m_pDisplayWindow, pszHelp,
uiHelpBackColor, uiHelpForeColor) != FTXRC_SUCCESS)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
}
if (bCreateStatusBar)
{
if (FTXWinInit( pScreen, uiNumCols, 2,
&m_pStatusWindow) != FTXRC_SUCCESS)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
if (FTXWinMove( m_pStatusWindow, uiStartCol,
uiULY + uiNumRows) != FTXRC_SUCCESS)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
if (FTXWinSetScroll( m_pStatusWindow, FALSE) != FTXRC_SUCCESS)
{
flmAssert( 0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
if (FTXWinSetCursorType( m_pStatusWindow,
WPS_CURSOR_INVISIBLE) != FTXRC_SUCCESS)
{
flmAssert( 0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
if (FTXWinSetBackFore( m_pStatusWindow,
m_bMonochrome ? WPS_BLACK : WPS_GREEN,
WPS_WHITE) != FTXRC_SUCCESS)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
if (FTXWinClear( m_pStatusWindow) != FTXRC_SUCCESS)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
if (FTXWinOpen( m_pStatusWindow) != FTXRC_SUCCESS)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
}
// Open the display window AFTER the status
// window so it will get the input focus.
if (FTXWinOpen( m_pDisplayWindow) != FTXRC_SUCCESS)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
// Get the actual number of rows and columns that are
// available in the window - must be done after
// setting the border, etc.
if (FTXWinGetCanvasSize( m_pDisplayWindow, &m_uiCols,
&m_uiRows) != FTXRC_SUCCESS)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
m_uiTopFormRow = 0;
refresh();
Exit:
return( rc);
}
/*===========================================================================
Desc: Redisplay the form.
===========================================================================*/
void FlmForm::refresh( void)
{
FlmFormObject * pObject;
// Set foreground and background color for window.
FTXWinSetBackFore( m_pDisplayWindow,
m_bMonochrome ? WPS_BLACK : m_uiBackColor,
m_bMonochrome ? WPS_WHITE : m_uiForeColor);
// Clear the screen
(void)FTXWinClear( m_pDisplayWindow);
// Redisplay all of the items on the screen.
pObject = m_pFirstObject;
while (pObject)
{
displayObject( pObject);
if ((pObject = pObject->getNextObject()) == m_pFirstObject)
break;
}
}
/*===========================================================================
Desc: Sets foreground and background color for an object in the form.
===========================================================================*/
void FlmForm::setObjectColor(
FLMUINT uiObjectId,
FLMUINT uiBackColor,
FLMUINT uiForeColor
)
{
FlmFormObject * pObject;
// Form must be initialized
flmAssert( m_pDisplayWindow != NULL);
// See if we can find the object.
if ((pObject = findObject( uiObjectId)) == NULL)
{
flmAssert( 0);
}
else
{
// Set the foreground and background color of the object.
pObject->setBackColor( uiBackColor);
pObject->setForeColor( uiForeColor);
// Redisplay the object.
displayObject( pObject);
}
}
/*===========================================================================
Desc: Gets an object's foreground and background colors.
===========================================================================*/
void FlmForm::getObjectColor(
FLMUINT uiObjectId,
FLMUINT * puiBackColor,
FLMUINT * puiForeColor
)
{
FlmFormObject * pObject;
// Form must be initialized
flmAssert( m_pDisplayWindow != NULL);
// See if we can find the object.
if ((pObject = findObject( uiObjectId)) == NULL)
{
flmAssert( 0);
}
else
{
// Get the foreground and background color of the object.
*puiBackColor = pObject->getBackColor();
*puiForeColor = pObject->getForeColor();
}
}
/*===========================================================================
Desc: Sets display only flag for an object in the form.
===========================================================================*/
void FlmForm::setObjectDisplayOnlyFlag(
FLMUINT uiObjectId,
FLMBOOL bDisplayOnly
)
{
FlmFormObject * pObject;
// Form must be initialized
flmAssert( m_pDisplayWindow != NULL);
// See if we can find the object.
if ((pObject = findObject( uiObjectId)) == NULL)
{
flmAssert( 0);
}
else
{
// Set the display only flag for the object.
pObject->setDisplayOnly( bDisplayOnly);
}
}
/*===========================================================================
Desc: Sets display only flag for an object in the form.
===========================================================================*/
void FlmForm::getObjectDisplayOnlyFlag(
FLMUINT uiObjectId,
FLMBOOL * pbDisplayOnly
)
{
FlmFormObject * pObject;
// Form must be initialized
flmAssert( m_pDisplayWindow != NULL);
// See if we can find the object.
if ((pObject = findObject( uiObjectId)) == NULL)
{
flmAssert( 0);
}
else
{
// Get the display only flag for the object.
*pbDisplayOnly = pObject->isDisplayOnly();
}
}
/*===========================================================================
Desc: Sets value for an object in the form.
===========================================================================*/
RCODE FlmForm::setObjectValue(
FLMUINT uiObjectId,
void * pvValue,
FLMUINT uiLen
)
{
RCODE rc = FERR_OK;
FlmFormObject * pObject;
F_UNREFERENCED_PARM( uiLen);
// Form must be initialized
if (!m_pDisplayWindow)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// See if we can find the object.
if ((pObject = findObject( uiObjectId)) == NULL)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
// Set the object's value, depending on object type.
switch (pObject->getObjectType())
{
case FORM_TEXT_OBJECT:
{
FlmFormTextObject * pTextObject = (FlmFormTextObject *)pObject;
rc = pTextObject->setValue( (const char *)pvValue);
break;
}
case FORM_UNSIGNED_OBJECT:
{
FlmFormUnsignedObject * pUnsignedObject =
(FlmFormUnsignedObject *)pObject;
rc = pUnsignedObject->setValue( (FLMUINT)pvValue);
break;
}
case FORM_SIGNED_OBJECT:
{
FlmFormSignedObject * pSignedObject =
(FlmFormSignedObject *)pObject;
rc = pSignedObject->setValue( (FLMINT)pvValue);
break;
}
case FORM_PULLDOWN_OBJECT:
{
FlmFormPulldownObject * pPulldownObject = (FlmFormPulldownObject *)pObject;
rc = pPulldownObject->setCurrentItem( (FLMUINT)pvValue);
break;
}
case FORM_RECORD_OBJECT:
{
FlmFormRecordObject * pRecordObject = (FlmFormRecordObject *)pObject;
rc = pRecordObject->setValue( (NODE *)pvValue);
break;
}
default:
rc = RC_SET( FERR_NOT_IMPLEMENTED);
break;
}
if (RC_BAD( rc))
{
goto Exit;
}
m_bValuesChanged = TRUE;
// Redisplay the object.
if (m_bInteracting && pObject == m_pCurObject)
{
// Call changeFocus to reset edit buffer.
(void)changeFocus( pObject, FALSE, TRUE);
}
else
{
displayObject( pObject);
}
Exit:
return( rc);
}
/*===========================================================================
Desc: Sets a return address to populate when the form has been
filled in - or when the object changes its value.
===========================================================================*/
RCODE FlmForm::setObjectReturnAddress(
FLMUINT uiObjectId,
void * pvReturnAddress,
FLMUINT * puiReturnLen
)
{
RCODE rc = FERR_OK;
FlmFormObject * pObject;
// Form must be initialized
if (!m_pDisplayWindow)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// See if we can find the object.
if ((pObject = findObject( uiObjectId)) == NULL)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
pObject->setReturnAddress( pvReturnAddress, puiReturnLen);
Exit:
return( rc);
}
/*===========================================================================
Desc: Sets a return path in a GEDCOM tree to populate when the
form has been filled in.
===========================================================================*/
RCODE FlmForm::setObjectReturnPath(
FLMUINT uiObjectId,
FLMUINT * puiReturnPath
)
{
RCODE rc = FERR_OK;
FlmFormObject * pObject;
// Form must be initialized
if (!m_pDisplayWindow)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// See if we can find the object.
if ((pObject = findObject( uiObjectId)) == NULL)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
pObject->setReturnPath( puiReturnPath);
Exit:
return( rc);
}
/*===========================================================================
Desc: Sets the help lines for an object in the form.
===========================================================================*/
RCODE FlmForm::setObjectHelp(
FLMUINT uiObjectId,
const char * pszHelpLine1,
const char * pszHelpLine2)
{
RCODE rc = FERR_OK;
FlmFormObject * pObject;
// Form must be initialized
if (!m_pDisplayWindow)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// See if we can find the object.
if ((pObject = findObject( uiObjectId)) == NULL)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
rc = pObject->setHelp( pszHelpLine1, pszHelpLine2);
Exit:
return( rc);
}
/*===========================================================================
Desc: Sets value for a object in the form.
===========================================================================*/
RCODE FlmForm::setFormEventCB(
FORM_EVENT_CB_p pEventCB,
void * pvAppData,
FLMBOOL bGetKeyStrokes
)
{
RCODE rc = FERR_OK;
// Form must be initialized
if (!m_pDisplayWindow)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
m_pEventCB = pEventCB;
m_pvAppData = pvAppData;
m_bGetKeyStrokes = bGetKeyStrokes;
Exit:
return( rc);
}
/*===========================================================================
Desc: Add a text object to the form.
===========================================================================*/
RCODE FlmForm::addTextObject(
FLMUINT uiObjectId,
const char * pszDefaultVal,
FLMUINT uiMaxChars,
FLMUINT uiWidth,
FLMUINT uiFormat,
FLMBOOL bDisplayOnly,
FLMUINT uiBackColor,
FLMUINT uiForeColor,
FLMUINT uiRow,
FLMUINT uiColumn)
{
RCODE rc = FERR_OK;
FlmFormObject * pPrevObject;
FlmFormTextObject * pTextObject;
// Form must be initialized
if (!m_pDisplayWindow)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// Make sure the object ID is not already used.
if ((pPrevObject = findObject( uiObjectId)) != NULL)
{
rc = RC_SET( FERR_EXISTS);
goto Exit;
}
// Find the objects this object should be linked to. This routine
// also determines if there is an overlap. If so, it will return
// an error.
if (RC_BAD( rc = getObjectLocation( uiWidth, uiRow, uiColumn,
&pPrevObject)))
{
goto Exit;
}
// Create a text object and link into the form.
if ((pTextObject = new FlmFormTextObject) == NULL)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
if (RC_BAD( rc = pTextObject->setup( this, uiObjectId, uiMaxChars,
uiWidth, uiFormat, bDisplayOnly,
uiBackColor, uiForeColor,
uiRow, uiColumn)))
{
goto Exit;
}
if (RC_BAD( rc = pTextObject->setValue( pszDefaultVal)))
{
goto Exit;
}
// Link the object into the form in its proper place.
linkObjectInForm( pTextObject, pPrevObject);
// Display the object
displayObject( pTextObject);
Exit:
return( rc);
}
/*===========================================================================
Desc: Add an unsigned numeric object to the form.
===========================================================================*/
RCODE FlmForm::addUnsignedObject(
FLMUINT uiObjectId,
FLMUINT uiDefaultVal,
FLMUINT uiMinVal,
FLMUINT uiMaxVal,
FLMUINT uiWidth,
FLMUINT uiFormat,
FLMBOOL bDisplayOnly,
FLMUINT uiBackColor,
FLMUINT uiForeColor,
FLMUINT uiRow,
FLMUINT uiColumn
)
{
RCODE rc = FERR_OK;
FlmFormObject * pPrevObject;
FlmFormUnsignedObject * pUnsignedObject;
// Form must be initialized
if (!m_pDisplayWindow)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// Make sure the object ID is not already used.
if ((pPrevObject = findObject( uiObjectId)) != NULL)
{
rc = RC_SET( FERR_EXISTS);
goto Exit;
}
// Find the objects this object should be linked to. This routine
// also determines if there is an overlap. If so, it will return
// an error.
if (RC_BAD( rc = getObjectLocation( uiWidth, uiRow, uiColumn,
&pPrevObject)))
{
goto Exit;
}
// Create an unsigned number object and link into the form.
if ((pUnsignedObject = new FlmFormUnsignedObject) == NULL)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
if (RC_BAD( rc = pUnsignedObject->setup( this, uiObjectId, uiMinVal, uiMaxVal,
uiWidth, uiFormat, bDisplayOnly,
uiBackColor, uiForeColor,
uiRow, uiColumn)))
{
goto Exit;
}
if (RC_BAD( rc = pUnsignedObject->setValue( uiDefaultVal)))
{
goto Exit;
}
// Link the object into the form in its proper place.
linkObjectInForm( pUnsignedObject, pPrevObject);
// Display the object
displayObject( pUnsignedObject);
Exit:
return( rc);
}
/*===========================================================================
Desc: Add a signed numeric object to the form.
===========================================================================*/
RCODE FlmForm::addSignedObject(
FLMUINT uiObjectId,
FLMINT iDefaultVal,
FLMINT iMinVal,
FLMINT iMaxVal,
FLMUINT uiWidth,
FLMUINT uiFormat,
FLMBOOL bDisplayOnly,
FLMUINT uiBackColor,
FLMUINT uiForeColor,
FLMUINT uiRow,
FLMUINT uiColumn
)
{
RCODE rc = FERR_OK;
FlmFormObject * pPrevObject;
FlmFormSignedObject * pSignedObject;
// Form must be initialized
if (!m_pDisplayWindow)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// Make sure the object ID is not already used.
if ((pPrevObject = findObject( uiObjectId)) != NULL)
{
rc = RC_SET( FERR_EXISTS);
goto Exit;
}
// Find the objects this object should be linked to. This routine
// also determines if there is an overlap. If so, it will return
// an error.
if (RC_BAD( rc = getObjectLocation( uiWidth, uiRow, uiColumn,
&pPrevObject)))
{
goto Exit;
}
// Create a signed number object and link into the form.
if ((pSignedObject = new FlmFormSignedObject) == NULL)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
if (RC_BAD( rc = pSignedObject->setup( this, uiObjectId, iMinVal, iMaxVal,
uiWidth, uiFormat, bDisplayOnly,
uiBackColor, uiForeColor,
uiRow, uiColumn)))
{
goto Exit;
}
if (RC_BAD( rc = pSignedObject->setValue( iDefaultVal)))
{
goto Exit;
}
// Link the object into the form in its proper place.
linkObjectInForm( pSignedObject, pPrevObject);
// Display the object
displayObject( pSignedObject);
Exit:
return( rc);
}
/*===========================================================================
Desc: Add a pulldown object to the form.
===========================================================================*/
RCODE FlmForm::addPulldownObject(
FLMUINT uiObjectId,
FLMUINT uiWidth,
FLMUINT uiHeight,
FLMUINT uiBackColor,
FLMUINT uiForeColor,
FLMUINT uiRow,
FLMUINT uiColumn,
FLMBOOL bAutoEnter
)
{
RCODE rc = FERR_OK;
FlmFormObject * pPrevObject;
FlmFormPulldownObject * pPulldownObject;
// Form must be initialized
if (!m_pDisplayWindow)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// Make sure the object ID is not already used.
if ((pPrevObject = findObject( uiObjectId)) != NULL)
{
rc = RC_SET( FERR_EXISTS);
goto Exit;
}
// Find the objects this object should be linked to. This routine
// also determines if there is an overlap. If so, it will return
// an error.
if (RC_BAD( rc = getObjectLocation( uiWidth, uiRow, uiColumn,
&pPrevObject)))
{
goto Exit;
}
// Create a signed number object and link into the form.
if ((pPulldownObject = new FlmFormPulldownObject) == NULL)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
if (RC_BAD( rc = pPulldownObject->setup( this, uiObjectId,
uiWidth, uiHeight,
uiBackColor, uiForeColor,
uiRow, uiColumn)))
{
goto Exit;
}
pPulldownObject->setEnterMode( bAutoEnter);
// Link the object into the form in its proper place.
linkObjectInForm( pPulldownObject, pPrevObject);
// Display the object
displayObject( pPulldownObject);
Exit:
return( rc);
}
/*===========================================================================
Desc: Add a pulldown item to a pulldown object in the form.
===========================================================================*/
RCODE FlmForm::addPulldownItem(
FLMUINT uiObjectId,
FLMUINT uiItemId,
const char * pszDisplayValue,
FLMUINT uiShortcutKey)
{
RCODE rc = FERR_OK;
FlmFormPulldownObject * pPulldownObject;
// Form must be initialized
if (!m_pDisplayWindow)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// Make sure the object has been defined.
if ((pPulldownObject =
(FlmFormPulldownObject *)findObject( uiObjectId)) == NULL)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
// Add the item to the pulldown
if (RC_BAD( rc = pPulldownObject->addItem( uiItemId, pszDisplayValue,
uiShortcutKey)))
{
goto Exit;
}
// Display the object
displayObject( pPulldownObject);
Exit:
return( rc);
}
/*===========================================================================
Desc: Remove a pulldown item from a pulldown object in the form.
===========================================================================*/
RCODE FlmForm::removePulldownItem(
FLMUINT uiObjectId,
FLMUINT uiItemId
)
{
RCODE rc = FERR_OK;
FlmFormPulldownObject * pPulldownObject;
// Form must be initialized
if (!m_pDisplayWindow)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// Make sure the object has been defined.
if ((pPulldownObject =
(FlmFormPulldownObject *)findObject( uiObjectId)) == NULL)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
// Remove the item to the pulldown
if (RC_BAD( rc = pPulldownObject->removeItem( uiItemId)))
{
goto Exit;
}
// Display the object
displayObject( pPulldownObject);
Exit:
return( rc);
}
/*===========================================================================
Desc: Removes all pulldown items from a pulldown object in the form.
===========================================================================*/
RCODE FlmForm::clearPulldownItems(
FLMUINT uiObjectId
)
{
RCODE rc = FERR_OK;
FlmFormPulldownObject * pPulldownObject;
// Form must be initialized
if (!m_pDisplayWindow)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// Make sure the object has been defined.
if ((pPulldownObject =
(FlmFormPulldownObject *)findObject( uiObjectId)) == NULL)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
// Clear all items from the pulldown
if (RC_BAD( rc = pPulldownObject->clearItems()))
{
goto Exit;
}
// Display the object
displayObject( pPulldownObject);
Exit:
return( rc);
}
/*===========================================================================
Desc: Sets a callback function for inserting new items into a pulldown
object inside a form.
===========================================================================*/
RCODE FlmForm::setPulldownInsertCallback(
FLMUINT uiObjectId,
INSERT_FUNC_p pCallback,
void * pvAppData
)
{
RCODE rc = FERR_OK;
FlmFormPulldownObject * pPulldownObject;
// Form must be initialized
if (!m_pDisplayWindow)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// Make sure the object has been defined.
if ((pPulldownObject =
(FlmFormPulldownObject *)findObject( uiObjectId)) == NULL)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
// Set the callback for the pulldown object.
pPulldownObject->setPulldownInsertCallback( pCallback, pvAppData);
Exit:
return( rc);
}
/*===========================================================================
Desc: Sets flag indicating that we are to return all of the items
in the list for this object on the screen, not just the current one.
===========================================================================*/
RCODE FlmForm::setPulldownReturnAll(
FLMUINT uiObjectId,
FLMUINT uiItemIdTag,
FLMUINT uiItemNameTag
)
{
RCODE rc = FERR_OK;
FlmFormPulldownObject * pPulldownObject;
// Form must be initialized
if (!m_pDisplayWindow)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// Make sure the object has been defined.
if ((pPulldownObject =
(FlmFormPulldownObject *)findObject( uiObjectId)) == NULL)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
// Set the callback for the pulldown object.
pPulldownObject->setPulldownReturnAll( uiItemIdTag, uiItemNameTag);
Exit:
return( rc);
}
/*===========================================================================
Desc: Gets the pulldown object for a specific object on the form.
===========================================================================*/
FlmPulldownList * FlmForm::getPulldownObject(
FLMUINT uiObjectId
)
{
FlmPulldownList * pPulldown = NULL;
FlmFormPulldownObject * pPulldownObject;
// Form must be initialized
if (!m_pDisplayWindow)
{
goto Exit;
}
// Make sure the object has been defined.
if ((pPulldownObject =
(FlmFormPulldownObject *)findObject( uiObjectId)) == NULL)
{
goto Exit;
}
// Get the callback for the pulldown object.
pPulldown = pPulldownObject->getPulldownObject();
Exit:
return( pPulldown);
}
/*===========================================================================
Desc: Sets the mode for entering an object - does it happen
automatically? Used only for pulldown and record objects.
===========================================================================*/
RCODE FlmForm::setEnterMode(
FLMUINT uiObjectId,
FLMBOOL bAutoEnter
)
{
RCODE rc = FERR_OK;
FlmFormObject * pObject;
// Form must be initialized
if (!m_pDisplayWindow)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// Make sure the object has been defined.
if ((pObject = findObject( uiObjectId)) == NULL)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
if (pObject->getObjectType() == FORM_PULLDOWN_OBJECT)
{
((FlmFormPulldownObject *)pObject)->setEnterMode( bAutoEnter);
}
else if (pObject->getObjectType() == FORM_RECORD_OBJECT)
{
((FlmFormRecordObject *)pObject)->setEnterMode( bAutoEnter);
}
else
{
flmAssert( 0);
}
Exit:
return( rc);
}
/*===========================================================================
Desc: Adds a GEDCOM record(s) object - for editing GEDCOM.
===========================================================================*/
RCODE FlmForm::addRecordObject(
FLMUINT uiObjectId,
const char * pszTitle,
NODE * pDefaultRecords,
FLMUINT uiWidth,
FLMUINT uiBackColor,
FLMUINT uiForeColor,
FLMUINT uiRow,
FLMUINT uiColumn,
FLMBOOL bAutoEnter)
{
RCODE rc = FERR_OK;
FlmFormObject * pPrevObject;
FlmFormRecordObject * pRecordObject;
// Form must be initialized
if (!m_pDisplayWindow)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// Make sure the object ID is not already used.
if ((pPrevObject = findObject( uiObjectId)) != NULL)
{
rc = RC_SET( FERR_EXISTS);
goto Exit;
}
// Find the objects this object should be linked to. This routine
// also determines if there is an overlap. If so, it will return
// an error.
if (RC_BAD( rc = getObjectLocation( uiWidth, uiRow, uiColumn,
&pPrevObject)))
{
goto Exit;
}
// Create a signed number object and link into the form.
if ((pRecordObject = new FlmFormRecordObject) == NULL)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
if (RC_BAD( rc = pRecordObject->setup( this, uiObjectId, pszTitle,
uiWidth,
uiBackColor, uiForeColor,
uiRow, uiColumn)))
{
goto Exit;
}
if (RC_BAD( rc = pRecordObject->setValue( pDefaultRecords)))
{
goto Exit;
}
pRecordObject->setEnterMode( bAutoEnter);
// Link the object into the form in its proper place.
linkObjectInForm( pRecordObject, pPrevObject);
// Display the object
displayObject( pRecordObject);
Exit:
return( rc);
}
/*===========================================================================
Desc: Sets the database handle and container for a GEDCOM record(s) object.
===========================================================================*/
RCODE FlmForm::setRecordObjectDbAndCont(
FLMUINT uiObjectId,
HFDB hDb,
FLMUINT uiContainer
)
{
RCODE rc = FERR_OK;
FlmFormObject * pObject;
// Form must be initialized
if (!m_pDisplayWindow)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// Make sure the object ID is not already used.
if ((pObject = findObject( uiObjectId)) == NULL)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
((FlmFormRecordObject *)pObject)->setDb( hDb);
((FlmFormRecordObject *)pObject)->setContainer( uiContainer);
Exit:
return( rc);
}
/*===========================================================================
Desc: Moves the form cursor to the first object on the form.
===========================================================================*/
FLMUINT FlmForm::firstObject(
FLMBOOL bSkipDisplayOnly,
FLMBOOL bSkipEditable,
FLMBOOL bRaiseExitEvent,
FLMBOOL bRaiseEnterEvent
)
{
FLMUINT uiChar = 0;
FlmFormObject * pFirstObject;
if (m_pFirstObject)
{
flmAssert( !bSkipDisplayOnly || !bSkipEditable);
// Verify the current object.
if (bRaiseExitEvent && m_pCurObject)
{
if (!verifyObject( bRaiseExitEvent))
goto Exit;
}
pFirstObject = m_pFirstObject;
// Skip any objects that are display only if the
// bSkipDisplayOnly flag is set
if (bSkipDisplayOnly)
{
while (pFirstObject->isDisplayOnly())
{
pFirstObject = pFirstObject->getNextObject();
if (pFirstObject == m_pFirstObject)
{
break;
}
}
}
// Skip any objects that are NOT display only if the
// bSkipEditable flag is set
else if (bSkipEditable)
{
while (!pFirstObject->isDisplayOnly())
{
pFirstObject = pFirstObject->getNextObject();
if (pFirstObject == m_pFirstObject)
{
break;
}
}
}
uiChar = changeFocus( pFirstObject, bRaiseEnterEvent, FALSE);
}
Exit:
return( uiChar);
}
/*===========================================================================
Desc: Moves the form cursor to the last object on the form.
===========================================================================*/
FLMUINT FlmForm::lastObject(
FLMBOOL bSkipDisplayOnly,
FLMBOOL bSkipEditable,
FLMBOOL bRaiseExitEvent,
FLMBOOL bRaiseEnterEvent
)
{
FLMUINT uiChar = 0;
FlmFormObject * pLastObject;
if (m_pLastObject)
{
flmAssert( !bSkipDisplayOnly || !bSkipEditable);
// Verify the current object.
if (!verifyObject( bRaiseExitEvent))
goto Exit;
pLastObject = m_pLastObject;
// Skip any objects that are display only if the
// bSkipDisplayOnly flag is set
if (bSkipDisplayOnly)
{
while (pLastObject->isDisplayOnly())
{
pLastObject = pLastObject->getPrevObject();
if (pLastObject == m_pLastObject)
{
break;
}
}
}
// Skip any objects that are NOT display only if the
// bSkipEditable flag is set
else if (bSkipEditable)
{
while (!pLastObject->isDisplayOnly())
{
pLastObject = pLastObject->getPrevObject();
if (pLastObject == m_pLastObject)
{
break;
}
}
}
uiChar = changeFocus( pLastObject, bRaiseEnterEvent, FALSE);
}
Exit:
return( uiChar);
}
/*===========================================================================
Desc: Moves the form cursor to the next object on the form.
===========================================================================*/
FLMUINT FlmForm::nextObject(
FLMBOOL bSkipDisplayOnly,
FLMBOOL bSkipEditable,
FLMBOOL bRaiseExitEvent,
FLMBOOL bRaiseEnterEvent
)
{
FLMUINT uiChar = 0;
FlmFormObject * pNextObject;
if (m_pCurObject)
{
flmAssert( !bSkipDisplayOnly || !bSkipEditable);
// Verify the current object.
if (!verifyObject( bRaiseExitEvent))
goto Exit;
// Skip any objects that are display only if the
// bSkipDisplayOnly flag is set
pNextObject = m_pCurObject->getNextObject();
if (bSkipDisplayOnly)
{
while (pNextObject != m_pCurObject &&
pNextObject->isDisplayOnly())
{
pNextObject = pNextObject->getNextObject();
}
}
// Skip any objects that are NOT display only if the
// bSkipEditable flag is set
else if (bSkipEditable)
{
while (pNextObject != m_pCurObject &&
!pNextObject->isDisplayOnly())
{
pNextObject = pNextObject->getNextObject();
}
}
uiChar = changeFocus( pNextObject, bRaiseEnterEvent, FALSE);
}
Exit:
return( uiChar);
}
/*===========================================================================
Desc: Moves the form cursor to the previous object on the form.
===========================================================================*/
FLMUINT FlmForm::prevObject(
FLMBOOL bSkipDisplayOnly,
FLMBOOL bSkipEditable,
FLMBOOL bRaiseExitEvent,
FLMBOOL bRaiseEnterEvent
)
{
FLMUINT uiChar = 0;
FlmFormObject * pPrevObject;
if (m_pCurObject)
{
flmAssert( !bSkipDisplayOnly || !bSkipEditable);
// Verify the current object.
if (!verifyObject( bRaiseExitEvent))
goto Exit;
pPrevObject = m_pCurObject->getPrevObject();
// Skip any objects that are display only if the
// bSkipDisplayOnly flag is set
if (bSkipDisplayOnly)
{
while (pPrevObject != m_pCurObject &&
pPrevObject->isDisplayOnly())
{
pPrevObject = pPrevObject->getPrevObject();
}
}
// Skip any objects that are NOT display only if the
// bSkipEditable flag is set
else if (bSkipEditable)
{
while (pPrevObject != m_pCurObject &&
!pPrevObject->isDisplayOnly())
{
pPrevObject = pPrevObject->getPrevObject();
}
}
uiChar = changeFocus( pPrevObject, bRaiseEnterEvent, FALSE);
}
Exit:
return( uiChar);
}
/*===========================================================================
Desc: Moves the form cursor to the object on the form that is above the
current object (if any).
===========================================================================*/
FLMUINT FlmForm::upObject(
FLMBOOL bSkipDisplayOnly,
FLMBOOL bSkipEditable,
FLMBOOL bRaiseExitEvent,
FLMBOOL bRaiseEnterEvent
)
{
FLMUINT uiChar = 0;
FlmFormObject * pUpObject;
FlmFormObject * pPrevObject;
FLMUINT uiRow;
FLMUINT uiColumn;
FLMUINT uiClosestDistance;
FLMUINT uiDistance;
if (m_pCurObject)
{
flmAssert( !bSkipDisplayOnly || !bSkipEditable);
// Verify the current object.
if (!verifyObject( bRaiseExitEvent))
goto Exit;
uiRow = m_pCurObject->getRow();
uiColumn = m_pCurObject->getColumn();
// Skip past all of the objects on the current row.
pPrevObject = m_pCurObject->getPrevObject();
while (pPrevObject != m_pCurObject &&
pPrevObject->getRow() == uiRow)
{
pPrevObject = pPrevObject->getPrevObject();
}
// Skip any objects that are display only if the
// bSkipDisplayOnly flag is set
if (bSkipDisplayOnly)
{
while (pPrevObject != m_pCurObject &&
pPrevObject->isDisplayOnly())
{
pPrevObject = pPrevObject->getPrevObject();
}
}
// Skip any objects that are NOT display only if the
// bSkipEditable flag is set
else if (bSkipEditable)
{
while (pPrevObject != m_pCurObject &&
!pPrevObject->isDisplayOnly())
{
pPrevObject = pPrevObject->getPrevObject();
}
}
// If there are no rows above this one, there is no up object.
if (pPrevObject->getRow() < uiRow)
{
uiRow = pPrevObject->getRow();
// Find the object on this current row whose column is closest to
// our current object.
uiClosestDistance = COLUMN_DIFF( uiColumn, pPrevObject->getColumn());
pUpObject = pPrevObject;
pPrevObject = pPrevObject->getPrevObject();
while (pPrevObject->getRow() == uiRow)
{
if ((pPrevObject->isDisplayOnly() && !bSkipDisplayOnly) ||
(!pPrevObject->isDisplayOnly() && !bSkipEditable))
{
uiDistance = COLUMN_DIFF( uiColumn, pPrevObject->getColumn());
if (uiDistance >= uiClosestDistance)
{
break;
}
pUpObject = pPrevObject;
uiClosestDistance = uiDistance;
}
pPrevObject = pPrevObject->getPrevObject();
}
uiChar = changeFocus( pUpObject, bRaiseEnterEvent, FALSE);
}
else if (m_uiTopFormRow)
{
// Scroll up one line of the form is not displaying the top line
// on the screen.
m_uiTopFormRow--;
m_uiEditRow++;
refresh();
}
}
Exit:
return( uiChar);
}
/*===========================================================================
Desc: Moves the form cursor to the object on the form that is below the
current object (if any).
===========================================================================*/
FLMUINT FlmForm::downObject(
FLMBOOL bSkipDisplayOnly,
FLMBOOL bSkipEditable,
FLMBOOL bRaiseExitEvent,
FLMBOOL bRaiseEnterEvent
)
{
FLMUINT uiChar = 0;
FlmFormObject * pDownObject;
FlmFormObject * pNextObject;
FLMUINT uiRow;
FLMUINT uiColumn;
FLMUINT uiClosestDistance;
FLMUINT uiDistance;
if (m_pCurObject)
{
flmAssert( !bSkipDisplayOnly || !bSkipEditable);
// Verify the current object.
if (!verifyObject( bRaiseExitEvent))
goto Exit;
uiRow = m_pCurObject->getRow();
uiColumn = m_pCurObject->getColumn();
// Skip past all of the objects on the current row.
pNextObject = m_pCurObject->getNextObject();
while (pNextObject != m_pCurObject &&
pNextObject->getRow() == uiRow)
{
pNextObject = pNextObject->getNextObject();
}
// Skip any objects that are display only if the
// bSkipDisplayOnly flag is set
if (bSkipDisplayOnly)
{
while (pNextObject != m_pCurObject &&
pNextObject->isDisplayOnly())
{
pNextObject = pNextObject->getNextObject();
}
}
// Skip any objects that are NOT display only if the
// bSkipEditable flag is set
else if (bSkipEditable)
{
while (pNextObject != m_pCurObject &&
!pNextObject->isDisplayOnly())
{
pNextObject = pNextObject->getNextObject();
}
}
// If there are no rows below this one, there is no down object.
if (pNextObject->getRow() > uiRow)
{
uiRow = pNextObject->getRow();
// Find the object on this current row whose column is closest to
// our current object.
uiClosestDistance = COLUMN_DIFF( uiColumn, pNextObject->getColumn());
pDownObject = pNextObject;
pNextObject = pNextObject->getNextObject();
while (pNextObject->getRow() == uiRow)
{
if ((pNextObject->isDisplayOnly() && !bSkipDisplayOnly) ||
(!pNextObject->isDisplayOnly() && !bSkipEditable))
{
uiDistance = COLUMN_DIFF( uiColumn, pNextObject->getColumn());
if (uiDistance >= uiClosestDistance)
{
break;
}
pDownObject = pNextObject;
uiClosestDistance = uiDistance;
}
pNextObject = pNextObject->getNextObject();
}
uiChar = changeFocus( pDownObject, bRaiseEnterEvent, FALSE);
}
}
Exit:
return( uiChar);
}
/*===========================================================================
Desc: Populates any registered return addresses with data from the form.
===========================================================================*/
RCODE FlmForm::getAllReturnData( void)
{
RCODE rc = FERR_OK;
RCODE tmpRc;
FlmFormObject * pObject = m_pFirstObject;
for (;;)
{
// Don't quit on first bad one. Save RC and continue.
if (RC_BAD( tmpRc = pObject->populateReturnAddress()))
{
rc = tmpRc;
}
pObject = pObject->getNextObject();
if (pObject == m_pFirstObject)
{
break;
}
}
return( rc);
}
/*===========================================================================
Desc: Populates any registered return paths in a GEDCOM tree with data
from the form.
===========================================================================*/
RCODE FlmForm::getAllReturnDataToTree(
POOL * pPool,
NODE * pTree)
{
RCODE rc = FERR_OK;
RCODE tmpRc;
FlmFormObject * pObject = m_pFirstObject;
for (;;)
{
// Don't quit on first bad one. Save RC and continue.
if (RC_BAD( tmpRc = pObject->populateReturnPath( pPool, pTree)))
{
rc = tmpRc;
}
pObject = pObject->getNextObject();
if (pObject == m_pFirstObject)
{
break;
}
}
return( rc);
}
/*===========================================================================
Desc: Executes a form - handles all user input in the form. Return value
is the last character that was pressed.
===========================================================================*/
FLMUINT FlmForm::interact(
FLMBOOL * pbValuesChanged,
FLMUINT * puiCurrObjectId)
{
FLMUINT uiChar;
m_bValuesChanged = FALSE;
// Form must be initialized
if (!m_pDisplayWindow)
{
uiChar = 0;
goto Exit;
}
// Set focus to the first object on the form.
m_bInteracting = TRUE;
m_pCurObject = NULL;
firstObject( TRUE, FALSE, FALSE, TRUE);
beep( NULL, (const char *)m_pCurObject);
// Loop forever getting input.
for (;;)
{
// See if we have been told to exit.
if ((m_pThread) &&
(m_pThread->getShutdownFlag()))
{
uiChar = 0;
goto Exit;
}
// Need to refresh the input cursor, in case it was changed by
// a callback function.
displayInputCursor();
if (FTXWinTestKB( m_pDisplayWindow) == FTXRC_SUCCESS)
{
FTXWinInputChar( m_pDisplayWindow, &uiChar);
// Clear error message out of status line.
beep( NULL, (const char *)m_pCurObject);
if (m_pEventCB && m_bGetKeyStrokes)
{
if (!m_pEventCB( FORM_EVENT_KEY_STROKE, this, m_pCurObject, uiChar,
&uiChar, m_pvAppData))
{
// Must verify current object, unless callback changes the
// character to ESCAPE.
if (uiChar == WPK_ESCAPE || verifyObject( TRUE))
{
goto Exit;
}
else
{
continue;
}
}
}
Handle_Char:
switch( uiChar)
{
case WPK_DOWN:
case WPK_CTRL_N:
if ((uiChar = downObject( TRUE, FALSE, TRUE, TRUE)) != 0)
goto Handle_Char;
break;
case WPK_UP:
case WPK_CTRL_P:
if ((uiChar = upObject( TRUE, FALSE, TRUE, TRUE)) != 0)
goto Handle_Char;
break;
case WPK_PGUP:
case WPK_CTRL_DOWN:
case WPK_CTRL_UP:
case WPK_PGDN:
break;
case WPK_CTRL_HOME:
if ((uiChar = firstObject( TRUE, FALSE, TRUE, TRUE)) != 0)
goto Handle_Char;
break;
case WPK_CTRL_END:
if ((uiChar = lastObject( TRUE, FALSE, TRUE, TRUE)) != 0)
goto Handle_Char;
break;
case WPK_CTRL_D:
if (m_pCurObject->getObjectType() == FORM_PULLDOWN_OBJECT)
{
Edit_Pulldown_Error:
beep( "Cannot edit: press ENTER to select from list");
}
else if (m_pCurObject->getObjectType() == FORM_RECORD_OBJECT)
{
Edit_Record_Error:
beep( "Press ENTER to edit record");
}
else
{
clearLine();
}
break;
case WPK_DELETE:
if (m_pCurObject->getObjectType() == FORM_PULLDOWN_OBJECT)
{
goto Edit_Pulldown_Error;
}
else if (m_pCurObject->getObjectType() == FORM_RECORD_OBJECT)
{
goto Edit_Record_Error;
}
else
{
deleteChar();
}
break;
case WPK_HOME:
cursorHome();
break;
case WPK_END:
cursorEnd();
break;
case WPK_INSERT:
if (m_bInsertMode)
{
m_bInsertMode = FALSE;
FTXWinSetCursorType( m_pDisplayWindow,
WPS_CURSOR_VISIBLE | WPS_CURSOR_BLOCK);
}
else
{
m_bInsertMode = TRUE;
FTXWinSetCursorType( m_pDisplayWindow,
WPS_CURSOR_VISIBLE | WPS_CURSOR_UNDERLINE);
}
break;
case WPK_RIGHT:
if ((uiChar = cursorRight()) != 0)
goto Handle_Char;
break;
case WPK_LEFT:
if ((uiChar = cursorLeft()) != 0)
goto Handle_Char;
break;
case WPK_CTRL_RIGHT:
case WPK_CTRL_LEFT:
case WPK_CTRL_C:
case WPK_CTRL_X:
case WPK_CTRL_V:
break;
case WPK_BACKSPACE:
if (m_pCurObject->getObjectType() == FORM_PULLDOWN_OBJECT)
{
goto Edit_Pulldown_Error;
}
else if (m_pCurObject->getObjectType() == FORM_RECORD_OBJECT)
{
goto Edit_Record_Error;
}
else
{
backspaceChar();
}
break;
case WPK_ENTER:
if (m_pCurObject->getObjectType() == FORM_PULLDOWN_OBJECT)
{
FlmFormPulldownObject * pPulldownObject =
(FlmFormPulldownObject *)m_pCurObject;
FLMUINT uiOldItemId;
FLMUINT uiNewItemId;
pPulldownObject->getCurrentItem( &uiOldItemId);
uiChar = pPulldownObject->select();
pPulldownObject->getCurrentItem( &uiNewItemId);
if (uiOldItemId != uiNewItemId)
{
m_bValuesChanged = TRUE;
}
if (uiChar)
goto Handle_Char;
}
else if (m_pCurObject->getObjectType() == FORM_RECORD_OBJECT)
{
FLMBOOL bChanged;
uiChar = ((FlmFormRecordObject *)m_pCurObject)->edit( &bChanged);
if (bChanged)
{
m_bValuesChanged = TRUE;
}
if (uiChar)
goto Handle_Char;
}
else
{
if ((uiChar = nextObject( TRUE, FALSE, TRUE, TRUE)) != 0)
goto Handle_Char;
}
break;
case WPK_TAB:
if ((uiChar = nextObject( TRUE, FALSE, TRUE, TRUE)) != 0)
goto Handle_Char;
break;
case WPK_STAB:
if ((uiChar = prevObject( TRUE, FALSE, TRUE, TRUE)) != 0)
goto Handle_Char;
break;
case WPK_ALT_H: // Help on form
case WPK_CTRL_H: // Help on field in form.
break;
case WPK_ESCAPE:
case WPK_ALT_Q:
case WPK_F1: // Done with form - submit.
// Verify the current object if not ESCAPE character
if (uiChar == WPK_ESCAPE || verifyObject( TRUE))
{
if (m_pEventCB && m_bGetKeyStrokes)
{
if (m_pEventCB( FORM_EVENT_EXIT_FORM, this,
m_pCurObject, uiChar,
&uiChar, m_pvAppData))
{
goto Exit;
}
}
else
{
goto Exit;
}
}
break;
case 0:
break;
default:
if ((uiChar >= ' ') && (uiChar <= 0x7F))
{
if (m_pCurObject->getObjectType() == FORM_PULLDOWN_OBJECT)
{
goto Edit_Pulldown_Error;
}
else if (m_pCurObject->getObjectType() == FORM_RECORD_OBJECT)
{
goto Edit_Record_Error;
}
else
{
insertChar( uiChar);
}
}
else
{
beep( "Keystroke not recognized");
}
break;
}
}
else
{
f_sleep( 1);
}
}
Exit:
if (puiCurrObjectId && m_pCurObject)
{
*puiCurrObjectId = m_pCurObject->getObjectId();
}
*pbValuesChanged = m_bValuesChanged;
m_bInteracting = FALSE;
return( uiChar);
}
/*===========================================================================
Desc: Retrieves various kinds of information about an object on a form.
===========================================================================*/
RCODE FlmForm::getObjectInfo(
FLMUINT uiObjectId,
FormObjectType * peObjectType,
FLMUINT * puiBackColor,
FLMUINT * puiForeColor,
FLMUINT * puiRow,
FLMUINT * puiCol,
FLMUINT * puiWidth,
void * pvMin,
void * pvMax,
FLMBOOL * pbDisplayOnly
)
{
RCODE rc = FERR_OK;
FlmFormObject * pObject;
// Form must be initialized
if (!m_pDisplayWindow)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// Make sure the object has been defined.
if ((pObject = findObject( uiObjectId)) == NULL)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
if (peObjectType)
{
*peObjectType = pObject->getObjectType();
}
if (puiBackColor)
{
*puiBackColor = pObject->getBackColor();
}
if (puiForeColor)
{
*puiForeColor = pObject->getForeColor();
}
if (puiRow)
{
*puiRow = pObject->getRow();
}
if (puiCol)
{
*puiCol = pObject->getColumn();
}
if (puiWidth)
{
*puiWidth = pObject->getWidth();
}
if (pvMin)
{
switch (pObject->getObjectType())
{
case FORM_UNSIGNED_OBJECT:
*((FLMUINT *)pvMin) = ((FlmFormUnsignedObject *)pObject)->getMin();
break;
case FORM_SIGNED_OBJECT:
*((FLMINT *)pvMin) = ((FlmFormSignedObject *)pObject)->getMin();
break;
default:
*((FLMUINT *)pvMin) = 0;
break;
}
}
if (pvMax)
{
switch (pObject->getObjectType())
{
case FORM_UNSIGNED_OBJECT:
*((FLMUINT *)pvMax) = ((FlmFormUnsignedObject *)pObject)->getMax();
break;
case FORM_SIGNED_OBJECT:
*((FLMINT *)pvMax) = ((FlmFormSignedObject *)pObject)->getMax();
break;
default:
*((FLMUINT *)pvMax) = pObject->getMaxEditChars();
break;
}
}
if (pbDisplayOnly)
{
*pbDisplayOnly = pObject->isDisplayOnly();
}
Exit:
return( rc);
}
/*===========================================================================
Desc: Retrieve a text value from the form
===========================================================================*/
RCODE FlmForm::getTextVal(
FLMUINT uiObjectId,
FLMUINT * puiLen,
char * pszValRV)
{
RCODE rc = FERR_OK;
FlmFormTextObject * pTextObject;
// Form must be initialized
if (!m_pDisplayWindow)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// Make sure the object has been defined.
if ((pTextObject =
(FlmFormTextObject *)findObject( uiObjectId)) == NULL)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
if (pTextObject->getObjectType() != FORM_TEXT_OBJECT)
{
flmAssert( 0);
}
if (RC_BAD( rc = pTextObject->getValue( puiLen, pszValRV)))
{
goto Exit;
}
Exit:
return( rc);
}
/*===========================================================================
Desc: Retrieve an unsigned numeric value from the form
===========================================================================*/
RCODE FlmForm::getUnsignedVal(
FLMUINT uiObjectId,
FLMUINT * puiValRV
)
{
RCODE rc = FERR_OK;
FlmFormObject * pObject;
// Form must be initialized
if (!m_pDisplayWindow)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// Make sure the object has been defined.
if ((pObject = findObject( uiObjectId)) == NULL)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
if (pObject->getObjectType() == FORM_UNSIGNED_OBJECT)
{
if (RC_BAD( rc = ((FlmFormUnsignedObject *)pObject)->getValue( puiValRV)))
{
goto Exit;
}
}
else if (pObject->getObjectType() == FORM_PULLDOWN_OBJECT)
{
if (RC_BAD( rc = ((FlmFormPulldownObject *)pObject)->getCurrentItem( puiValRV)))
{
goto Exit;
}
}
else
{
flmAssert( 0);
}
Exit:
return( rc);
}
/*===========================================================================
Desc: Retrieve a signed numeric value from the form
===========================================================================*/
RCODE FlmForm::getSignedVal(
FLMUINT uiObjectId,
FLMINT * piValRV
)
{
RCODE rc = FERR_OK;
FlmFormSignedObject * pSignedObject;
// Form must be initialized
if (!m_pDisplayWindow)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// Make sure the object has been defined.
if ((pSignedObject =
(FlmFormSignedObject *)findObject( uiObjectId)) == NULL)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
if (pSignedObject->getObjectType() != FORM_SIGNED_OBJECT)
{
flmAssert( 0);
}
if (RC_BAD( rc = pSignedObject->getValue( piValRV)))
{
goto Exit;
}
Exit:
return( rc);
}
/*===========================================================================
Desc: Retrieve a GEDCOM record value from the form
===========================================================================*/
RCODE FlmForm::getRecordVal(
FLMUINT uiObjectId,
NODE * * ppRecord,
POOL * pPool)
{
RCODE rc = FERR_OK;
FlmFormRecordObject * pRecordObject;
// Form must be initialized
if (!m_pDisplayWindow)
{
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// Make sure the object has been defined.
if ((pRecordObject =
(FlmFormRecordObject *)findObject( uiObjectId)) == NULL)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
if (pRecordObject->getObjectType() != FORM_RECORD_OBJECT)
{
flmAssert( 0);
}
if (RC_BAD( rc = pRecordObject->getValue( ppRecord, pPool)))
{
goto Exit;
}
Exit:
return( rc);
}
/*===========================================================================
Desc: Verifies the current object and sets its value if it is verified.
Otherwise, returns FALSE.
===========================================================================*/
FLMBOOL FlmForm::verifyObject(
FLMBOOL bRaiseExitEvent
)
{
FLMBOOL bOk = TRUE;
FLMUINT uiVal;
FLMINT iVal;
// Verify the input - make sure it is null terminated first.
m_pszEditBuf [m_uiNumCharsEntered] = 0;
switch (m_pCurObject->getObjectType())
{
case FORM_TEXT_OBJECT:
((FlmFormTextObject *)m_pCurObject)->setValue( m_pszEditBuf);
break;
case FORM_UNSIGNED_OBJECT:
if (!((FlmFormUnsignedObject *)m_pCurObject)->verifyValue( m_pszEditBuf,
&uiVal))
{
bOk = FALSE;
goto Exit;
}
((FlmFormUnsignedObject *)m_pCurObject)->setValue( uiVal);
break;
case FORM_SIGNED_OBJECT:
if (!((FlmFormSignedObject *)m_pCurObject)->verifyValue( m_pszEditBuf,
&iVal))
{
bOk = FALSE;
goto Exit;
}
((FlmFormSignedObject *)m_pCurObject)->setValue( iVal);
break;
case FORM_PULLDOWN_OBJECT:
case FORM_RECORD_OBJECT:
break;
}
// Do exit callback
if (m_pEventCB && bRaiseExitEvent)
{
bOk = m_pEventCB( FORM_EVENT_EXIT_OBJECT, this, m_pCurObject, 0,
NULL, m_pvAppData);
}
Exit:
return( bOk);
}
/*===========================================================================
Desc: Moves the form cursor to the first object on the form.
===========================================================================*/
FLMUINT FlmForm::changeFocus(
FlmFormObject * pNewObject,
FLMBOOL bRaiseEnterEvent,
FLMBOOL bForceChange)
{
FLMUINT uiChar = 0;
char * pszTmp;
FLMUINT uiMaxEditChars;
// Form must be initialized
if (!m_pDisplayWindow)
{
goto Exit;
}
// Go to the new object on the form.
if ((pNewObject) && ((m_pCurObject != pNewObject) || (bForceChange)))
{
// Redisplay the current object.
if (m_pCurObject)
{
displayObject( m_pCurObject);
}
// Determine if the object is visible.
m_pCurObject = pNewObject;
if (!isVisible( pNewObject))
{
// Object not visible, reposition the form and redisplay the entire
// form.
// If the object will fit in the first page of the form, set the
// top form of the row to zero.
if (pNewObject->getRow() < m_uiTopFormRow)
{
m_uiTopFormRow = pNewObject->getRow();
}
else
{
if (pNewObject->getRow() > m_uiRows - 1)
{
m_uiTopFormRow = pNewObject->getRow() - m_uiRows + 1;
}
else
{
flmAssert( 0); // Should never be able to get here.
m_uiTopFormRow = 0;
}
}
refresh();
}
// Do the entry callback
if (m_pEventCB && bRaiseEnterEvent)
{
(void)m_pEventCB( FORM_EVENT_ENTER_OBJECT, this, m_pCurObject, 0,
NULL, m_pvAppData);
}
// Set up to edit the new object.
uiMaxEditChars = pNewObject->getMaxEditChars();
if (m_uiEditBufSize < uiMaxEditChars + 1)
{
// Allocate a new buffer.
if( RC_BAD( f_alloc( uiMaxEditChars + 1, &pszTmp)))
{
goto Exit;
}
if (m_pszEditBuf)
{
f_free( &m_pszEditBuf);
m_pszEditBuf = NULL;
m_uiEditBufSize = 0;
}
m_pszEditBuf = pszTmp;
m_uiEditBufSize = uiMaxEditChars + 1;
}
m_uiMaxCharsToEnter = uiMaxEditChars;
pNewObject->formatEditBuffer( m_pszEditBuf);
m_uiNumCharsEntered = f_strlen( m_pszEditBuf);
m_uiEditWidth = pNewObject->getWidth();
m_uiEditBufPos = 0;
m_uiEditBufLeftColPos = 0;
m_uiEditColumn = pNewObject->getColumn();
m_uiEditRow = pNewObject->getRow() - m_uiTopFormRow;
m_bInsertMode = TRUE;
m_pCurObject = pNewObject;
m_bShowingHelpStatus = FALSE;
beep( NULL, (const char *)m_pCurObject);
FTXWinSetCursorType( m_pDisplayWindow,
WPS_CURSOR_VISIBLE | WPS_CURSOR_UNDERLINE);
// Set the background and foreground color
refreshLine( m_uiEditBufPos, m_uiEditWidth);
if ((m_pCurObject->getObjectType() == FORM_PULLDOWN_OBJECT) &&
(((FlmFormPulldownObject *)m_pCurObject)->isAutoEnterMode()))
{
uiChar = WPK_ENTER;
}
else if ((m_pCurObject->getObjectType() == FORM_RECORD_OBJECT) &&
(((FlmFormRecordObject *)m_pCurObject)->isAutoEnterMode()))
{
uiChar = WPK_ENTER;
}
}
Exit:
return( uiChar);
}
/*===========================================================================
Desc: Finds an object by tag number.
===========================================================================*/
FlmFormObject * FlmForm::findObject(
FLMUINT uiObjectId
)
{
FlmFormObject * pObject;
// Follow the linked list of objects until we find the one that matches
// the tag we are looking for.
if ((pObject = m_pFirstObject) != NULL)
{
for (;;)
{
if (pObject->getObjectId() == uiObjectId)
break;
pObject = pObject->getNextObject();
// break when we have circled all the way around.
if (pObject == m_pFirstObject)
{
pObject = NULL;
break;
}
}
}
return( pObject);
}
/*===========================================================================
Desc: Determines if an object is currently visible.
===========================================================================*/
FLMBOOL FlmForm::isVisible(
FlmFormObject * pObject
)
{
return( (FLMBOOL)((pObject->getRow() >= m_uiTopFormRow &&
pObject->getRow() <=
m_uiTopFormRow + m_uiRows - 1)
? (FLMBOOL)TRUE
: (FLMBOOL)FALSE));
}
/*===========================================================================
Desc: Displays an object - if it is visible.
===========================================================================*/
void FlmForm::displayObject(
FlmFormObject * pObject
)
{
// If the object is visible, tell it to display itself.
if (isVisible( pObject))
{
pObject->display( pObject->getRow() - m_uiTopFormRow,
pObject->getColumn());
}
}
/*===========================================================================
Desc: Determines where an object should be linked into the form.
Also determines if the object overlaps any other objects. If so,
an error will be returned.
===========================================================================*/
RCODE FlmForm::getObjectLocation(
FLMUINT uiWidth,
FLMUINT uiRow,
FLMUINT uiColumn,
FlmFormObject ** ppPrevObject
)
{
RCODE rc = FERR_OK;
FlmFormObject * pPrevObject;
FlmFormObject * pNextObject;
// Follow linked list of objects until we find the one that is just
// before this one.
pPrevObject = NULL;
pNextObject = m_pFirstObject;
while (pNextObject && pNextObject->getRow() < uiRow)
{
pPrevObject = pNextObject;
if ((pNextObject = pNextObject->getNextObject()) ==
m_pFirstObject)
{
pNextObject = NULL;
break;
}
}
// If the next object is on the same row as the new
// object, search down the row until we hit an
// object whose column is > the new object's column.
while (pNextObject &&
pNextObject->getRow() == uiRow &&
pNextObject->getColumn() < uiColumn)
{
pPrevObject = pNextObject;
if ((pNextObject = pNextObject->getNextObject()) ==
m_pFirstObject)
{
pNextObject = NULL;
break;
}
}
// If the previous object is on the same row, see if there
// is any overlap between it, the new object, and the next
// object.
if (uiWidth)
{
if (pPrevObject &&
pPrevObject->getWidth() &&
pPrevObject->getRow() == uiRow)
{
if (pPrevObject->getColumn() + pPrevObject->getWidth() - 1 >=
uiColumn)
{
flmAssert( 0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
}
if (pNextObject &&
pNextObject->getWidth() &&
pNextObject->getRow() == uiRow)
{
if (uiColumn + uiWidth - 1 >= pNextObject->getColumn())
{
flmAssert( 0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
}
}
// Make sure the column plus its width will fit in the form window.
if (uiColumn + uiWidth > m_uiCols)
{
flmAssert( 0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
*ppPrevObject = pPrevObject;
Exit:
return( rc);
}
/*===========================================================================
Desc: Links an object into a form - after the passed in prev object.
===========================================================================*/
void FlmForm::linkObjectInForm(
FlmFormObject * pNewObject,
FlmFormObject * pPrevObject
)
{
FlmFormObject * pNextObject;
if (!m_pFirstObject)
{
pNextObject = pPrevObject =
m_pFirstObject = m_pLastObject = pNewObject;
}
else if (!pPrevObject)
{
pPrevObject = m_pLastObject;
pNextObject = m_pFirstObject;
m_pFirstObject = pNewObject;
}
else
{
if ((pNextObject = pPrevObject->getNextObject()) ==
m_pFirstObject)
{
m_pLastObject = pNewObject;
}
}
pNewObject->setNextObject( pNextObject);
pNewObject->setPrevObject( pPrevObject);
pNextObject->setPrevObject( pNewObject);
pPrevObject->setNextObject( pNewObject);
}
/*===========================================================================
Desc: Refresh the portion of the line specified.
===========================================================================*/
void FlmForm::refreshLine(
FLMUINT uiPos,
FLMUINT uiChars
)
{
FLMBYTE ucSaveByte;
// Use foreground color as background color, and vice versa when
// editing.
FTXWinSetBackFore( m_pDisplayWindow,
m_bMonochrome ? WPS_WHITE : m_pCurObject->getForeColor(),
m_bMonochrome ? WPS_BLACK : m_pCurObject->getBackColor());
// If there are fewer characters in the edit buffer than
// what we are being asked to display, we need to blank
// out whatever portion comes after the end of line.
if (uiChars > m_uiNumCharsEntered - uiPos)
{
if (uiPos < m_uiNumCharsEntered)
{
m_pszEditBuf [m_uiNumCharsEntered] = 0;
FTXWinPrintStrXY( m_pDisplayWindow, &m_pszEditBuf [uiPos],
m_uiEditColumn + uiPos - m_uiEditBufLeftColPos, m_uiEditRow);
uiChars -= (m_uiNumCharsEntered - uiPos);
}
else
{
FTXWinSetCursorPos( m_pDisplayWindow,
m_uiEditColumn + uiPos - m_uiEditBufLeftColPos,
m_uiEditRow);
}
// Blank out the rest of the box up to the number of
// characters specified.
while (uiChars)
{
FTXWinPrintChar( m_pDisplayWindow, ' ');
uiChars--;
}
}
else
{
ucSaveByte = m_pszEditBuf [uiPos + uiChars];
m_pszEditBuf [uiPos + uiChars] = 0;
FTXWinPrintStrXY( m_pDisplayWindow, &m_pszEditBuf [uiPos],
m_uiEditColumn + uiPos - m_uiEditBufLeftColPos, m_uiEditRow);
m_pszEditBuf [uiPos + uiChars] = ucSaveByte;
}
}
/*===========================================================================
Desc: Move cursor to the beginning of the line
===========================================================================*/
void FlmForm::cursorHome( void)
{
if (m_uiEditBufPos)
{
m_uiEditBufPos = 0;
if (m_uiEditBufLeftColPos)
{
m_uiEditBufLeftColPos = 0;
refreshLine( m_uiEditBufLeftColPos, m_uiEditWidth);
}
}
else
{
beep( "Already at beginning of line");
}
}
/*===========================================================================
Desc: Move cursor to the end of the line
===========================================================================*/
void FlmForm::cursorEnd( void)
{
if (m_uiEditBufPos < m_uiNumCharsEntered)
{
m_uiEditBufPos = m_uiNumCharsEntered;
if (m_uiEditBufLeftColPos + m_uiEditWidth <= m_uiNumCharsEntered)
{
m_uiEditBufLeftColPos = m_uiNumCharsEntered - m_uiEditWidth + 1;
refreshLine( m_uiEditBufLeftColPos, m_uiEditWidth);
}
}
else
{
beep( "Already at end of line");
}
}
/*===========================================================================
Desc: Move cursor right one character.
===========================================================================*/
FLMUINT FlmForm::cursorRight( void)
{
FLMUINT uiChar = 0;
if ((m_uiEditBufPos < m_uiNumCharsEntered) &&
(m_pCurObject->getObjectType() != FORM_PULLDOWN_OBJECT) &&
(m_pCurObject->getObjectType() != FORM_RECORD_OBJECT))
{
m_uiEditBufPos++;
if (m_uiEditBufLeftColPos + m_uiEditWidth - 1 < m_uiEditBufPos)
{
m_uiEditBufLeftColPos++;
refreshLine( m_uiEditBufLeftColPos, m_uiEditWidth);
}
}
else
{
uiChar = nextObject();
}
return( uiChar);
}
/*===========================================================================
Desc: Move cursor left one character.
===========================================================================*/
FLMUINT FlmForm::cursorLeft( void)
{
FLMUINT uiChar = 0;
if ((m_uiEditBufPos) &&
(m_pCurObject->getObjectType() != FORM_PULLDOWN_OBJECT) &&
(m_pCurObject->getObjectType() != FORM_RECORD_OBJECT))
{
m_uiEditBufPos--;
if (m_uiEditBufLeftColPos > m_uiEditBufPos)
{
m_uiEditBufLeftColPos--;
refreshLine( m_uiEditBufLeftColPos, m_uiEditWidth);
}
}
else
{
uiChar = prevObject();
}
return( uiChar);
}
/*===========================================================================
Desc: Delete the character the cursor is positioned on.
===========================================================================*/
void FlmForm::deleteChar( void)
{
if (m_uiEditBufPos < m_uiNumCharsEntered)
{
if (m_uiEditBufPos < m_uiNumCharsEntered - 1)
{
f_memmove( &m_pszEditBuf [m_uiEditBufPos],
&m_pszEditBuf [m_uiEditBufPos + 1],
m_uiNumCharsEntered - m_uiEditBufPos - 1);
}
m_uiNumCharsEntered--;
if (m_uiEditWidth <= m_uiNumCharsEntered - m_uiEditBufLeftColPos + 1)
{
refreshLine( m_uiEditBufPos,
m_uiEditWidth - (m_uiEditBufPos - m_uiEditBufLeftColPos));
}
else
{
refreshLine( m_uiEditBufPos,
m_uiNumCharsEntered - m_uiEditBufPos + 1);
}
m_bValuesChanged = TRUE;
}
else
{
beep( "At end of line - nothing to delete");
}
}
/*===========================================================================
Desc: Insert a character where the cursor is positioned.
===========================================================================*/
void FlmForm::insertChar(
FLMUINT uiChar
)
{
// See if the buffer is full.
if ((m_uiNumCharsEntered == m_uiMaxCharsToEnter) &&
((m_bInsertMode) || (m_uiEditBufPos == m_uiNumCharsEntered)))
{
beep( "Maximum number of characters have been entered");
return;
}
if (m_uiEditBufPos == m_uiNumCharsEntered)
{
m_pszEditBuf [m_uiNumCharsEntered++] = (FLMBYTE)uiChar;
m_uiEditBufPos++;
if (m_uiNumCharsEntered == m_uiMaxCharsToEnter)
{
refreshLine( m_uiEditBufPos - 1, 1);
}
else if (m_uiEditBufPos - m_uiEditBufLeftColPos >= m_uiEditWidth)
{
m_uiEditBufLeftColPos++;
refreshLine( m_uiEditBufLeftColPos, m_uiEditWidth);
}
else
{
refreshLine( m_uiEditBufPos - 1, 1);
}
}
else if (m_bInsertMode)
{
f_memmove( &m_pszEditBuf [m_uiEditBufPos + 1],
&m_pszEditBuf [m_uiEditBufPos],
m_uiNumCharsEntered - m_uiEditBufPos);
m_uiNumCharsEntered++;
m_pszEditBuf [m_uiEditBufPos++] = (FLMBYTE)uiChar;
if (m_uiEditBufPos - m_uiEditBufLeftColPos >= m_uiEditWidth)
{
m_uiEditBufLeftColPos++;
refreshLine( m_uiEditBufLeftColPos, m_uiEditWidth);
}
else if (m_uiEditWidth <= m_uiNumCharsEntered - m_uiEditBufLeftColPos + 1)
{
refreshLine( m_uiEditBufPos - 1,
m_uiEditWidth - (m_uiEditBufPos - 1 - m_uiEditBufLeftColPos));
}
else
{
refreshLine( m_uiEditBufPos - 1,
m_uiNumCharsEntered - (m_uiEditBufPos - 1));
}
}
else
{
m_pszEditBuf [m_uiEditBufPos++] = (FLMBYTE)uiChar;
if (m_uiEditBufPos - m_uiEditBufLeftColPos >= m_uiEditWidth)
{
m_uiEditBufLeftColPos++;
refreshLine( m_uiEditBufLeftColPos, m_uiEditWidth);
}
else
{
refreshLine( m_uiEditBufPos - 1, 1);
}
}
m_bValuesChanged = TRUE;
}
/*===========================================================================
Desc: Delete the character to the left of the cursor.
===========================================================================*/
void FlmForm::backspaceChar( void)
{
if (m_uiEditBufPos)
{
m_uiEditBufPos--;
if (m_uiEditBufPos < m_uiNumCharsEntered - 1)
{
f_memmove( &m_pszEditBuf [m_uiEditBufPos],
&m_pszEditBuf [m_uiEditBufPos + 1],
m_uiNumCharsEntered - m_uiEditBufPos - 1);
}
m_uiNumCharsEntered--;
if (m_uiEditBufPos <= m_uiEditBufLeftColPos &&
m_uiEditBufLeftColPos)
{
if (m_uiEditBufPos)
{
m_uiEditBufLeftColPos = m_uiEditBufPos - 1;
}
else
{
m_uiEditBufLeftColPos = 0;
}
if (m_uiEditWidth > m_uiNumCharsEntered - m_uiEditBufLeftColPos + 1)
{
refreshLine( m_uiEditBufLeftColPos,
m_uiNumCharsEntered - m_uiEditBufLeftColPos + 1);
}
else
{
refreshLine( m_uiEditBufLeftColPos, m_uiEditWidth);
}
}
else if (m_uiEditWidth > m_uiNumCharsEntered - m_uiEditBufLeftColPos + 1)
{
refreshLine( m_uiEditBufPos,
m_uiNumCharsEntered - m_uiEditBufPos + 2);
}
else
{
refreshLine( m_uiEditBufPos,
m_uiEditWidth - (m_uiEditBufPos - m_uiEditBufLeftColPos));
}
m_bValuesChanged = TRUE;
}
else
{
beep( "Cannot backspace - at beginning of line");
}
}
/*===========================================================================
Desc: Delete all characters from current cursor position to end of line,
including the character the cursor is currently positioned on.
===========================================================================*/
void FlmForm::clearLine( void)
{
if (m_uiEditBufPos < m_uiNumCharsEntered)
{
m_uiNumCharsEntered = m_uiEditBufPos;
refreshLine( m_uiEditBufPos,
m_uiEditWidth - (m_uiEditBufPos - m_uiEditBufLeftColPos));
m_bValuesChanged = TRUE;
}
else
{
beep( "Nothing to clear - at end of line");
}
}
/*===========================================================================
Desc: Redisplay the input cursor.
===========================================================================*/
void FlmForm::displayInputCursor( void)
{
FLMUINT uiCol;
FLMUINT uiRow;
FTXWinGetCursorPos( m_pDisplayWindow, &uiCol, &uiRow);
if ((uiCol != m_uiEditColumn + (m_uiEditBufPos - m_uiEditBufLeftColPos)) ||
(uiRow != m_uiEditRow))
{
FTXWinSetCursorPos( m_pDisplayWindow,
m_uiEditColumn + (m_uiEditBufPos - m_uiEditBufLeftColPos), m_uiEditRow);
}
}
/*===========================================================================
Desc: Beep and display an error message in the status box.
===========================================================================*/
void FlmForm::beep(
const char * pszErrMsg1,
const char * pszErrMsg2)
{
FLMUINT uiElapTime;
FLMUINT uiMilli;
if (m_pStatusWindow)
{
if (pszErrMsg1)
{
FTXWinSetBackFore( m_pStatusWindow,
m_bMonochrome ? WPS_BLACK : WPS_RED,
WPS_WHITE);
FTXWinClearLine( m_pStatusWindow, 0, 0);
FTXWinClearLine( m_pStatusWindow, 0, 1);
FTXWinPrintStrXY( m_pStatusWindow, pszErrMsg1, 0, 0);
if (pszErrMsg2)
{
FTXWinPrintStrXY( m_pStatusWindow, pszErrMsg2, 0, 1);
}
FTXWinSetBackFore( m_pStatusWindow,
m_bMonochrome ? WPS_BLACK : WPS_GREEN,
WPS_WHITE);
uiElapTime = FLM_GET_TIMER() - m_uiLastTimeBeeped;
FLM_TIMER_UNITS_TO_MILLI( uiElapTime, uiMilli);
if (uiMilli >= 100)
{
ftxBeep();
m_uiLastTimeBeeped = FLM_GET_TIMER();
}
m_bShowingHelpStatus = FALSE;
}
else if (!m_bShowingHelpStatus)
{
FlmFormObject * pObject = (FlmFormObject *)pszErrMsg2;
char szHelp1 [100];
char szHelp2 [100];
FTXWinClearLine( m_pStatusWindow, 0, 0);
FTXWinClearLine( m_pStatusWindow, 0, 1);
pObject->getHelp( szHelp1, sizeof( szHelp1), szHelp2, sizeof( szHelp2));
if (szHelp1 [0])
{
FTXWinPrintStrXY( m_pStatusWindow, szHelp1, 0, 0);
}
if (szHelp2 [0])
{
FTXWinPrintStrXY( m_pStatusWindow, szHelp2, 0, 1);
}
m_bShowingHelpStatus = TRUE;
}
}
}
/*===========================================================================
Desc: Initializes variables
===========================================================================*/
FlmFormObject::FlmFormObject()
{
m_uiObjectId = 0;
m_uiRow = 0;
m_uiColumn = 0;
m_uiWidth = 0;
m_uiFormat = 0;
m_bDisplayOnly = FALSE;
m_uiHelpBuffSize = 0;
m_pszHelpLine1 = NULL;
m_pszHelpLine2 = NULL;
m_pForm = NULL;
m_uiMaxEditChars = 0;
m_pvReturnAddress = NULL;
m_puiReturnLen = NULL;
m_uiReturnPath [0] = 0;
m_uiBackColor = WPS_WHITE;
m_uiForeColor = WPS_BLUE;
m_pNextObject = NULL;
m_pPrevObject = NULL;
}
FlmFormObject::~FlmFormObject()
{
if (m_pszHelpLine1)
{
f_free( &m_pszHelpLine1);
}
}
/*===========================================================================
Desc: Output text to the field - justify to left, center or right.
===========================================================================*/
void FlmFormObject::outputText(
char * pszText,
FLMUINT uiRow,
FLMUINT uiColumn)
{
FLMUINT uiChars = f_strlen( pszText);
FTX_WINDOW_p pWindow = m_pForm->getWindow();
FLMUINT uiPreFill = 0;
FLMUINT uiPostFill = 0;
char * pszDispText;
char * pszRestoreChar = NULL;
char ucSave;
FTXWinSetBackFore( pWindow,
m_pForm->getMonochrome() ? WPS_BLACK : m_uiBackColor,
m_pForm->getMonochrome() ? WPS_WHITE : m_uiForeColor);
if (m_uiFormat & FORMAT_LEFT_JUSTIFY)
{
Left_Justify:
pszDispText = pszText;
if (uiChars <= m_uiWidth)
{
uiPostFill = m_uiWidth - uiChars;
}
else
{
pszRestoreChar = &pszText [m_uiWidth];
ucSave = *pszRestoreChar;
*pszRestoreChar = 0;
}
}
else if (m_uiFormat & FORMAT_RIGHT_JUSTIFY)
{
if (uiChars > m_uiWidth)
{
pszDispText = &pszText [uiChars - m_uiWidth];
}
else
{
pszDispText = pszText;
uiPreFill = m_uiWidth - uiChars;
}
}
else if (m_uiFormat & FORMAT_CENTER_JUSTIFY)
{
if (uiChars > m_uiWidth)
{
pszDispText = &pszText [(uiChars - m_uiWidth) / 2];
pszRestoreChar = &pszDispText [m_uiWidth];
ucSave = *pszRestoreChar;
*pszRestoreChar = 0;
}
else
{
pszDispText = pszText;
uiPreFill = (m_uiWidth - uiChars) / 2;
uiPostFill = m_uiWidth - uiChars - uiPreFill;
}
}
else
{
goto Left_Justify;
}
FTXWinSetCursorPos( pWindow, uiColumn, uiRow);
// Do the blank prefill.
while (uiPreFill)
{
FTXWinPrintChar( pWindow, ' ');
uiPreFill--;
}
// Output the text - will be right justified.
if (*pszDispText)
{
FTXWinPrintStr( pWindow, pszDispText);
}
// Blank fill the rest
while (uiPostFill)
{
FTXWinPrintChar( pWindow, ' ');
uiPostFill--;
}
// Restore any overwritten character.
if (pszRestoreChar)
{
*pszRestoreChar = ucSave;
}
}
/*===========================================================================
Desc: Set help for an object on the form.
===========================================================================*/
RCODE FlmFormObject::setHelp(
const char * pszHelpLine1,
const char * pszHelpLine2)
{
RCODE rc = FERR_OK;
FLMUINT uiLen1;
FLMUINT uiLen2;
char * pszTmp;
uiLen1 = (FLMUINT)((pszHelpLine1)
? (FLMUINT)f_strlen( pszHelpLine1)
: (FLMUINT)0);
uiLen2 = (FLMUINT)((pszHelpLine2)
? (FLMUINT)f_strlen( pszHelpLine2)
: (FLMUINT)0);
// Allocate one buffer for both strings.
if (uiLen1 + uiLen2 + 2 > m_uiHelpBuffSize)
{
if( RC_BAD( rc = f_alloc( uiLen1 + uiLen2 + 2, &pszTmp)))
{
goto Exit;
}
if (m_pszHelpLine1)
{
f_free( &m_pszHelpLine1);
m_pszHelpLine1 = NULL;
m_uiHelpBuffSize = 0;
}
m_pszHelpLine1 = pszTmp;
m_uiHelpBuffSize = uiLen1 + uiLen2 + 2;
}
// Copy help line one into the buffer.
if (pszHelpLine1 && uiLen1)
{
f_memcpy( m_pszHelpLine1, pszHelpLine1, uiLen1);
}
m_pszHelpLine1 [uiLen1] = 0;
// Copy help line 2 into the buffer.
m_pszHelpLine2 = m_pszHelpLine1 + uiLen1 + 1;
if (pszHelpLine2 && uiLen2)
{
f_memcpy( m_pszHelpLine2, pszHelpLine2, uiLen2);
}
m_pszHelpLine2 [uiLen2] = 0;
Exit:
return( rc);
}
/*===========================================================================
Desc: Get the help lines for an object on the form.
===========================================================================*/
void FlmFormObject::getHelp(
char * pszHelpLine1,
FLMUINT uiHelpSize1,
char * pszHelpLine2,
FLMUINT uiHelpSize2)
{
FLMUINT uiLen;
if (!m_pszHelpLine1)
{
*pszHelpLine1 = 0;
}
else
{
uiLen = f_strlen( m_pszHelpLine1);
if (uiLen >= uiHelpSize1)
{
uiLen = uiHelpSize1 - 1;
}
if (uiLen)
{
f_memcpy( pszHelpLine1, m_pszHelpLine1, uiLen);
}
pszHelpLine1 [uiLen] = 0;
}
if (!m_pszHelpLine2)
{
*pszHelpLine2 = 0;
}
else
{
uiLen = f_strlen( m_pszHelpLine2);
if (uiLen >= uiHelpSize2)
{
uiLen = uiHelpSize2 - 1;
}
if (uiLen)
{
f_memcpy( pszHelpLine2, m_pszHelpLine2, uiLen);
}
pszHelpLine2 [uiLen] = 0;
}
}
/*===========================================================================
Desc: Finds the registered return path in the tree - will create a node,
unless the root node of the path does not match the root node of
the tree.
===========================================================================*/
NODE * FlmFormObject::findPath(
POOL * pPool,
NODE * pTree)
{
NODE * pNode = NULL;
NODE * pParentNode;
FLMUINT uiLevel;
FLMUINT uiTagNum;
RCODE rc;
if (m_uiReturnPath [0] == GedTagNum( pTree))
{
pNode = pTree;
uiLevel = 1;
for (;;)
{
uiTagNum = m_uiReturnPath [uiLevel];
if (!uiTagNum)
break;
pParentNode = pNode;
pNode = GedChild( pParentNode);
while ((pNode) && (GedTagNum( pNode) != uiTagNum))
{
pNode = GedSibNext( pNode);
}
if (!pNode)
{
if ((pNode = GedNodeMake( pPool, uiTagNum, &rc)) == NULL)
{
goto Exit;
}
GedChildGraft( pParentNode, pNode, GED_LAST);
}
uiLevel++;
}
}
Exit:
return( pNode);
}
/*===========================================================================
Desc: Initializes variables
===========================================================================*/
FlmFormTextObject::FlmFormTextObject()
{
m_pszValue = NULL;
}
FlmFormTextObject::~FlmFormTextObject()
{
if (m_pszValue)
{
f_free( &m_pszValue);
}
}
/*===========================================================================
Desc: Sets up a text object on a form.
===========================================================================*/
RCODE FlmFormTextObject::setup(
FlmForm * pForm,
FLMUINT uiObjectId,
FLMUINT uiMaxChars,
FLMUINT uiWidth,
FLMUINT uiFormat,
FLMBOOL bDisplayOnly,
FLMUINT uiBackColor,
FLMUINT uiForeColor,
FLMUINT uiRow,
FLMUINT uiColumn
)
{
RCODE rc = FERR_OK;
if (m_pForm)
{
flmAssert( 0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
if( RC_BAD( rc = f_alloc( uiMaxChars + 1, &m_pszValue)))
{
goto Exit;
}
m_uiMaxEditChars = uiMaxChars;
m_pForm = pForm;
m_eObjectType = FORM_TEXT_OBJECT;
m_uiObjectId = uiObjectId;
m_uiRow = uiRow;
m_uiColumn = uiColumn;
m_uiWidth = uiWidth;
m_uiFormat = uiFormat;
m_bDisplayOnly = bDisplayOnly;
setBackColor( uiBackColor);
setForeColor( uiForeColor);
Exit:
return( rc);
}
/*===========================================================================
Desc: Set the current value for a text object in a form.
===========================================================================*/
RCODE FlmFormTextObject::setValue(
const char * pszValue)
{
RCODE rc = FERR_OK;
FLMUINT uiLen = f_strlen( pszValue);
if (uiLen > m_uiMaxEditChars)
{
flmAssert( 0);
rc = RC_SET( FERR_CONV_DEST_OVERFLOW);
uiLen = m_uiMaxEditChars;
}
f_memcpy( m_pszValue, pszValue, uiLen);
m_pszValue [uiLen] = 0;
//Exit:
return( rc);
}
/*===========================================================================
Desc: Gets the current value for a text object in a form.
===========================================================================*/
RCODE FlmFormTextObject::getValue(
FLMUINT * puiLen,
char * pszValue)
{
RCODE rc = FERR_OK;
FLMUINT uiLen;
if (!pszValue)
{
*puiLen = (FLMUINT)((m_pszValue)
? (FLMUINT)f_strlen( m_pszValue) + 1
: (FLMUINT)1);
}
else
{
uiLen = f_strlen( m_pszValue);
if (uiLen > *puiLen - 1)
{
flmAssert( 0);
rc = RC_SET( FERR_CONV_DEST_OVERFLOW);
uiLen = *puiLen - 1;
}
f_memcpy( pszValue, m_pszValue, uiLen);
pszValue [uiLen] = 0;
*puiLen = uiLen + 1;
}
return( rc);
}
/*===========================================================================
Desc: Displays the current value for a text object in a form.
===========================================================================*/
void FlmFormTextObject::display(
FLMUINT uiDisplayRow,
FLMUINT uiDisplayColumn
)
{
outputText( m_pszValue, uiDisplayRow, uiDisplayColumn);
}
/*===========================================================================
Desc: Formats the current value into an edit buffer that will be used to
edit the object.
===========================================================================*/
void FlmFormTextObject::formatEditBuffer(
char * pszEditBuf)
{
f_strcpy( pszEditBuf, m_pszValue);
}
/*===========================================================================
Desc: Formats the current value into an the return address, if any.
===========================================================================*/
RCODE FlmFormTextObject::populateReturnAddress( void)
{
RCODE rc = FERR_OK;
if (m_pvReturnAddress)
{
rc = getValue( m_puiReturnLen, (char *)m_pvReturnAddress);
}
return( rc);
}
/*===========================================================================
Desc: Formats the current value into an node in the tree, if any.
===========================================================================*/
RCODE FlmFormTextObject::populateReturnPath(
POOL * pPool,
NODE * pTree)
{
RCODE rc = FERR_OK;
char * pszTmp;
FLMUINT uiLen;
NODE * pNode;
if (m_uiReturnPath [0])
{
if ((pNode = findPath( pPool, pTree)) != NULL)
{
if( RC_BAD( rc = f_alloc( m_uiMaxEditChars + 1, &pszTmp)))
{
goto Exit;
}
uiLen = m_uiMaxEditChars + 1;
if (RC_OK( rc = getValue( &uiLen, pszTmp)))
{
rc = GedPutNATIVE( pPool, (NODE *)pNode, pszTmp);
}
f_free( &pszTmp);
}
}
Exit:
return( rc);
}
/*===========================================================================
Desc: Initializes variables
===========================================================================*/
FlmFormUnsignedObject::FlmFormUnsignedObject()
{
m_uiValue = 0; // Current value in the object
m_uiMin = 0;
m_uiMax = 0;
}
FlmFormUnsignedObject::~FlmFormUnsignedObject()
{
}
/*===========================================================================
Desc: Sets up an unsigned object on a form.
===========================================================================*/
RCODE FlmFormUnsignedObject::setup(
FlmForm * pForm,
FLMUINT uiObjectId,
FLMUINT uiMin,
FLMUINT uiMax,
FLMUINT uiWidth,
FLMUINT uiFormat,
FLMBOOL bDisplayOnly,
FLMUINT uiBackColor,
FLMUINT uiForeColor,
FLMUINT uiRow,
FLMUINT uiColumn
)
{
RCODE rc = FERR_OK;
FLMUINT uiHexDigits;
if (m_pForm)
{
flmAssert( 0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
m_pForm = pForm;
m_eObjectType = FORM_UNSIGNED_OBJECT;
m_uiObjectId = uiObjectId;
if (uiMin > uiMax)
{
flmAssert( 0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
m_uiMin = uiMin;
m_uiMax = uiMax;
// Determine the maximum number of edit characters - based on maximum
// value. Calculate the maximum decimal digits and the maximum
// hex digits - take the greater of these two.
m_uiMaxEditChars = 1;
uiMax /= 10;
while (uiMax)
{
uiMax /= 10;
m_uiMaxEditChars++;
}
uiHexDigits = 3; // Accounts for at least "0x" and one digit
uiMax = m_uiMax >> 4;
while (uiMax)
{
uiMax >>= 4;
uiHexDigits++;
}
if (uiHexDigits > m_uiMaxEditChars)
{
m_uiMaxEditChars = uiHexDigits;
}
if (uiWidth > m_uiMaxEditChars)
{
m_uiMaxEditChars = uiWidth;
}
m_uiRow = uiRow;
m_uiColumn = uiColumn;
m_uiWidth = uiWidth;
m_uiFormat = uiFormat;
m_bDisplayOnly = bDisplayOnly;
setBackColor( uiBackColor);
setForeColor( uiForeColor);
Exit:
return( rc);
}
/*===========================================================================
Desc: Set the current value for an unsigned object in a form.
===========================================================================*/
RCODE FlmFormUnsignedObject::setValue(
FLMUINT uiValue
)
{
RCODE rc = FERR_OK;
if (uiValue < m_uiMin || uiValue > m_uiMax)
{
flmAssert( 0);
rc = RC_SET( FERR_CONV_DEST_OVERFLOW);
}
m_uiValue = uiValue;
//Exit:
return( rc);
}
/*===========================================================================
Desc: Gets the current value for an unsigned object in a form.
===========================================================================*/
RCODE FlmFormUnsignedObject::getValue(
FLMUINT * puiValue
)
{
*puiValue = m_uiValue;
return( FERR_OK);
}
/*===========================================================================
Desc: Converts the text and verifies that it is a proper unsigned value.
===========================================================================*/
FSTATIC FLMBOOL flmIsUnsigned(
char * pszEditBuf,
FLMUINT * puiValue,
char * pszErrMsg)
{
FLMBOOL bOk = TRUE;
FLMUINT uiValue = 0;
// Convert the value - using HEX or decimal.
if ((*pszEditBuf == '0') &&
((*(pszEditBuf + 1) == 'x') ||
(*(pszEditBuf + 1) == 'X')))
{
pszEditBuf += 2;
if (!(*pszEditBuf))
{
bOk = FALSE;
f_strcpy( pszErrMsg,
"Invalid HEX number - must have at least one hex digit");
goto Exit;
}
// Hex conversion
while (*pszEditBuf)
{
if (((*pszEditBuf >= '0') && (*pszEditBuf <= '9')) ||
((*pszEditBuf >= 'A') && (*pszEditBuf <= 'F')) ||
((*pszEditBuf >= 'a') && (*pszEditBuf <= 'f')))
{
if (uiValue > 0x0FFFFFFF)
{
bOk = FALSE;
f_strcpy( pszErrMsg, "HEX number is too large");
goto Exit;
}
uiValue <<= 4;
if ((*pszEditBuf >= '0') && (*pszEditBuf <= '9'))
{
uiValue += (FLMUINT)(*pszEditBuf - '0');
}
else if ((*pszEditBuf >= 'A') && (*pszEditBuf <= 'F'))
{
uiValue += (FLMUINT)(*pszEditBuf - 'A' + 10);
}
else
{
uiValue += (FLMUINT)(*pszEditBuf - 'a' + 10);
}
}
else
{
f_strcpy( pszErrMsg, "Invalid digit in HEX number");
bOk = FALSE;
goto Exit;
}
pszEditBuf++;
}
}
else
{
if (!(*pszEditBuf))
{
bOk = FALSE;
f_strcpy( pszErrMsg,
"Invalid number - must have at least one decimal digit");
goto Exit;
}
// Decimal conversion
while (*pszEditBuf)
{
if ((*pszEditBuf >= '0') && (*pszEditBuf <= '9'))
{
if (uiValue > (0xFFFFFFFF / 10))
{
Too_Large_Error:
bOk = FALSE;
f_strcpy( pszErrMsg, "Decimal number is too large");
goto Exit;
}
uiValue *= 10;
if (uiValue > 0xFFFFFFFF - (FLMUINT)(*pszEditBuf - '0'))
{
goto Too_Large_Error;
}
uiValue += (FLMUINT)(*pszEditBuf - '0');
}
else
{
f_strcpy( pszErrMsg, "Invalid digit in number");
bOk = FALSE;
goto Exit;
}
pszEditBuf++;
}
}
*puiValue = uiValue;
Exit:
return( bOk);
}
/*===========================================================================
Desc: Converts the text and verifies that it is a proper unsigned value.
===========================================================================*/
FLMBOOL FlmFormUnsignedObject::verifyValue(
char * pszEditBuf,
FLMUINT * puiValue)
{
FLMBOOL bOk = TRUE;
char szErrMsg [100];
FLMUINT uiValue;
bOk = flmIsUnsigned( pszEditBuf, &uiValue, szErrMsg);
if (!bOk)
{
m_pForm->beep( szErrMsg);
goto Exit;
}
if ((uiValue < m_uiMin) || (uiValue > m_uiMax))
{
f_sprintf( (char *)szErrMsg, "Value must be >= %u and <= %u",
(unsigned)m_uiMin, (unsigned)m_uiMax);
m_pForm->beep( szErrMsg);
bOk = FALSE;
goto Exit;
}
*puiValue = uiValue;
Exit:
return( bOk);
}
/*===========================================================================
Desc: Displays the current value for an unsigned object in a form.
===========================================================================*/
void FlmFormUnsignedObject::display(
FLMUINT uiDisplayRow,
FLMUINT uiDisplayColumn
)
{
char szValue [20];
formatEditBuffer( szValue);
outputText( szValue, uiDisplayRow, uiDisplayColumn);
}
/*===========================================================================
Desc: Formats the current value into an edit buffer that will be used to
edit the object.
===========================================================================*/
void FlmFormUnsignedObject::formatEditBuffer(
char * pszEditBuf)
{
char szFormat [10];
if (m_uiFormat & (FORMAT_UPPER_HEX | FORMAT_LOWER_HEX))
{
if (m_uiFormat & FORMAT_ZERO_LEAD)
{
if (m_uiFormat & FORMAT_UPPER_HEX)
{
f_sprintf( (char *)szFormat, "0x%%0%uX", (unsigned)m_uiWidth);
}
else
{
f_sprintf( (char *)szFormat, "0x%%0%ux", (unsigned)m_uiWidth);
}
f_sprintf( (char *)pszEditBuf, "%s%u", (char *)szFormat, (unsigned)m_uiValue);
}
else if (m_uiFormat & FORMAT_UPPER_HEX)
{
f_sprintf( (char *)pszEditBuf, "0x%X", (unsigned)m_uiValue);
}
else
{
f_sprintf( (char *)pszEditBuf, "0x%x", (unsigned)m_uiValue);
}
}
else
{
if (m_uiFormat & FORMAT_ZERO_LEAD)
{
f_sprintf( (char *)szFormat, "%%0%uu", (unsigned)m_uiWidth);
f_sprintf( (char *)pszEditBuf, "%s%u", (char *)szFormat, (unsigned)m_uiValue);
}
else
{
f_sprintf( (char *)pszEditBuf, "%u", (unsigned)m_uiValue);
}
}
}
/*===========================================================================
Desc: Formats the current value into an the return address, if any.
===========================================================================*/
RCODE FlmFormUnsignedObject::populateReturnAddress( void)
{
RCODE rc = FERR_OK;
if (m_pvReturnAddress)
{
rc = getValue( (FLMUINT *)m_pvReturnAddress);
}
return( rc);
}
/*===========================================================================
Desc: Formats the current value into an node in the tree, if any.
===========================================================================*/
RCODE FlmFormUnsignedObject::populateReturnPath(
POOL * pPool,
NODE * pTree)
{
RCODE rc = FERR_OK;
NODE * pNode;
FLMUINT uiValue;
if (m_uiReturnPath [0])
{
if ((pNode = findPath( pPool, pTree)) != NULL)
{
if (RC_OK( rc = getValue( &uiValue)))
{
rc = GedPutUINT( pPool, pNode, uiValue);
}
}
}
return( rc);
}
/*===========================================================================
Desc: Initializes variables
===========================================================================*/
FlmFormSignedObject::FlmFormSignedObject()
{
m_iValue = 0; // Current value in the object
m_iMin = 0;
m_iMax = 0;
}
FlmFormSignedObject::~FlmFormSignedObject()
{
}
/*===========================================================================
Desc: Sets up a signed object on a form.
===========================================================================*/
RCODE FlmFormSignedObject::setup(
FlmForm * pForm,
FLMUINT uiObjectId,
FLMINT iMin,
FLMINT iMax,
FLMUINT uiWidth,
FLMUINT uiFormat,
FLMBOOL bDisplayOnly,
FLMUINT uiBackColor,
FLMUINT uiForeColor,
FLMUINT uiRow,
FLMUINT uiColumn
)
{
RCODE rc = FERR_OK;
FLMUINT uiTmpDigits;
FLMUINT uiTmp;
if (m_pForm)
{
flmAssert( 0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
m_pForm = pForm;
m_eObjectType = FORM_SIGNED_OBJECT;
m_uiObjectId = uiObjectId;
if (iMin > iMax)
{
flmAssert( 0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
m_iMin = iMin;
m_iMax = iMax;
// First look at the maximum width required for the maximum number.
// Look at the number of digits required for both a HEX and a
// non-hex representation.
m_uiMaxEditChars = 1;
if (iMax < 0)
{
m_uiMaxEditChars++;
iMax = -iMax;
}
iMax /= 10;
while (iMax)
{
iMax /= 10;
m_uiMaxEditChars++;
}
// Calculate the digits required to enter the number in hex.
uiTmpDigits = 3; // Accounts for at least "0x" and one digit
uiTmp = ((FLMUINT)m_iMax) >> 4;
while (uiTmp)
{
uiTmp >>= 4;
uiTmpDigits++;
}
if (uiTmpDigits > m_uiMaxEditChars)
{
m_uiMaxEditChars = uiTmpDigits;
}
// Now look at the minimum number.
uiTmpDigits = 1;
if (iMin < 0)
{
uiTmpDigits++;
iMin = -iMin;
}
iMin /= 10;
while (iMin)
{
iMin /= 10;
uiTmpDigits++;
}
if (uiTmpDigits > m_uiMaxEditChars)
{
m_uiMaxEditChars = uiTmpDigits;
}
// Calculate the hex digits for the minimum number.
uiTmpDigits = 3; // Accounts for at least "0x" and one digit
uiTmp = ((FLMUINT)m_iMin) >> 4;
while (uiTmp)
{
uiTmp >>= 4;
uiTmpDigits++;
}
if (uiTmpDigits > m_uiMaxEditChars)
{
m_uiMaxEditChars = uiTmpDigits;
}
// Finally, if the width is greater, set it as the maximum
// edit characters.
if (uiWidth > m_uiMaxEditChars)
{
m_uiMaxEditChars = uiWidth;
}
m_uiRow = uiRow;
m_uiColumn = uiColumn;
m_uiWidth = uiWidth;
m_uiFormat = uiFormat;
m_bDisplayOnly = bDisplayOnly;
setBackColor( uiBackColor);
setForeColor( uiForeColor);
Exit:
return( rc);
}
/*===========================================================================
Desc: Set the current value for a signed object in a form.
===========================================================================*/
RCODE FlmFormSignedObject::setValue(
FLMINT iValue
)
{
RCODE rc = FERR_OK;
if (iValue < m_iMin || iValue > m_iMax)
{
flmAssert( 0);
rc = RC_SET( FERR_CONV_DEST_OVERFLOW);
}
m_iValue = iValue;
//Exit:
return( rc);
}
/*===========================================================================
Desc: Gets the current value for a signed object in a form.
===========================================================================*/
RCODE FlmFormSignedObject::getValue(
FLMINT * piValue
)
{
*piValue = m_iValue;
return( FERR_OK);
}
/*===========================================================================
Desc: Converts the text and verifies that it is a proper signed value.
===========================================================================*/
FLMBOOL FlmFormSignedObject::verifyValue(
char * pszEditBuf,
FLMINT * piValue)
{
FLMBOOL bOk = TRUE;
FLMUINT uiValue = 0;
FLMINT iValue;
char szErrMsg [100];
FLMBOOL bNegative;
// Convert the value - using HEX or decimal.
if ((*pszEditBuf == '0') &&
((*(pszEditBuf + 1) == 'x') ||
(*(pszEditBuf + 1) == 'X')))
{
pszEditBuf += 2;
if (!(*pszEditBuf))
{
bOk = FALSE;
m_pForm->beep( "Invalid HEX number");
goto Exit;
}
// Hex conversion
while (*pszEditBuf)
{
if (((*pszEditBuf >= '0') && (*pszEditBuf <= '9')) ||
((*pszEditBuf >= 'A') && (*pszEditBuf <= 'F')) ||
((*pszEditBuf >= 'a') && (*pszEditBuf <= 'f')))
{
if (uiValue > 0x0FFFFFFF)
{
bOk = FALSE;
m_pForm->beep( "HEX number is too large");
goto Exit;
}
uiValue <<= 4;
if ((*pszEditBuf >= '0') && (*pszEditBuf <= '9'))
{
uiValue += (FLMUINT)(*pszEditBuf - '0');
}
else if ((*pszEditBuf >= 'A') && (*pszEditBuf <= 'F'))
{
uiValue += (FLMUINT)(*pszEditBuf - 'A' + 10);
}
else
{
uiValue += (FLMUINT)(*pszEditBuf - 'a' + 10);
}
}
else
{
m_pForm->beep( "Invalid digit in HEX number");
bOk = FALSE;
goto Exit;
}
pszEditBuf++;
}
iValue = (FLMINT)uiValue;
}
else
{
if (*pszEditBuf == '-')
{
bNegative = TRUE;
pszEditBuf++;
}
else
{
bNegative = FALSE;
}
// Decimal conversion
while (*pszEditBuf)
{
if ((*pszEditBuf >= '0') && (*pszEditBuf <= '9'))
{
if (((!bNegative) && (uiValue > (0x7FFFFFFF / 10))) ||
((bNegative) && (uiValue > (0x80000000 / 10))))
{
Too_Large_Error:
bOk = FALSE;
if (!bNegative)
{
m_pForm->beep( "Decimal number is too large");
}
else
{
m_pForm->beep( "Negative decimal number is too small");
}
goto Exit;
}
uiValue *= 10;
if (((!bNegative) &&
(uiValue > 0x7FFFFFFF - (FLMUINT)(*pszEditBuf - '0'))) ||
((bNegative) &&
(uiValue > 0x80000000 - (FLMUINT)(*pszEditBuf - '0'))))
{
goto Too_Large_Error;
}
uiValue += (FLMUINT)(*pszEditBuf - '0');
}
else
{
m_pForm->beep( "Invalid digit in number");
bOk = FALSE;
goto Exit;
}
pszEditBuf++;
}
iValue = (FLMINT)uiValue;
if ((bNegative) && (uiValue != 0x80000000))
{
iValue = -iValue;
}
}
if ((iValue < m_iMin) || (iValue > m_iMax))
{
f_sprintf( (char *)szErrMsg, "Value must be >= %u and <= %u",
(unsigned)m_iMin, (unsigned)m_iMax);
m_pForm->beep( szErrMsg);
bOk = FALSE;
goto Exit;
}
*piValue = iValue;
Exit:
return( bOk);
}
/*===========================================================================
Desc: Displays the current value for a signed object in a form.
===========================================================================*/
void FlmFormSignedObject::display(
FLMUINT uiDisplayRow,
FLMUINT uiDisplayColumn
)
{
char szValue [20];
formatEditBuffer( szValue);
outputText( szValue, uiDisplayRow, uiDisplayColumn);
}
/*===========================================================================
Desc: Formats the current value into an edit buffer that will be used to
edit the object.
===========================================================================*/
void FlmFormSignedObject::formatEditBuffer(
char * pszEditBuf)
{
char szFormat [10];
if (m_uiFormat & (FORMAT_UPPER_HEX | FORMAT_LOWER_HEX))
{
if (m_uiFormat & FORMAT_ZERO_LEAD)
{
if (m_uiFormat & FORMAT_UPPER_HEX)
{
f_sprintf( (char *)szFormat, "0x%%0%uX", (unsigned)m_uiWidth);
}
else
{
f_sprintf( (char *)szFormat, "0x%%0%ux", (unsigned)m_uiWidth);
}
f_sprintf( (char *)pszEditBuf, "%s%d", (char *)szFormat, (int)m_iValue);
}
else if (m_uiFormat & FORMAT_UPPER_HEX)
{
f_sprintf( (char *)pszEditBuf, "0x%X", (unsigned)m_iValue);
}
else
{
f_sprintf( (char *)pszEditBuf, "0x%x", (unsigned)m_iValue);
}
}
else
{
if (m_uiFormat & FORMAT_ZERO_LEAD)
{
f_sprintf( (char *)szFormat, "%%0%ud", (unsigned)m_uiWidth);
f_sprintf( (char *)pszEditBuf, "%s%d", (char *)szFormat, (int)m_iValue);
}
else
{
f_sprintf( (char *)pszEditBuf, "%u", (unsigned)m_iValue);
}
}
}
/*===========================================================================
Desc: Formats the current value into an the return address, if any.
===========================================================================*/
RCODE FlmFormSignedObject::populateReturnAddress( void)
{
RCODE rc = FERR_OK;
if (m_pvReturnAddress)
{
rc = getValue( (FLMINT *)m_pvReturnAddress);
}
return( rc);
}
/*===========================================================================
Desc: Formats the current value into an node in the tree, if any.
===========================================================================*/
RCODE FlmFormSignedObject::populateReturnPath(
POOL * pPool,
NODE * pTree)
{
RCODE rc = FERR_OK;
NODE * pNode;
FLMINT iValue;
if (m_uiReturnPath [0])
{
if ((pNode = findPath( pPool, pTree)) != NULL)
{
if (RC_OK( rc = getValue( &iValue)))
{
rc = GedPutINT( pPool, pNode, iValue);
}
}
}
return( rc);
}
/*===========================================================================
Desc: Initializes variables
===========================================================================*/
FlmFormRecordObject::FlmFormRecordObject()
{
m_pszTitle = NULL;
m_bAutoEnter = TRUE;
m_hDb = HFDB_NULL;
m_uiContainer = FLM_DATA_CONTAINER;
GedPoolInit( &m_pool, 512);
m_pRecord = NULL;
m_uiFirstNode = 0;
m_uiCurrNode = 0;
}
FlmFormRecordObject::~FlmFormRecordObject()
{
GedPoolFree( &m_pool);
if (m_pszTitle)
{
f_free( &m_pszTitle);
}
}
/*===========================================================================
Desc: Sets up a GEDCOM record object on a form.
===========================================================================*/
RCODE FlmFormRecordObject::setup(
FlmForm * pForm,
FLMUINT uiObjectId,
const char * pszTitle,
FLMUINT uiWidth,
FLMUINT uiBackColor,
FLMUINT uiForeColor,
FLMUINT uiRow,
FLMUINT uiColumn)
{
RCODE rc = FERR_OK;
FLMUINT uiLen;
if (m_pForm)
{
flmAssert( 0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
m_pForm = pForm;
m_eObjectType = FORM_RECORD_OBJECT;
m_uiObjectId = uiObjectId;
m_uiMaxEditChars = 16;
if (m_uiMaxEditChars < uiWidth)
{
m_uiMaxEditChars = uiWidth;
}
m_uiRow = uiRow;
m_uiColumn = uiColumn;
m_uiWidth = uiWidth;
m_bDisplayOnly = FALSE;
setBackColor( uiBackColor);
setForeColor( uiForeColor);
if (pszTitle && *pszTitle)
{
uiLen = f_strlen( pszTitle);
if( RC_BAD( rc = f_alloc( uiLen + 1, &m_pszTitle)))
{
goto Exit;
}
f_memcpy( m_pszTitle, pszTitle, uiLen + 1);
}
Exit:
return( rc);
}
/*===========================================================================
Desc: Set the current value for a GEDCOM record object in a form.
===========================================================================*/
RCODE FlmFormRecordObject::setValue(
NODE * pRecord
)
{
RCODE rc = FERR_OK;
GedPoolReset( &m_pool, NULL);
if (!pRecord)
{
m_pRecord = NULL;
}
else
{
if ((m_pRecord = GedCopy( &m_pool, GED_FOREST, pRecord)) == NULL)
{
GedPoolReset( &m_pool, NULL);
rc = RC_SET( FERR_MEM);
goto Exit;
}
}
Exit:
return( rc);
}
/*===========================================================================
Desc: Gets the current value for a GEDCOM record object in a form.
===========================================================================*/
RCODE FlmFormRecordObject::getValue(
NODE * * ppRecordValue,
POOL * pPool)
{
RCODE rc = FERR_OK;
if (!m_pRecord)
{
*ppRecordValue = NULL;
}
else
{
if ((*ppRecordValue = GedCopy( pPool, GED_FOREST, m_pRecord)) == NULL)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
}
Exit:
return( rc);
}
/*===========================================================================
Desc: Displays the current value for a GEDCOM record object in a form.
===========================================================================*/
void FlmFormRecordObject::display(
FLMUINT uiDisplayRow,
FLMUINT uiDisplayColumn
)
{
char szValue [200];
formatEditBuffer( szValue);
outputText( szValue, uiDisplayRow, uiDisplayColumn);
}
/*===========================================================================
Desc: Formats the current value into an edit buffer that will be used to
edit the object.
===========================================================================*/
void FlmFormRecordObject::formatEditBuffer(
char * pszEditBuf)
{
if (m_pszTitle && *m_pszTitle)
{
f_strcpy( pszEditBuf, m_pszTitle);
}
else
{
*pszEditBuf = 0;
}
}
/*===========================================================================
Desc: Formats the current value into an the return address, if any.
===========================================================================*/
RCODE FlmFormRecordObject::populateReturnAddress( void)
{
RCODE rc = FERR_OK;
if (m_pvReturnAddress)
{
rc = getValue( (NODE * *)m_pvReturnAddress, (POOL *)m_puiReturnLen);
}
return( rc);
}
/*===========================================================================
Desc: Formats the current value into an node in the tree, if any.
===========================================================================*/
RCODE FlmFormRecordObject::populateReturnPath(
POOL * pPool,
NODE * pTree)
{
RCODE rc = FERR_OK;
NODE * pNode;
NODE * pTmpNode;
NODE * pTmpNode2;
NODE * pLastSib;
if (m_uiReturnPath [0])
{
if ((pNode = findPath( pPool, pTree)) != NULL)
{
// Clip out any previous children.
if (GedChild( pNode))
{
GedClip( GED_FOREST, GedChild( pNode));
}
// Graft in the new nodes as a forest of children.
pTmpNode = m_pRecord;
pLastSib = NULL;
while (pTmpNode)
{
if ((pTmpNode2 = GedCopy( pPool, GED_TREE, pTmpNode)) == NULL)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
if (pLastSib)
{
GedSibGraft( pLastSib, pTmpNode2, GED_LAST);
}
else
{
GedChildGraft( pNode, pTmpNode2, GED_LAST);
}
pLastSib = pTmpNode2;
pTmpNode = GedSibNext( pTmpNode);
}
}
}
Exit:
return( rc);
}
/****************************************************************************
Name: flintRecEditKeyHook
Desc: Keyboard callback for edit records within a form.
*****************************************************************************/
FSTATIC RCODE flintRecEditKeyHook(
F_RecEditor * pRecEditor,
NODE * pCurNd,
FLMUINT uiKeyIn,
void * UserData,
FLMUINT * puiKeyOut
)
{
F_UNREFERENCED_PARM( pCurNd);
F_UNREFERENCED_PARM( pRecEditor);
*((FLMUINT *)UserData) = uiKeyIn;
switch (uiKeyIn)
{
case WPK_TAB:
case WPK_STAB:
case WPK_LEFT:
case WPK_RIGHT:
if (puiKeyOut)
{
*puiKeyOut = WPK_ESCAPE;
}
break;
default:
if (puiKeyOut)
{
*puiKeyOut = uiKeyIn;
}
break;
}
return( FERR_OK);
}
/*===========================================================================
Desc: Pops into the editor for the GEDCOM record.
===========================================================================*/
FLMUINT FlmFormRecordObject::edit(
FLMBOOL * pbChanged
)
{
FLMUINT uiExitChar = 0;
FTX_SCREEN_p pScreen = m_pForm->getScreen();
F_RecEditor * pRecEditor = NULL;
POOL tmpPool;
NODE * pFirstRecord;
NODE * pTmpRecord;
NODE * pCopyRecord;
NODE * pLastCopiedRecord;
NODE * pCurrentNode;
NODE * pFirstNode;
FLMUINT uiCurrNode;
FLMUINT uiFirstNode;
FLMUINT uiNumRows;
FLMUINT uiNumCols;
FLMBOOL bHaveFirstNode;
FLMBOOL bHaveCurrNode;
*pbChanged = FALSE;
GedPoolInit( &tmpPool, 512);
if (RC_BAD( getValue( &pTmpRecord, &tmpPool)))
{
goto Exit;
}
if (FTXScreenGetSize( pScreen, &uiNumCols, &uiNumRows) != FTXRC_SUCCESS)
{
goto Exit;
}
if ((pRecEditor = new F_RecEditor) == NULL)
{
goto Exit;
}
if (RC_BAD( pRecEditor->Setup( pScreen)))
{
goto Exit;
}
pRecEditor->setTitle( m_pszTitle);
pRecEditor->setKeyHook( flintRecEditKeyHook, (void *)&uiExitChar);
pRecEditor->setTree( pTmpRecord);
pRecEditor->setDefaultSource( m_hDb, m_uiContainer);
pRecEditor->setShutdown( m_pForm->getThread()->getShutdownFlagAddr());
// Get a pointer to the current node - using the ordinal position
// that was previously saved.
pCurrentNode = pFirstNode = pTmpRecord;
uiCurrNode = m_uiCurrNode;
uiFirstNode = m_uiFirstNode;
flmAssert( uiCurrNode >= uiFirstNode);
while (pCurrentNode && uiCurrNode)
{
uiCurrNode--;
pCurrentNode = pCurrentNode->next;
if (uiFirstNode)
{
uiFirstNode--;
pFirstNode = pCurrentNode;
}
}
if (pCurrentNode)
{
pRecEditor->setCurrentNode( pCurrentNode);
}
if (pFirstNode)
{
pRecEditor->setFirstNode( pFirstNode);
}
pRecEditor->interactiveEdit( 3, 3, uiNumCols - 6, uiNumRows - 6, TRUE, TRUE);
if (uiExitChar == WPK_ESCAPE)
{
uiExitChar = 0;
}
else
{
// Locate the first record - in case some were inserted.
pCurrentNode = pRecEditor->getCurrentNode();
pFirstNode = pRecEditor->getFirstNode();
pFirstRecord = pTmpRecord = pRecEditor->getRootNode( pCurrentNode);
for (;;)
{
if ((pTmpRecord = GedSibPrev( pTmpRecord)) == NULL)
{
break;
}
pFirstRecord = pTmpRecord;
}
// Determine the ordinal position of the first and current node.
m_uiCurrNode = 0;
m_uiFirstNode = 0;
uiCurrNode = 0;
bHaveFirstNode = bHaveCurrNode = FALSE;
pTmpRecord = pFirstRecord;
while (pTmpRecord)
{
if (pTmpRecord == pCurrentNode)
{
m_uiCurrNode = uiCurrNode;
bHaveCurrNode = TRUE;
}
else if (pTmpRecord == pFirstNode)
{
m_uiFirstNode = uiCurrNode;
bHaveFirstNode = TRUE;
}
if (bHaveFirstNode && bHaveCurrNode)
{
break;
}
pTmpRecord = pRecEditor->getNextNode( pTmpRecord, FALSE);
uiCurrNode++;
}
// Copy the records back into the form record object. While
// copying them back, see if any of them were changed.
GedPoolReset( &m_pool, NULL);
m_pRecord = NULL;
pLastCopiedRecord = NULL;
pTmpRecord = pFirstRecord;
while (pTmpRecord)
{
if (pRecEditor->isRecordModified( pTmpRecord))
{
*pbChanged = TRUE;
}
// Copy the record into the form object.
pRecEditor->copyCleanRecord( &m_pool, pTmpRecord, &pCopyRecord);
if (pLastCopiedRecord)
{
GedSibGraft( pLastCopiedRecord, pCopyRecord, GED_LAST);
}
else
{
m_pRecord = pCopyRecord;
}
pLastCopiedRecord = pCopyRecord;
// Go to the next record.
pTmpRecord = GedSibNext( pTmpRecord);
}
}
Exit:
if (pRecEditor)
{
pRecEditor->Release();
}
GedPoolFree( &tmpPool);
return( uiExitChar);
}
/*===========================================================================
Desc: Initializes variables
===========================================================================*/
FlmFormPulldownObject::FlmFormPulldownObject()
{
m_pPulldown = NULL;
m_bAutoEnter = TRUE;
m_bReturnAll = FALSE;
m_uiItemIdTag = 0;
m_uiItemNameTag = 0;
}
FlmFormPulldownObject::~FlmFormPulldownObject()
{
if (m_pPulldown)
{
m_pPulldown->Release();
}
}
/*===========================================================================
Desc: Sets up a pulldown object on a form.
===========================================================================*/
RCODE FlmFormPulldownObject::setup(
FlmForm * pForm,
FLMUINT uiObjectId,
FLMUINT uiWidth,
FLMUINT uiHeight,
FLMUINT uiBackColor,
FLMUINT uiForeColor,
FLMUINT uiRow,
FLMUINT uiColumn
)
{
RCODE rc = FERR_OK;
F_UNREFERENCED_PARM( uiHeight);
if (m_pForm)
{
flmAssert( 0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
m_pForm = pForm;
m_eObjectType = FORM_PULLDOWN_OBJECT;
m_uiObjectId = uiObjectId;
m_uiMaxEditChars = 16;
if (m_uiMaxEditChars < uiWidth)
{
m_uiMaxEditChars = uiWidth;
}
if ((m_pPulldown = new FlmPulldownList) == NULL)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
m_pPulldown->setBackColor( uiBackColor);
m_pPulldown->setForeColor( uiForeColor);
m_uiRow = uiRow;
m_uiColumn = uiColumn;
m_uiWidth = uiWidth;
setBackColor( uiBackColor);
setForeColor( uiForeColor);
Exit:
return( rc);
}
/*===========================================================================
Desc: Sets the current item for a pulldown object on a form.
===========================================================================*/
RCODE FlmFormPulldownObject::setCurrentItem(
FLMUINT uiItemId
)
{
RCODE rc = FERR_OK;
if (!m_pPulldown)
{
flmAssert( 0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
rc = m_pPulldown->setCurrentItem( uiItemId);
Exit:
return( rc);
}
/*===========================================================================
Desc: Gets the current item for a pulldown object on a form.
===========================================================================*/
RCODE FlmFormPulldownObject::getCurrentItem(
FLMUINT * puiItemId
)
{
RCODE rc = FERR_OK;
if (!m_pPulldown)
{
flmAssert( 0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
rc = m_pPulldown->getCurrentItem( puiItemId);
Exit:
return( rc);
}
/*===========================================================================
Desc: Adds an item to a pulldown object on a form.
===========================================================================*/
RCODE FlmFormPulldownObject::addItem(
FLMUINT uiItemId,
const char * pszDisplayValue,
FLMUINT uiShortcutKey)
{
RCODE rc = FERR_OK;
if (!m_pPulldown)
{
flmAssert( 0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
rc = m_pPulldown->addItem( uiItemId, pszDisplayValue, uiShortcutKey,
NULL, NULL, NULL);
Exit:
return( rc);
}
/*===========================================================================
Desc: Adds an item from a pulldown object on a form.
===========================================================================*/
RCODE FlmFormPulldownObject::removeItem(
FLMUINT uiItemId
)
{
RCODE rc = FERR_OK;
if (!m_pPulldown)
{
flmAssert( 0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
rc = m_pPulldown->removeItem( uiItemId);
Exit:
return( rc);
}
/*===========================================================================
Desc: Removes all items from a pulldown object on a form.
===========================================================================*/
RCODE FlmFormPulldownObject::clearItems( void)
{
RCODE rc = FERR_OK;
if (!m_pPulldown)
{
flmAssert( 0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
rc = m_pPulldown->clearItems();
Exit:
return( rc);
}
/*===========================================================================
Desc: Displays the current value for a pulldown object in a form.
===========================================================================*/
void FlmFormPulldownObject::display(
FLMUINT uiDisplayRow,
FLMUINT uiDisplayColumn
)
{
char szValue [80];
formatEditBuffer( szValue);
outputText( szValue, uiDisplayRow, uiDisplayColumn);
}
/*===========================================================================
Desc: Formats the current value into an edit buffer that will be used to
edit the object.
===========================================================================*/
void FlmFormPulldownObject::formatEditBuffer(
char * pszEditBuf)
{
FLMUINT uiItemId;
FLMUINT uiLen;
if (RC_BAD( m_pPulldown->getCurrentItem( &uiItemId)))
{
*pszEditBuf = 0;
}
else
{
uiLen = m_uiMaxEditChars + 1;
m_pPulldown->getItemDispValue( uiItemId, &uiLen, pszEditBuf);
}
}
/*===========================================================================
Desc: Formats the current value into an the return address, if any.
===========================================================================*/
RCODE FlmFormPulldownObject::populateReturnAddress( void)
{
RCODE rc = FERR_OK;
if (m_pvReturnAddress)
{
rc = getCurrentItem( (FLMUINT *)m_pvReturnAddress);
}
return( rc);
}
/*===========================================================================
Desc: Formats the current value into an node in the tree, if any.
===========================================================================*/
RCODE FlmFormPulldownObject::populateReturnPath(
POOL * pPool,
NODE * pTree)
{
RCODE rc = FERR_OK;
NODE * pNode;
FLMUINT uiValue;
FLMUINT uiItemId;
if (m_uiReturnPath [0])
{
if ((pNode = findPath( pPool, pTree)) != NULL)
{
if (m_bReturnAll)
{
// Clip out any previous children.
if (GedChild( pNode))
{
GedClip( GED_FOREST, GedChild( pNode));
}
// Graft in the new nodes as a forest of children
// list of IDs are the immediate children. Underneat
// each ID node is the name node.
if (RC_OK( m_pPulldown->getFirstItem( &uiItemId)))
{
for (;;)
{
FLMUINT uiLen;
char * pszName;
NODE * pIdNode;
NODE * pNameNode;
// Create the ID node.
if ((pIdNode = GedNodeMake( pPool, m_uiItemIdTag,
&rc)) == NULL)
{
break;
}
if (RC_BAD( rc = GedPutUINT( pPool, pIdNode, uiItemId)))
{
break;
}
// Create the name node.
if ((pNameNode = GedNodeMake( pPool, m_uiItemNameTag,
&rc)) == NULL)
{
break;
}
GedChildGraft( pIdNode, pNameNode, GED_LAST);
m_pPulldown->getItemDispValue( uiItemId, &uiLen, NULL);
uiLen++;
if ((pszName = (char *)GedAllocSpace( pPool,
pNameNode, FLM_TEXT_TYPE,
uiLen)) == NULL)
{
rc = RC_SET( FERR_MEM);
break;
}
m_pPulldown->getItemDispValue( uiItemId, &uiLen, pszName);
GedChildGraft( pNode, pIdNode, GED_LAST);
// Go to the next item in the list.
if (RC_BAD( m_pPulldown->getNextItem( uiItemId, &uiItemId)))
{
break;
}
}
}
}
else
{
if (RC_OK( rc = getCurrentItem( &uiValue)))
{
rc = GedPutRecPtr( pPool, pNode, uiValue);
}
}
}
}
return( rc);
}
/*===========================================================================
Desc: Handles keystrokes for a pulldown box on a form.
===========================================================================*/
FSTATIC FLMBOOL pulldownKeyFunc(
FlmPulldownList * pPulldown,
FLMUINT uiKeyIn,
FLMUINT * puiKeyOut,
void * pvAppData
)
{
FLMBOOL bContinue = TRUE;
F_UNREFERENCED_PARM( pPulldown);
F_UNREFERENCED_PARM( pvAppData);
*puiKeyOut = uiKeyIn;
switch (uiKeyIn)
{
case WPK_TAB:
case WPK_STAB:
case WPK_LEFT:
case WPK_RIGHT:
bContinue = FALSE;
break;
default:
break;
}
return( bContinue);
}
/*===========================================================================
Desc: Enters the editor for the pulldown list and allows the user to
select one of the items from the list.
===========================================================================*/
FLMUINT FlmFormPulldownObject::select( void)
{
FLMUINT uiBoxUpperLeftCol;
FLMUINT uiBoxUpperLeftRow;
FLMUINT uiBoxHeight;
FLMUINT uiBoxWidth;
FLMUINT uiExitChar;
FLMUINT uiExitValue;
FLMUINT uiFormColumns = m_pForm->getColumns();
FLMUINT uiFormRows = m_pForm->getRows();
FTX_SCREEN_p pScreen = m_pForm->getScreen();
FLMBOOL bRedisplay;
for (;;)
{
m_pPulldown->calcEditLocation(
uiFormRows, uiFormColumns,
m_pForm->getEditRow(), m_uiColumn,
m_uiWidth,
&uiBoxWidth, &uiBoxHeight,
&uiBoxUpperLeftCol, &uiBoxUpperLeftRow);
m_pPulldown->interact( pScreen, m_pForm->getThread(),
uiBoxWidth, uiBoxHeight, TRUE,
m_pForm->getUpperLeftColumn() + uiBoxUpperLeftCol,
m_pForm->getUpperLeftRow() + uiBoxUpperLeftRow,
FALSE, 0, &uiExitChar, &uiExitValue, 1,
&bRedisplay, pulldownKeyFunc, NULL);
if (!bRedisplay)
{
break;
}
}
display( m_pForm->getEditRow(), m_uiColumn);
if (uiExitChar == WPK_ENTER)
{
uiExitChar = WPK_TAB;
}
else if (uiExitChar == WPK_ESCAPE)
{
uiExitChar = 0;
}
return( uiExitChar);
}
/*===========================================================================
Desc: Set insert key callback for pulldown object on a form.
===========================================================================*/
void FlmFormPulldownObject::setPulldownInsertCallback(
INSERT_FUNC_p pCallback,
void * pvAppData)
{
if (m_pPulldown)
{
m_pPulldown->setPulldownInsertCallback( pCallback, pvAppData);
}
}
/*===========================================================================
Desc: Initializes variables
===========================================================================*/
FlmPulldownList::FlmPulldownList()
{
m_bMonochrome = FALSE;
m_bInteracting = FALSE;
m_uiBackColor = WPS_BLUE;
m_uiForeColor = WPS_WHITE;
m_pFirstItem = NULL;
m_pLastItem = NULL;
m_pCurrentItem = NULL;
m_pTopItem = NULL;
m_pWindow = NULL;
m_pShortcutKeys = NULL;
m_uiShortcutKeyArraySize = 0;
m_uiNumShortcutKeys = 0;
m_pszTypedownBuf = NULL;
m_uiTypedownBufSize = 0;
m_uiNumTypedownChars = 0;
m_uiMaxTypedownChars = 0;
m_uiDispOffset = 0;
m_pThread = NULL;
m_pszListTitle = NULL;
m_uiListTitleBufSize = 0;
m_uiListTitleBackColor = WPS_BLACK;
m_uiListTitleForeColor = WPS_WHITE;
m_pszListHelp = NULL;
m_uiListHelpBufSize = 0;
m_uiListHelpBackColor = WPS_BLACK;
m_uiListHelpForeColor = WPS_WHITE;
m_pInsertFunc = NULL;
m_pvAppData = NULL;
}
FlmPulldownList::~FlmPulldownList()
{
clearItems();
if (m_pShortcutKeys)
{
f_free( &m_pShortcutKeys);
}
if (m_pszTypedownBuf)
{
f_free( &m_pszTypedownBuf);
}
if (m_pWindow)
{
(void)FTXWinFree( &m_pWindow);
}
if (m_pszListTitle)
{
f_free( &m_pszListTitle);
}
if (m_pszListHelp)
{
f_free( &m_pszListHelp);
}
}
/*===========================================================================
Desc: Finds an item by the item ID.
===========================================================================*/
FlmPulldownItem * FlmPulldownList::findItem(
FLMUINT uiItemId
)
{
FlmPulldownItem * pItem;
pItem = m_pFirstItem;
while (pItem)
{
if (pItem->uiItemId == uiItemId)
{
break;
}
pItem = pItem->pNext;
}
return( pItem);
}
/*===========================================================================
Desc: Sets the title for the pulldown list.
===========================================================================*/
RCODE FlmPulldownList::setTitle(
const char * pszListTitle,
FLMUINT uiBackColor,
FLMUINT uiForeColor)
{
RCODE rc = FERR_OK;
char * pszTmp;
FLMUINT uiLen;
if (!pszListTitle || !(*pszListTitle))
{
if (m_pszListTitle)
{
f_free( &m_pszListTitle);
}
m_pszListTitle = NULL;
m_uiListTitleBufSize = 0;
}
else
{
uiLen = f_strlen( pszListTitle);
if (m_uiListTitleBufSize < uiLen + 1)
{
if( RC_BAD( rc = f_alloc( uiLen + 1, &pszTmp)))
{
goto Exit;
}
if (m_pszListTitle)
{
f_free( &m_pszListTitle);
m_pszListTitle = NULL;
m_uiListTitleBufSize = 0;
}
m_pszListTitle = pszTmp;
m_uiListTitleBufSize = uiLen + 1;
}
f_strcpy( m_pszListTitle, pszListTitle);
}
m_uiListTitleBackColor = uiBackColor;
m_uiListTitleForeColor = uiForeColor;
Exit:
return( rc);
}
/*===========================================================================
Desc: Sets the help for the pulldown list.
===========================================================================*/
RCODE FlmPulldownList::setHelp(
const char * pszListHelp,
FLMUINT uiBackColor,
FLMUINT uiForeColor)
{
RCODE rc = FERR_OK;
char * pszTmp;
FLMUINT uiLen;
if (!pszListHelp || !(*pszListHelp))
{
if (m_pszListHelp)
{
f_free( &m_pszListHelp);
}
m_pszListHelp = NULL;
m_uiListHelpBufSize = 0;
}
else
{
uiLen = f_strlen( pszListHelp);
if (m_uiListHelpBufSize < uiLen + 1)
{
if( RC_BAD( rc = f_alloc( uiLen + 1, &pszTmp)))
{
goto Exit;
}
if (m_pszListHelp)
{
f_free( &m_pszListHelp);
m_pszListHelp = NULL;
m_uiListHelpBufSize = 0;
}
m_pszListHelp = pszTmp;
m_uiListHelpBufSize = uiLen + 1;
}
f_strcpy( m_pszListHelp, pszListHelp);
}
m_uiListHelpBackColor = uiBackColor;
m_uiListHelpForeColor = uiForeColor;
Exit:
return( rc);
}
/*===========================================================================
Desc: Sets the current item for a pulldown list.
===========================================================================*/
RCODE FlmPulldownList::setCurrentItem(
FLMUINT uiItemId
)
{
RCODE rc = FERR_OK;
FlmPulldownItem * pItem;
if (!uiItemId)
{
m_pCurrentItem = m_pFirstItem;
}
else
{
// Find the item
if ((pItem = findItem( uiItemId)) == NULL)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
m_pCurrentItem = pItem;
}
Exit:
return( rc);
}
/*===========================================================================
Desc: Gets the current item for a pulldown list.
===========================================================================*/
RCODE FlmPulldownList::getCurrentItem(
FLMUINT * puiItemId
)
{
RCODE rc = FERR_OK;
if (!m_pCurrentItem)
{
if (!m_pFirstItem)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
m_pCurrentItem = m_pFirstItem;
}
*puiItemId = m_pCurrentItem->uiItemId;
Exit:
return( rc);
}
/*===========================================================================
Desc: Gets the first item in a pulldown list.
===========================================================================*/
RCODE FlmPulldownList::getFirstItem(
FLMUINT * puiItemId
)
{
RCODE rc = FERR_OK;
if (!m_pFirstItem)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
*puiItemId = m_pFirstItem->uiItemId;
Exit:
return( rc);
}
/*===========================================================================
Desc: Gets the last item in a pulldown list.
===========================================================================*/
RCODE FlmPulldownList::getLastItem(
FLMUINT * puiItemId
)
{
RCODE rc = FERR_OK;
if (!m_pLastItem)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
*puiItemId = m_pLastItem->uiItemId;
Exit:
return( rc);
}
/*===========================================================================
Desc: Gets the next item in a pulldown list.
===========================================================================*/
RCODE FlmPulldownList::getNextItem(
FLMUINT uiItemId,
FLMUINT * puiNextItemId
)
{
FlmPulldownItem * pItem;
RCODE rc = FERR_OK;
pItem = m_pFirstItem;
while( pItem)
{
if( pItem->uiItemId == uiItemId)
{
pItem = pItem->pNext;
break;
}
pItem = pItem->pNext;
}
if( !pItem)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
*puiNextItemId = pItem->uiItemId;
Exit:
return( rc);
}
/*===========================================================================
Desc: Gets the previous item in a pulldown list.
===========================================================================*/
RCODE FlmPulldownList::getPrevItem(
FLMUINT uiItemId,
FLMUINT * puiPrevItemId
)
{
FlmPulldownItem * pItem;
RCODE rc = FERR_OK;
pItem = m_pLastItem;
while( pItem)
{
if( pItem->uiItemId == uiItemId)
{
pItem = pItem->pPrev;
break;
}
pItem = pItem->pPrev;
}
if( !pItem)
{
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
*puiPrevItemId = pItem->uiItemId;
Exit:
return( rc);
}
/*===========================================================================
Desc: Gets the display value for an item in the pulldown list.
===========================================================================*/
RCODE FlmPulldownList::getItemDispValue(
FLMUINT uiItemId,
FLMUINT * puiDispBufLen,
char * pszDisplayValue)
{
RCODE rc = FERR_OK;
FlmPulldownItem * pItem;
// Find the item
if ((pItem = findItem( uiItemId)) == NULL)
{
flmAssert( 0);
*pszDisplayValue = 0;
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
if (!pszDisplayValue)
{
*puiDispBufLen = pItem->uiDisplayValueLen;
}
else
{
(*puiDispBufLen)--;
if (*puiDispBufLen > pItem->uiDisplayValueLen)
{
*puiDispBufLen = pItem->uiDisplayValueLen;
}
f_memcpy( pszDisplayValue, pItem->pszDisplayValue, *puiDispBufLen);
pszDisplayValue [*puiDispBufLen] = 0;
}
Exit:
return( rc);
}
/*===========================================================================
Desc: Sets the display value for an item in the pulldown list.
===========================================================================*/
RCODE FlmPulldownList::setDisplayValue(
FLMUINT uiItemId,
const char * pszDisplayValue)
{
RCODE rc = FERR_OK;
FlmPulldownItem * pItem;
FLMUINT uiLen;
char * pszTmp;
// Find the item
if ((pItem = findItem( uiItemId)) == NULL)
{
flmAssert( 0);
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
uiLen = f_strlen( pszDisplayValue);
if (uiLen <= pItem->uiDisplayValueLen)
{
f_strcpy( pItem->pszDisplayValue, pszDisplayValue);
// See if we need to recalculate maximum typedown
// characters.
if (pItem->uiDisplayValueLen >= m_uiMaxTypedownChars)
{
recalcMaxWidth();
}
}
else
{
if( RC_BAD( rc = f_alloc( uiLen + 1, &pszTmp)))
{
goto Exit;
}
f_free( &pItem->pszDisplayValue);
pItem->pszDisplayValue = pszTmp;
f_strcpy( pszTmp, pszDisplayValue);
// See if we need to increase the size of the typedown
// buffer.
if (uiLen + 1 > m_uiTypedownBufSize)
{
if (m_pszTypedownBuf)
{
f_free( &m_pszTypedownBuf);
m_pszTypedownBuf = NULL;
m_uiTypedownBufSize = 0;
}
if( RC_BAD( rc = f_alloc( uiLen + 6, &m_pszTypedownBuf)))
{
f_free( &pItem);
goto Exit;
}
m_uiTypedownBufSize = uiLen + 6;
}
if (uiLen > m_uiMaxTypedownChars)
{
m_uiMaxTypedownChars = uiLen;
}
}
pItem->uiDisplayValueLen = uiLen;
refresh();
Exit:
return( rc);
}
/*===========================================================================
Desc: Recalculates the maximum width for the pulldown list.
===========================================================================*/
void FlmPulldownList::recalcMaxWidth( void)
{
FlmPulldownItem * pItem;
m_uiMaxTypedownChars = 0;
pItem = m_pFirstItem;
while (pItem)
{
if (pItem->uiDisplayValueLen > m_uiMaxTypedownChars)
{
m_uiMaxTypedownChars = pItem->uiDisplayValueLen;
}
pItem = pItem->pNext;
}
}
/*===========================================================================
Desc: Finds the entry for a particular shortcut key.
===========================================================================*/
FlmShortcutKey * FlmPulldownList::findShortcutKey(
FLMUINT uiShortcutKey
)
{
FlmShortcutKey * pShortcutKey;
FLMUINT uiLow;
FLMUINT uiMid;
FLMUINT uiHigh;
FLMUINT uiNumShortcutKeys;
uiShortcutKey = (FLMUINT)f_toupper( uiShortcutKey);
if (m_uiNumShortcutKeys <= 1)
{
pShortcutKey =
(FlmShortcutKey *)(((m_pShortcutKeys) &&
(m_pShortcutKeys [0].uiShortcutKey == uiShortcutKey))
? m_pShortcutKeys
: (FlmShortcutKey *)NULL);
goto Exit;
}
pShortcutKey = NULL;
uiNumShortcutKeys = m_uiNumShortcutKeys - 1;
for (uiHigh = uiNumShortcutKeys, uiLow = 0 ; ; )
{
uiMid = (uiLow + uiHigh) >> 1; // (uiLow + uiHigh) / 2
if (uiShortcutKey == m_pShortcutKeys [uiMid ].uiShortcutKey)
{
// Found a match
pShortcutKey = &m_pShortcutKeys [uiMid];
break;
}
// Check if we are done - where low equals high.
if (uiLow >= uiHigh)
{
break; // Done - item not found.
}
if (uiShortcutKey < m_pShortcutKeys [uiMid ].uiShortcutKey)
{
if (uiMid == 0)
{
break; // Way too high?
}
uiHigh = uiMid - 1; // Too high
}
else
{
if (uiMid == uiNumShortcutKeys)
{
break; // Done - Hit the top
}
uiLow = uiMid + 1; // Too low
}
}
Exit:
return( pShortcutKey);
}
/*===========================================================================
Desc: Records a shortcut key and the item it is pointing to.
===========================================================================*/
RCODE FlmPulldownList::addShortcutKey(
FLMUINT uiShortcutKey,
FlmPulldownItem * pItem
)
{
RCODE rc = FERR_OK;
FlmShortcutKey * pShortcutKey;
FLMUINT uiPos;
FlmShortcutKey TmpShortCut;
uiShortcutKey = (FLMUINT)f_toupper( uiShortcutKey);
// Make sure the shortcut key is not already defined.
if ((pShortcutKey = findShortcutKey( uiShortcutKey)) != NULL)
{
flmAssert( 0);
rc = RC_SET( FERR_EXISTS);
goto Exit;
}
// Make sure we have space to insert the shortcut key
if (m_uiNumShortcutKeys == m_uiShortcutKeyArraySize)
{
if( RC_BAD( rc = f_alloc( sizeof( FlmShortcutKey) *
(m_uiShortcutKeyArraySize + 5), &pShortcutKey)))
{
goto Exit;
}
// Make sure the shortcut is not defined.
if (m_pShortcutKeys)
{
f_memcpy( pShortcutKey, m_pShortcutKeys,
sizeof( FlmShortcutKey) * m_uiShortcutKeyArraySize);
f_free( &m_pShortcutKeys);
}
m_pShortcutKeys = pShortcutKey;
m_uiShortcutKeyArraySize += 5;
}
// Insert the shortcut key at end of list.
pShortcutKey = &m_pShortcutKeys [m_uiNumShortcutKeys];
m_uiNumShortcutKeys++;
pShortcutKey->uiShortcutKey = uiShortcutKey;
pShortcutKey->pItem = pItem;
pItem->uiShortcutKey = uiShortcutKey;
// Bubble key down to where it belongs in the list.
if (m_uiNumShortcutKeys > 1)
{
uiPos = m_uiNumShortcutKeys - 1;
while (uiPos &&
m_pShortcutKeys [m_uiNumShortcutKeys - 1].uiShortcutKey <
m_pShortcutKeys [uiPos - 1].uiShortcutKey)
{
uiPos--;
}
// No need to do anything if the new shortcut is
// already in its place.
if (uiPos < m_uiNumShortcutKeys - 1)
{
// Save new shortcut into a temporary buffer.
f_memcpy( &TmpShortCut, &m_pShortcutKeys [m_uiNumShortcutKeys - 1],
sizeof( FlmShortcutKey));
// Move everything from the insert position to the end of the array
// up one slot.
f_memmove( &m_pShortcutKeys [uiPos + 1], &m_pShortcutKeys [uiPos],
sizeof( FlmShortcutKey) * (m_uiNumShortcutKeys - uiPos - 1));
// Put the new shortcut into its slot in the array.
f_memcpy( &m_pShortcutKeys [uiPos], &TmpShortCut,
sizeof( FlmShortcutKey));
}
}
Exit:
return( rc);
}
/*===========================================================================
Desc: Removes a shortcut key that is pointing to an item.
===========================================================================*/
void FlmPulldownList::removeShortcutKey(
FLMUINT uiShortcutKey
)
{
FlmShortcutKey * pShortcutKey;
FLMUINT uiPos;
uiShortcutKey = (FLMUINT)f_toupper( uiShortcutKey);
// Make sure the shortcut key is defined.
if ((pShortcutKey = findShortcutKey( uiShortcutKey)) == NULL)
{
flmAssert( 0);
}
else
{
// Move everything above that position down by one.
uiPos = (FLMUINT)(pShortcutKey - m_pShortcutKeys);
f_memmove( pShortcutKey, &pShortcutKey [1],
sizeof( FlmShortcutKey) *
(m_uiNumShortcutKeys - uiPos - 1));
m_uiNumShortcutKeys--;
}
}
/*===========================================================================
Desc: Adds an item to a pulldown list.
===========================================================================*/
RCODE FlmPulldownList::addItem(
FLMUINT uiItemId,
const char * pszDisplayValue,
FLMUINT uiShortcutKey,
FlmPulldownList * pSubList,
ITEM_FUNC_p pFunc,
void * pvAppData)
{
RCODE rc = FERR_OK;
FlmPulldownItem * pItem;
FLMUINT uiLen;
// Make sure the item is not already defined.
if ((pItem = findItem( uiItemId)) != NULL)
{
rc = RC_SET( FERR_EXISTS);
goto Exit;
}
// Allocate memory for the new item.
if( RC_BAD( rc = f_alloc( sizeof( FlmPulldownItem), &pItem)))
{
goto Exit;
}
f_memset( pItem, 0, sizeof( FlmPulldownItem));
uiLen = f_strlen( pszDisplayValue);
if( RC_BAD( rc = f_alloc( uiLen + 1, &pItem->pszDisplayValue)))
{
f_free( &pItem);
goto Exit;
}
// See if we need to increase the size of the typedown
// buffer.
if (uiLen + 1 > m_uiTypedownBufSize)
{
if (m_pszTypedownBuf)
{
f_free( &m_pszTypedownBuf);
m_pszTypedownBuf = NULL;
m_uiTypedownBufSize = 0;
}
if( RC_BAD( rc = f_alloc( uiLen + 6, &m_pszTypedownBuf)))
{
f_free( &pItem);
goto Exit;
}
m_uiTypedownBufSize = uiLen + 6;
}
if (uiLen > m_uiMaxTypedownChars)
{
m_uiMaxTypedownChars = uiLen;
}
pItem->uiItemId = uiItemId;
f_memcpy( pItem->pszDisplayValue, pszDisplayValue, uiLen + 1);
pItem->uiDisplayValueLen = uiLen;
pItem->uiShortcutKey = 0;
pItem->pSubList = pSubList;
pItem->pFunc = pFunc;
pItem->pvAppData = pvAppData;
if ((pItem->pPrev = m_pLastItem) == NULL)
{
pItem->uiItemNumber = 1;
m_pFirstItem = pItem;
}
else
{
m_pLastItem->pNext = pItem;
pItem->uiItemNumber = m_pLastItem->uiItemNumber + 1;
}
m_pLastItem = pItem;
if (!m_pCurrentItem)
{
m_pCurrentItem = pItem;
}
if (uiShortcutKey)
{
if (RC_BAD( rc = addShortcutKey( uiShortcutKey, pItem)))
{
removeItem( uiItemId);
goto Exit;
}
}
Exit:
return( rc);
}
/*===========================================================================
Desc: Adds an item to a pulldown list.
===========================================================================*/
RCODE FlmPulldownList::insertItem(
FLMUINT uiPositionItemId,
FLMBOOL bInsertBefore,
FLMUINT uiItemId,
const char * pszDisplayValue,
FLMUINT uiShortcutKey,
FlmPulldownList * pSubList,
ITEM_FUNC_p pFunc,
void * pvAppData)
{
RCODE rc = FERR_OK;
FlmPulldownItem * pItem;
FlmPulldownItem * pPositionItem;
FlmPulldownItem * pBeforeItem;
FlmPulldownItem * pAfterItem;
FLMUINT uiLen;
FLMUINT uiItemNumber;
// Find the position item, if any.
pPositionItem = (FlmPulldownItem *)((uiPositionItemId)
? findItem( uiPositionItemId)
: (FlmPulldownItem *)NULL);
// Make sure the item is not already defined.
if ((pItem = findItem( uiItemId)) != NULL)
{
flmAssert( 0);
rc = RC_SET( FERR_EXISTS);
goto Exit;
}
// Allocate memory for the new item.
if( RC_BAD( rc = f_alloc( sizeof( FlmPulldownItem), &pItem)))
{
goto Exit;
}
f_memset( pItem, 0, sizeof( FlmPulldownItem));
uiLen = f_strlen( pszDisplayValue);
if( RC_BAD( rc = f_alloc( uiLen + 1, &pItem->pszDisplayValue)))
{
f_free( &pItem);
goto Exit;
}
// See if we need to increase the size of the typedown
// buffer.
if (uiLen + 1 > m_uiTypedownBufSize)
{
if (m_pszTypedownBuf)
{
f_free( &m_pszTypedownBuf);
m_pszTypedownBuf = NULL;
m_uiTypedownBufSize = 0;
}
if( RC_BAD( rc = f_alloc( uiLen + 6, &m_pszTypedownBuf)))
{
f_free( &pItem);
goto Exit;
}
m_uiTypedownBufSize = uiLen + 6;
}
if (uiLen > m_uiMaxTypedownChars)
{
m_uiMaxTypedownChars = uiLen;
}
pItem->uiItemId = uiItemId;
f_memcpy( pItem->pszDisplayValue, pszDisplayValue, uiLen + 1);
pItem->uiDisplayValueLen = uiLen;
pItem->uiShortcutKey = 0;
pItem->pSubList = pSubList;
pItem->pFunc = pFunc;
pItem->pvAppData = pvAppData;
if (!pPositionItem)
{
pPositionItem = (FlmPulldownItem *)((bInsertBefore)
? m_pFirstItem
: m_pLastItem);
}
// Determine the before and after items.
if (bInsertBefore)
{
pBeforeItem = (FlmPulldownItem *)((pPositionItem)
? pPositionItem->pPrev
: (FlmPulldownItem *)NULL);
pAfterItem = pPositionItem;
}
else
{
pBeforeItem = pPositionItem;
pAfterItem = (FlmPulldownItem *)((pPositionItem)
? pPositionItem->pNext
: (FlmPulldownItem *)NULL);
}
// Link new item between the before and after items.
if ((pItem->pPrev = pBeforeItem) == NULL)
{
pItem->uiItemNumber = 1;
m_pFirstItem = pItem;
}
else
{
pBeforeItem->pNext = pItem;
pItem->uiItemNumber = pBeforeItem->uiItemNumber + 1;
}
if ((pItem->pNext = pAfterItem) == NULL)
{
m_pLastItem = pItem;
}
else
{
pAfterItem->pPrev = pItem;
}
if (!m_pCurrentItem)
{
m_pCurrentItem = pItem;
}
if (!m_pTopItem)
{
m_pTopItem = pItem;
}
// Renumber everything after the new item.
uiItemNumber = pItem->uiItemNumber + 1;
while (pAfterItem)
{
pAfterItem->uiItemNumber = uiItemNumber++;
pAfterItem = pAfterItem->pNext;
}
// Add the shortcut key, if any.
if (uiShortcutKey)
{
if (RC_BAD( rc = addShortcutKey( uiShortcutKey, pItem)))
{
removeItem( uiItemId);
goto Exit;
}
}
Exit:
return( rc);
}
/*===========================================================================
Desc: Adds shortcut key for a particular item in the list.
===========================================================================*/
RCODE FlmPulldownList::addShortcutKey(
FLMUINT uiItemId,
FLMUINT uiShortcutKey
)
{
RCODE rc = FERR_OK;
FlmPulldownItem * pItem;
// Make sure the item is not already defined.
if ((pItem = findItem( uiItemId)) == NULL)
{
flmAssert( 0);
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
flmAssert( uiShortcutKey);
if (RC_BAD( rc = addShortcutKey( uiShortcutKey, pItem)))
{
goto Exit;
}
Exit:
return( rc);
}
/*===========================================================================
Desc: Removes an item from a pulldown list.
===========================================================================*/
RCODE FlmPulldownList::removeItem(
FLMUINT uiItemId
)
{
RCODE rc = FERR_OK;
FlmPulldownItem * pItem;
FlmPulldownItem * pTmpItem;
FLMUINT uiSaveLen;
if ((pItem = findItem( uiItemId)) == NULL)
{
flmAssert( 0);
rc = RC_SET( FERR_NOT_FOUND);
goto Exit;
}
uiSaveLen = pItem->uiDisplayValueLen;
// If the one we are removing is the current item, adjust
// the current item pointer.
if (m_pCurrentItem == pItem)
{
if ((m_pCurrentItem = pItem->pNext) == NULL)
{
m_pCurrentItem = pItem->pPrev;
}
}
// If the one we are removing is the top item, adjust
// the top item pointer.
if (m_pTopItem == pItem)
{
if ((m_pTopItem = pItem->pNext) == NULL)
{
m_pTopItem = pItem->pPrev;
}
}
// Decrement all of the item numbers of items that come after this
// one.
pTmpItem = pItem->pNext;
while (pTmpItem)
{
pTmpItem->uiItemNumber--;
pTmpItem = pTmpItem->pNext;
}
// Unlink the item from the list.
if (pItem->pNext)
{
pItem->pNext->pPrev = pItem->pPrev;
}
else
{
m_pLastItem = pItem->pPrev;
}
if (pItem->pPrev)
{
pItem->pPrev->pNext = pItem->pNext;
}
else
{
m_pFirstItem = pItem->pNext;
}
if (pItem->pszDisplayValue)
{
f_free( &pItem->pszDisplayValue);
}
if (pItem->uiShortcutKey)
{
removeShortcutKey( pItem->uiShortcutKey);
}
f_free( &pItem);
// See if we need to recalculate maximum typedown
// characters.
if (uiSaveLen >= m_uiMaxTypedownChars)
{
recalcMaxWidth();
}
Exit:
return( rc);
}
/*===========================================================================
Desc: Clears all items from a pulldown list.
===========================================================================*/
RCODE FlmPulldownList::clearItems( void)
{
FlmPulldownItem * pItem;
FlmPulldownItem * pNextItem;
pItem = m_pFirstItem;
while (pItem)
{
pNextItem = pItem->pNext;
if (pItem->pszDisplayValue)
{
f_free( &pItem->pszDisplayValue);
}
f_free( &pItem);
pItem = pNextItem;
}
m_pFirstItem = NULL;
m_pLastItem = NULL;
m_pCurrentItem = NULL;
if (m_pShortcutKeys)
{
f_free( &m_pShortcutKeys);
m_uiShortcutKeyArraySize = 0;
m_uiNumShortcutKeys = 0;
m_pShortcutKeys = NULL;
}
return( FERR_OK);
}
/*===========================================================================
Desc: Display one item in the pulldown list.
===========================================================================*/
void FlmPulldownList::displayItem(
FlmPulldownItem * pItem,
FLMBOOL bIsCurrentItem)
{
FLMUINT uiRow = pItem->uiItemNumber - m_pTopItem->uiItemNumber;
FLMUINT uiLen;
char * pszDisp;
char ucSave;
if (bIsCurrentItem)
{
FTXWinSetBackFore( m_pWindow,
m_bMonochrome ? WPS_WHITE : m_uiForeColor,
m_bMonochrome ? WPS_BLACK : m_uiBackColor);
}
else
{
FTXWinSetBackFore( m_pWindow,
m_bMonochrome ? WPS_BLACK : m_uiBackColor,
m_bMonochrome ? WPS_WHITE : m_uiForeColor);
}
FTXWinSetCursorPos( m_pWindow, 0, uiRow);
if (m_uiDispOffset < pItem->uiDisplayValueLen)
{
uiLen = pItem->uiDisplayValueLen - m_uiDispOffset;
pszDisp = &pItem->pszDisplayValue [m_uiDispOffset];
if (uiLen > m_uiCols)
{
uiLen = m_uiCols;
ucSave = pszDisp [uiLen];
pszDisp [uiLen] = 0;
FTXWinPrintStr( m_pWindow, pszDisp);
pszDisp [uiLen] = ucSave;
}
else
{
FTXWinPrintStr( m_pWindow, pszDisp);
}
}
else
{
uiLen = 0;
}
// Clear the rest of the line
if (uiLen < m_uiCols)
{
FTXWinClearLine( m_pWindow, uiLen, uiRow);
}
if (bIsCurrentItem)
{
if (!m_uiNumTypedownChars || m_uiNumTypedownChars <= m_uiDispOffset)
{
FTXWinSetCursorPos( m_pWindow, 0, uiRow);
}
else if (m_uiNumTypedownChars - m_uiDispOffset <= m_uiCols)
{
FTXWinSetCursorPos( m_pWindow, m_uiNumTypedownChars - m_uiDispOffset, uiRow);
}
else
{
FTXWinSetCursorPos( m_pWindow, m_uiCols, uiRow);
}
}
}
/*===========================================================================
Desc: Refresh the display
===========================================================================*/
void FlmPulldownList::refresh( void)
{
FLMUINT uiCnt;
FlmPulldownItem * pItem;
FLMBOOL bDispCurrent;
if (m_bInteracting)
{
FTXWinSetBackFore( m_pWindow,
m_bMonochrome ? WPS_BLACK : m_uiBackColor,
m_bMonochrome ? WPS_WHITE : m_uiForeColor);
// Clear the screen
(void)FTXWinClear( m_pWindow);
bDispCurrent = FALSE;
for (uiCnt = 0, pItem = m_pTopItem;
uiCnt < m_uiRows && pItem;
uiCnt++, pItem = pItem->pNext)
{
if (pItem == m_pCurrentItem)
{
bDispCurrent = TRUE;
}
else
{
displayItem( pItem, FALSE);
}
}
// Always display the current item last, so that the cursor will
// be positioned on it.
if (bDispCurrent)
{
displayItem( m_pCurrentItem, TRUE);
}
}
}
/*===========================================================================
Desc: Move cursor to the specified item - refresh if necessary.
===========================================================================*/
void FlmPulldownList::positionTo(
FLMUINT uiItemId
)
{
FlmPulldownItem * pItem;
if (m_bInteracting)
{
if ((pItem = findItem( uiItemId)) != NULL)
{
m_uiNumTypedownChars = 0;
positionTo( pItem, FALSE);
}
}
else
{
setCurrentItem( uiItemId);
}
}
/*===========================================================================
Desc: Move cursor to the specified item - refresh if necessary.
===========================================================================*/
void FlmPulldownList::positionTo(
FlmPulldownItem * pItem,
FLMBOOL bForceRefresh
)
{
FLMUINT uiCnt;
FLMUINT uiCounter;
if ((bForceRefresh) ||
((pItem->uiItemNumber < m_pTopItem->uiItemNumber) ||
(pItem->uiItemNumber > m_pTopItem->uiItemNumber + m_uiRows - 1)))
{
m_pCurrentItem = pItem;
if (pItem->uiItemNumber <= m_uiRows)
{
m_pTopItem = m_pFirstItem;
}
else
{
m_pTopItem = m_pCurrentItem;
for (uiCnt = (m_uiRows - 1) / 2, uiCounter = 0;
uiCounter < uiCnt;
uiCounter++)
{
m_pTopItem = m_pTopItem->pPrev;
}
}
refresh();
}
else
{
displayItem( m_pCurrentItem, FALSE);
m_pCurrentItem = pItem;
displayItem( m_pCurrentItem, TRUE);
}
}
/*===========================================================================
Desc: Move cursor down
===========================================================================*/
void FlmPulldownList::cursorDown( void)
{
m_uiNumTypedownChars = 0;
*m_pszTypedownBuf = 0;
if (m_pCurrentItem->pNext)
{
if (m_pCurrentItem->pNext->uiItemNumber - m_pTopItem->uiItemNumber + 1 >
m_uiRows)
{
m_pCurrentItem = m_pCurrentItem->pNext;
m_pTopItem = m_pTopItem->pNext;
refresh();
}
else
{
displayItem( m_pCurrentItem, FALSE);
m_pCurrentItem = m_pCurrentItem->pNext;
displayItem( m_pCurrentItem, TRUE);
}
}
else
{
displayItem( m_pCurrentItem, TRUE);
}
}
/*===========================================================================
Desc: Move cursor up
===========================================================================*/
void FlmPulldownList::cursorUp( void)
{
m_uiNumTypedownChars = 0;
*m_pszTypedownBuf = 0;
if (m_pCurrentItem->pPrev)
{
if (m_pCurrentItem == m_pTopItem)
{
m_pCurrentItem = m_pCurrentItem->pPrev;
m_pTopItem = m_pTopItem->pPrev;
refresh();
}
else
{
displayItem( m_pCurrentItem, FALSE);
m_pCurrentItem = m_pCurrentItem->pPrev;
displayItem( m_pCurrentItem, TRUE);
}
}
else
{
displayItem( m_pCurrentItem, TRUE);
}
}
/*===========================================================================
Desc: Scroll display left
===========================================================================*/
void FlmPulldownList::scrollLeft( void)
{
if (m_uiDispOffset)
{
m_uiDispOffset--;
refresh();
}
}
/*===========================================================================
Desc: Scroll display right
===========================================================================*/
void FlmPulldownList::scrollRight( void)
{
if (m_uiMaxTypedownChars - m_uiDispOffset > m_uiCols)
{
m_uiDispOffset++;
refresh();
}
}
/*===========================================================================
Desc: Move cursor down a page
===========================================================================*/
void FlmPulldownList::pageDown( void)
{
FLMUINT uiCnt;
m_uiNumTypedownChars = 0;
*m_pszTypedownBuf = 0;
if (m_pCurrentItem->uiItemNumber + m_uiRows > m_pLastItem->uiItemNumber)
{
cursorEnd();
}
else
{
uiCnt = m_uiRows;
while (uiCnt)
{
m_pCurrentItem = m_pCurrentItem->pNext;
m_pTopItem = m_pTopItem->pNext;
uiCnt--;
}
refresh();
}
}
/*===========================================================================
Desc: Move cursor up a page
===========================================================================*/
void FlmPulldownList::pageUp( void)
{
FLMUINT uiCnt;
m_uiNumTypedownChars = 0;
*m_pszTypedownBuf = 0;
if (m_pTopItem->uiItemNumber < m_uiRows)
{
cursorHome();
}
else
{
uiCnt = m_uiRows;
while (uiCnt)
{
m_pCurrentItem = m_pCurrentItem->pPrev;
m_pTopItem = m_pTopItem->pPrev;
uiCnt--;
}
refresh();
}
}
/*===========================================================================
Desc: Move cursor to first item
===========================================================================*/
void FlmPulldownList::cursorHome( void)
{
m_uiNumTypedownChars = 0;
*m_pszTypedownBuf = 0;
if (m_pTopItem != m_pFirstItem)
{
m_pCurrentItem = m_pFirstItem;
m_pTopItem = m_pFirstItem;
refresh();
}
else if (m_pCurrentItem != m_pFirstItem)
{
displayItem( m_pCurrentItem, FALSE);
m_pCurrentItem = m_pFirstItem;
displayItem( m_pCurrentItem, TRUE);
}
else
{
displayItem( m_pCurrentItem, TRUE);
}
}
/*===========================================================================
Desc: Move cursor to last item
===========================================================================*/
void FlmPulldownList::cursorEnd( void)
{
m_uiNumTypedownChars = 0;
*m_pszTypedownBuf = 0;
if (m_pLastItem->uiItemNumber - m_pTopItem->uiItemNumber + 1 > m_uiRows)
{
m_pCurrentItem = m_pLastItem;
m_pTopItem = m_pLastItem;
while (m_pLastItem->uiItemNumber - m_pTopItem->uiItemNumber + 1 < m_uiRows)
{
m_pTopItem = m_pTopItem->pPrev;
}
refresh();
}
else if (m_pCurrentItem != m_pLastItem)
{
displayItem( m_pCurrentItem, FALSE);
m_pCurrentItem = m_pLastItem;
displayItem( m_pCurrentItem, TRUE);
}
else
{
displayItem( m_pCurrentItem, TRUE);
}
}
/*===========================================================================
Desc: Move cursor to last item
===========================================================================*/
void FlmPulldownList::backspaceChar( void)
{
FlmPulldownItem * pItem;
if (m_uiNumTypedownChars)
{
m_uiNumTypedownChars--;
m_pszTypedownBuf [m_uiNumTypedownChars] = 0;
if (!m_uiNumTypedownChars)
{
cursorHome();
}
else
{
// See if any of the items match this one
pItem = m_pFirstItem;
while ((pItem) &&
(f_strnicmp( pItem->pszDisplayValue, m_pszTypedownBuf,
m_uiNumTypedownChars) != 0))
{
pItem = pItem->pNext;
}
// If we found something, move to it.
if (pItem)
{
positionTo( pItem, FALSE);
}
else
{
flmAssert( 0);
}
}
}
}
/*===========================================================================
Desc: Perform typedown
===========================================================================*/
void FlmPulldownList::typedown(
FLMUINT uiChar
)
{
FlmPulldownItem * pItem;
// Not a shortcut key, see about typedown.
if (m_uiNumTypedownChars < m_uiMaxTypedownChars)
{
m_pszTypedownBuf [m_uiNumTypedownChars] = (FLMBYTE)uiChar;
m_pszTypedownBuf [m_uiNumTypedownChars + 1] = 0;
// See if any of the items match this one
pItem = m_pFirstItem;
while ((pItem) &&
(f_strnicmp( pItem->pszDisplayValue, m_pszTypedownBuf,
m_uiNumTypedownChars + 1) != 0))
{
pItem = pItem->pNext;
}
// If we found something, move to it.
if (pItem)
{
m_uiNumTypedownChars++;
positionTo( pItem, FALSE);
}
}
}
/*===========================================================================
Desc: See if the key typed is a shortcut. If so, move to that
item.
===========================================================================*/
FLMBOOL FlmPulldownList::shortcutKey(
FLMUINT uiChar
)
{
FlmShortcutKey * pShortcutKey = findShortcutKey( uiChar);
if (!pShortcutKey)
{
return( FALSE);
}
m_uiNumTypedownChars = 0;
*m_pszTypedownBuf = 0;
positionTo( pShortcutKey->pItem, FALSE);
return( TRUE);
}
/*===========================================================================
Desc: Calculates where a pulldown list should be displayed for
editing.
===========================================================================*/
void FlmPulldownList::calcEditLocation(
FLMUINT uiScreenRows,
FLMUINT uiScreenCols,
FLMUINT uiAnchorRow,
FLMUINT uiLeftAnchorCol,
FLMUINT uiAnchorWidth,
FLMUINT * puiBoxWidth,
FLMUINT * puiBoxHeight,
FLMUINT * puiUpperLeftCol,
FLMUINT * puiUpperLeftRow
)
{
FLMUINT uiTotalItems = (FLMUINT)((m_pLastItem)
? m_pLastItem->uiItemNumber
: (FLMUINT)1);
FLMUINT uiMinBoxHeight;
FLMUINT uiMaxBoxHeight;
FLMUINT uiMinBoxWidth;
FLMUINT uiMaxBoxWidth;
FLMUINT uiRightAnchorCol = uiLeftAnchorCol + uiAnchorWidth;
FLMUINT uiTestLeftCol;
FLMUINT uiTestLeftRow;
FLMUINT uiTestWidth;
FLMUINT uiTestHeight;
FLMUINT uiQuadrant;
FLMUINT uiMinWidth;
// Decrement left anchor column by one if it is not zero already.
if (uiLeftAnchorCol)
{
uiLeftAnchorCol--;
}
uiMinWidth = (FLMUINT)((m_pszListTitle)
? (FLMUINT)f_strlen( m_pszListTitle)
: (FLMUINT)0);
if (m_pszListHelp)
{
if (uiMinWidth < f_strlen( m_pszListHelp))
{
uiMinWidth = f_strlen( m_pszListHelp);
}
}
uiMinWidth += 4;
if (!m_pLastItem)
{
uiMinBoxHeight = uiMaxBoxHeight = 5;
uiMinBoxWidth = uiMaxBoxWidth = 15;
}
else
{
uiMinBoxHeight = uiMaxBoxHeight = uiTotalItems + 2;
if (uiMinBoxHeight > 7)
{
uiMinBoxHeight = 7;
}
uiMinBoxWidth = uiMaxBoxWidth = m_uiMaxTypedownChars + 2;
if (uiMinBoxWidth > 15)
{
uiMinBoxWidth = 15;
}
}
if (uiMaxBoxWidth < uiMinWidth)
uiMaxBoxWidth = uiMinWidth;
// Test quadrant to right/down from right side anchor.
uiQuadrant = 1;
for (;; uiQuadrant++)
{
switch (uiQuadrant)
{
case 1: // quadrant to right and down from right side of anchor
uiTestLeftCol = uiRightAnchorCol;
uiTestLeftRow = uiAnchorRow;
uiTestWidth = uiScreenCols - uiRightAnchorCol;
uiTestHeight = uiScreenRows - uiAnchorRow;
break;
case 2: // quadrant to right and up from right side of anchor
uiTestLeftCol = uiRightAnchorCol;
uiTestLeftRow = ((FLMUINT)(uiMaxBoxHeight > uiAnchorRow)
? (FLMUINT)0
: uiAnchorRow + 1 - uiMaxBoxHeight);
uiTestWidth = uiScreenCols - uiRightAnchorCol;
uiTestHeight = uiAnchorRow + 1;
break;
case 3: // quadrant to left and down from left side of anchor
uiTestLeftCol = (FLMUINT)((uiMaxBoxWidth >= uiLeftAnchorCol)
? (FLMUINT)0
: uiLeftAnchorCol + 1 - uiMaxBoxWidth);
uiTestLeftRow = uiAnchorRow;
uiTestWidth = uiLeftAnchorCol + 1;
uiTestHeight = uiScreenRows - uiAnchorRow;
break;
case 4: // quadrant to left and up from left side of anchor
uiTestLeftCol = (FLMUINT)((uiMaxBoxWidth >= uiLeftAnchorCol)
? (FLMUINT)0
: uiLeftAnchorCol + 1 - uiMaxBoxWidth);
uiTestLeftRow = ((FLMUINT)(uiMaxBoxHeight > uiAnchorRow)
? (FLMUINT)0
: uiAnchorRow + 1 - uiMaxBoxHeight);
uiTestWidth = uiLeftAnchorCol + 1;
uiTestHeight = uiAnchorRow + 1;
break;
case 5:
default:
// Try moving anchor column to the left and/or up one column
// at a time and testing the four options above again.
if (uiRightAnchorCol)
{
if ((uiRightAnchorCol > uiLeftAnchorCol + 2) ||
(!uiAnchorRow))
{
uiRightAnchorCol--;
uiQuadrant = 0;
continue;
}
else
{
uiAnchorRow--;
uiQuadrant = 0;
continue;
}
}
else if (uiAnchorRow)
{
uiAnchorRow--;
uiQuadrant = 0;
continue;
}
flmAssert( 0); // We have too small of a screen if we get to here.
break;
}
if ((uiTestHeight >= uiMinBoxHeight) &&
(uiTestWidth >= uiMinBoxWidth))
{
*puiBoxHeight = (FLMUINT)((uiTestHeight >= uiMaxBoxHeight)
? uiMaxBoxHeight
: uiTestHeight);
*puiBoxWidth = (FLMUINT)((uiTestWidth >= uiMaxBoxWidth)
? uiMaxBoxWidth
: uiTestWidth);
*puiUpperLeftCol = uiTestLeftCol;
*puiUpperLeftRow = uiTestLeftRow;
goto Exit;
}
}
Exit:
return;
}
/*===========================================================================
Desc: User interaction with a pulldown list.
===========================================================================*/
RCODE FlmPulldownList::interact(
FTX_SCREEN_p pScreen,
FlmThreadContext * pThread,
FLMUINT uiWidth,
FLMUINT uiHeight,
FLMBOOL bDoBorder,
FLMUINT uiULX,
FLMUINT uiULY,
FLMBOOL bReturnOnShortcut,
FLMUINT uiResponseTimeout,
FLMUINT * puiExitChar,
FLMUINT * puiExitValue,
FLMUINT uiExitValueDepth,
FLMBOOL * pbRedisplay,
LIST_KEY_FUNC_p pKeyFunc,
void * pvAppData
)
{
RCODE rc = FERR_OK;
FLMUINT uiChar;
FLMUINT uiScreenCols;
FLMUINT uiScreenRows;
FLMUINT uiStartTime;
FlmPulldownItem * pSaveCurrentItem;
FLMUINT uiMinWidth;
FLMBOOL bBoxFixed = TRUE;
FLMUINT uiSaveWidth = uiHeight;
FLMUINT uiSaveHeight = uiWidth;
if (pbRedisplay)
{
*pbRedisplay = FALSE;
}
Start_Over:
m_pThread = pThread;
m_pWindow = NULL;
*puiExitChar = 0;
*puiExitValue = 0;
m_bInteracting = TRUE;
m_uiNumTypedownChars = 0;
flmAssert( uiExitValueDepth >= 1);
f_memset( puiExitValue, 0, sizeof( FLMUINT) * uiExitValueDepth);
FTXScreenGetSize( pScreen, &uiScreenCols, &uiScreenRows);
// If either width or height is passed in as zero, we
// need to calculate the box position - put in the center
// of the screen.
if (!uiWidth || !uiHeight)
{
bBoxFixed = FALSE;
uiMinWidth = (FLMUINT)((m_pszListTitle)
? (FLMUINT)f_strlen( m_pszListTitle)
: (FLMUINT)0);
if (m_pszListHelp)
{
if (uiMinWidth < f_strlen( m_pszListHelp))
{
uiMinWidth = f_strlen( m_pszListHelp);
}
}
uiMinWidth += 4;
if (!itemCount())
{
uiWidth = uiMinWidth;
uiHeight = 3;
}
else
{
uiWidth = maxWidth() + 2;
if (uiWidth < uiMinWidth)
{
uiWidth = uiMinWidth;
}
uiHeight = itemCount() + 2;
}
if (uiWidth > uiScreenCols)
{
uiWidth = uiScreenCols;
}
if (uiHeight > uiScreenRows)
{
uiHeight = uiScreenRows;
}
uiULX = (uiScreenCols - uiWidth) / 2;
uiULY = (uiScreenRows - uiHeight) / 2;
if (uiULY < 3)
{
uiULY = 3;
}
if (uiULX < 3)
{
uiULX = 3;
}
if (uiHeight > uiScreenRows - (uiULY * 2))
{
uiHeight = uiScreenRows - (uiULY * 2);
}
if (uiWidth > uiScreenCols - (uiULX * 2))
{
uiWidth = uiScreenCols - (uiULX * 2);
}
}
// Create the display window of the appropriate size.
if (FTXWinInit( pScreen, uiWidth, uiHeight,
&m_pWindow) != FTXRC_SUCCESS)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
// Position the window on the screen.
if (FTXWinMove( m_pWindow, uiULX, uiULY) != FTXRC_SUCCESS)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
// Prevent window from scrolling.
if (FTXWinSetScroll( m_pWindow, FALSE) != FTXRC_SUCCESS)
{
flmAssert( 0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// Don't wrap lines.
if (FTXWinSetLineWrap( m_pWindow, FALSE) != FTXRC_SUCCESS)
{
flmAssert( 0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// Input cursor should not be present initially.
if (FTXWinSetCursorType( m_pWindow,
WPS_CURSOR_INVISIBLE) != FTXRC_SUCCESS)
{
flmAssert( 0);
rc = RC_SET( FERR_FAILURE);
goto Exit;
}
// Set foreground and background color for window.
if (FTXWinSetBackFore( m_pWindow,
m_bMonochrome ? WPS_BLACK : m_uiBackColor,
m_bMonochrome ? WPS_WHITE : m_uiForeColor) != FTXRC_SUCCESS)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
// Clear the window
if (FTXWinClear( m_pWindow) != FTXRC_SUCCESS)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
if (bDoBorder)
{
if (FTXWinDrawBorder( m_pWindow) != FTXRC_SUCCESS)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
if (m_pszListTitle && *m_pszListTitle)
{
FTXWinSetTitle( m_pWindow, m_pszListTitle,
m_uiListTitleBackColor,
m_uiListTitleForeColor);
}
if (m_pszListHelp && *m_pszListHelp)
{
FTXWinSetHelp( m_pWindow, m_pszListHelp,
m_uiListHelpBackColor,
m_uiListHelpForeColor);
}
}
if (FTXWinOpen( m_pWindow) != FTXRC_SUCCESS)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
if (FTXWinGetCanvasSize( m_pWindow, &m_uiCols,
&m_uiRows) != FTXRC_SUCCESS)
{
rc = RC_SET( FERR_MEM);
goto Exit;
}
// Position on the current value
if (!m_pCurrentItem)
{
m_pCurrentItem = m_pFirstItem;
}
pSaveCurrentItem = m_pCurrentItem;
if (m_pCurrentItem)
{
positionTo( m_pCurrentItem, TRUE);
}
FTXWinSetCursorType( m_pWindow,
WPS_CURSOR_VISIBLE | WPS_CURSOR_UNDERLINE);
// Loop forever getting input.
uiStartTime = FLM_GET_TIMER();
FLM_SECS_TO_TIMER_UNITS( uiResponseTimeout, uiResponseTimeout);
for (;;)
{
// See if we have been told to exit.
if ((pThread) &&
(pThread->getShutdownFlag()))
{
uiChar = 0;
*puiExitValue = 0;
goto Exit;
}
// See if the response timeout period has elapsed
if( uiResponseTimeout)
{
if( (FLM_GET_TIMER() - uiStartTime) >= uiResponseTimeout)
{
uiChar = 0;
*puiExitValue = 0;
goto Exit;
}
}
// Need to refresh the input cursor, in case it was changed by
// a callback function.
if (FTXWinTestKB( m_pWindow) == FTXRC_SUCCESS)
{
FTXWinInputChar( m_pWindow, &uiChar);
uiStartTime = FLM_GET_TIMER();
if (pKeyFunc)
{
if (!((*pKeyFunc)( this, uiChar, &uiChar, pvAppData)))
{
if (m_pCurrentItem)
{
*puiExitValue = m_pCurrentItem->uiItemId;
}
goto Exit;
}
}
switch( uiChar)
{
case WPK_INSERT:
if (m_pInsertFunc)
{
char szItemName [100];
FLMUINT uiNewItem;
FLMUINT uiNewShortcutKey;
FLMUINT uiBeforeId;
FLMUINT uiAfterId;
uiBeforeId = (FLMUINT)((m_pCurrentItem &&
m_pCurrentItem->pPrev)
? m_pCurrentItem->pPrev->uiItemId
: (FLMUINT)0);
uiAfterId = (FLMUINT)((m_pCurrentItem &&
m_pCurrentItem->pNext)
? m_pCurrentItem->pNext->uiItemId
: (FLMUINT)0);
if ((*m_pInsertFunc)( this, uiBeforeId, uiAfterId,
&uiNewItem, &uiNewShortcutKey,
szItemName, sizeof( szItemName),
m_pvAppData))
{
if (RC_OK( insertItem( uiBeforeId, FALSE,
uiNewItem, szItemName,
uiNewShortcutKey, NULL,
NULL, NULL)))
{
m_bInteracting = FALSE;
setCurrentItem( uiNewItem);
uiWidth = uiSaveWidth;
uiHeight = uiSaveHeight;
(void)FTXWinFree( &m_pWindow);
m_pWindow = NULL;
if (pbRedisplay)
{
*pbRedisplay = TRUE;
goto Exit;
}
goto Start_Over;
}
}
}
break;
case WPK_DELETE:
if (m_pInsertFunc && m_pCurrentItem)
{
FLMUINT uiItemId = m_pCurrentItem->uiItemId;
FlmPulldownItem * pItem;
if (m_pCurrentItem->pNext)
{
pItem = m_pCurrentItem->pNext;
}
else
{
pItem = m_pCurrentItem->pPrev;
}
removeItem( uiItemId);
m_bInteracting = FALSE;
if (pItem)
{
setCurrentItem( pItem->uiItemId);
}
uiWidth = uiSaveWidth;
uiHeight = uiSaveHeight;
(void)FTXWinFree( &m_pWindow);
m_pWindow = NULL;
if (pbRedisplay)
{
*pbRedisplay = TRUE;
goto Exit;
}
goto Start_Over;
}
break;
case WPK_CTRL_N:
case WPK_DOWN:
case WPK_TAB:
if (m_pCurrentItem)
{
cursorDown();
}
break;
case WPK_CTRL_P:
case WPK_UP:
case WPK_STAB:
if (m_pCurrentItem)
{
cursorUp();
}
break;
case WPK_CTRL_LEFT:
if (m_pCurrentItem)
{
scrollLeft();
}
break;
case WPK_CTRL_RIGHT:
if (m_pCurrentItem)
{
scrollRight();
}
break;
case WPK_PGUP:
if (m_pCurrentItem)
{
pageUp();
}
break;
case WPK_CTRL_DOWN:
case WPK_CTRL_UP:
break;
case WPK_PGDN:
if (m_pCurrentItem)
{
pageDown();
}
break;
case WPK_CTRL_D:
break;
case WPK_CTRL_HOME:
case WPK_HOME:
if (m_pCurrentItem)
{
cursorHome();
}
break;
case WPK_CTRL_END:
case WPK_END:
if (m_pCurrentItem)
{
cursorEnd();
}
break;
case WPK_BACKSPACE:
if (m_pCurrentItem)
{
backspaceChar();
}
break;
case WPK_ENTER:
Process_Key:
if (m_pCurrentItem)
{
*puiExitValue = m_pCurrentItem->uiItemId;
if (m_pCurrentItem->pSubList)
{
FLMUINT uiBoxUpperLeftCol;
FLMUINT uiBoxUpperLeftRow;
FLMUINT uiBoxHeight;
FLMUINT uiBoxWidth;
FLMUINT uiExitChar;
if (bBoxFixed)
{
m_pCurrentItem->pSubList->calcEditLocation(
uiScreenRows, uiScreenCols,
uiULY + 1 + (m_pCurrentItem->uiItemNumber -
m_pTopItem->uiItemNumber),
uiULX, uiWidth,
&uiBoxWidth, &uiBoxHeight,
&uiBoxUpperLeftCol, &uiBoxUpperLeftRow);
}
else
{
uiBoxWidth = 0;
uiBoxHeight = 0;
uiBoxUpperLeftCol = 0;
uiBoxUpperLeftRow = 0;
}
m_pCurrentItem->pSubList->setCurrentItem( 0);
flmAssert( uiExitValueDepth > 1);
if (uiExitValueDepth > 1)
{
m_pCurrentItem->pSubList->interact( pScreen, pThread,
uiBoxWidth, uiBoxHeight, TRUE,
uiBoxUpperLeftCol, uiBoxUpperLeftRow,
bReturnOnShortcut, uiResponseTimeout,
&uiExitChar, &puiExitValue [1],
uiExitValueDepth - 1,
NULL, pKeyFunc, pvAppData);
if (!uiExitChar)
{
uiChar = 0;
goto Exit;
}
if (uiExitChar != WPK_ESCAPE)
{
uiChar = uiExitChar;
goto Exit;
}
}
else
{
goto Exit;
}
}
else if (m_pCurrentItem->pFunc)
{
if (!m_pCurrentItem->pFunc( this,
m_pCurrentItem->uiItemId,
m_pCurrentItem->pvAppData))
{
goto Exit;
}
}
else
{
goto Exit;
}
}
break;
case WPK_ALT_H:
case WPK_CTRL_H:
break; // Help
case WPK_ESCAPE:
m_pCurrentItem = pSaveCurrentItem;
*puiExitValue = 0;
goto Exit;
case 0: // Callback can change key to zero to do nothing.
break;
default:
if (m_pCurrentItem)
{
// First, see if it is a shortcut key.
if (shortcutKey( uiChar))
{
if (bReturnOnShortcut)
{
if (m_pCurrentItem->pSubList ||
m_pCurrentItem->pFunc)
{
goto Process_Key;
}
else
{
*puiExitValue = m_pCurrentItem->uiItemId;
goto Exit;
}
}
}
else
{
typedown( uiChar);
}
}
break;
}
}
else
{
f_sleep( 1);
}
}
Exit:
*puiExitChar = uiChar;
m_pThread = NULL;
if (m_pWindow)
{
(void)FTXWinFree( &m_pWindow);
m_pWindow = NULL;
}
m_bInteracting = FALSE;
return( rc);
}
Reference in New Issue View Git Blame Copy Permalink