MorePalmOS

A development library for developing Palm OS applications

Home
At A Glance
Globals
Funcitons
Types
Files
MoreControl.h
MoreDataMgr.h
MoreDateTime.h
MoreErrorMgr.h
MoreEvent.h
MoreField.h
MoreForm.h
MoreList.h
MoreMacro.h
MoreMemoryMgr.h
MorePalmOS.h
MorePreferences.h
MoreRect.h
MoreStringMgr.h
MoreSystemMgr.h
MoreTable.h
MoreTextMgr.h
MoreTimeMgr.h
MoreTypes.h
MoreVersion.h
MoreWindow.h

MoreField.c

Go to the documentation of this file.

/******************************************************************************
 * MorePalmOS
 * Copyright (c) 2004 Steven Fisher
 *
 * Distributed under the Boost Software License, Version 1.0. See accompanying
 * license file License.txt or <http://www.boost.org/LICENSE_1_0.txt>.
 *
 * http://morepalmos.sourceforge.net
 *
 *   MorePalmOS is the humble begining of an attempt to provide a library for
 *   Palm OS development which works around system bugs, illustrate how to
 *   use system calls, and provide "glue code" for programming Palm OS
 *   applications in a more straightforward way while minimally impacting
 *   code size.
 *****************************************************************************/

#include "MorePrefix.h"
#include "MoreField.h"
#include "MoreForm.h"
#include "MoreMemoryMgr.h"
#include "MoreStringMgr.h"
#include "MorePrivate.h"

#include <Field.h>
#include <MemoryMgr.h>
#include <StringMgr.h>


//-----------------------------------------------------------------------------

#if !MOREPALMOS_MACRO_SIMPLE_FUNCS

FieldType* MFldGetByID( FormType* formP, FrmObjectID_t id )
{
        return ( FieldType* )MFrmGetObjPtrByID( formP, id );
}

FieldType* MFldGetByIdx( FormType* formP, FrmObjectIdx_t idx )
{
        return ( FieldType* )MFrmGetObjPtrByIdx( formP, idx );
}

FieldType* MFldGetByPtr( FrmObject_t* objectP )
{
        return ( FieldType* )( objectP );
}

#endif

//-----------------------------------------------------------------------------

static _rinline void PrvMFldAbandonHandle( MemHandle oldH, MoreSetTextFlags flags )
{
        if ( oldH && ( !( flags & mstLeakOld ) ) )
        {
                MemHandleFree( oldH );
        }
}

static _rinline void PrvMFldRedraw( FieldType* fieldP, MoreSetTextFlags flags )
{
        if ( flags & mstRedraw )
        {
                FldDrawField( fieldP );
        }
}

//-----------------------------------------------------------------------------

Err MFldSetTextFromChars( FieldType* fieldP, const char *s,
                UInt32 len, MoreSetTextFlags flags )
{
        Err err;
        UInt32 size = len + 1;
        MemHandle oldH = FldGetTextHandle( fieldP );
        MemHandle newH = NULL;
        char* p;

        // We've been asked to reuse the old hadnel. Try to do so. 
        if ( ( mstReuseOld & flags ) && ( oldH ) )
        {
                // Sever handle from field before changing it. 
                FldSetTextHandle( fieldP, NULL );
                err = MemHandleResize( oldH, size );
                if ( errNone != err )
                {
                        /* Couldn't resize handle. Reattach it; we'll create a new
                           one instead. */
                        FldSetTextHandle( fieldP, oldH );
                }
                else
                {
                        newH = oldH;
                }
        }

        // Try to allocate a new handle for the text. 
        if ( !newH )
        {
                newH = MemHandleNew( size );
        }

        // If we still don't have a handle, fail. 
        if ( !newH )
        {
                return memErrNotEnoughSpace;
        }

        // Copy stirng into handle. 
        p = ( char * ) MemHandleLock( newH );
        MemMove( p, s, len );
        p [ len ] = 0;
        MemHandleUnlock( newH );

        /* Dispose of the old handle. We do this after copying in case the old
           handle contains the text we're copying. */
        if ( oldH != newH )
                PrvMFldAbandonHandle( oldH, flags );

        // Assign handle to field. 
        FldSetTextHandle( fieldP, newH );

        // Redraw the field if so asked.
        PrvMFldRedraw( fieldP, flags );

        return errNone;
}

Err MFldSetTextFromCharsByID( FormType* formP, FrmObjectID_t fieldID,
                const Char *s, UInt32 len, MoreSetTextFlags flags )
{
        _validate_object_id( formP, fieldID );
        return MFldSetTextFromChars( MFldGetByID( formP, fieldID ), s,
                        len, flags );
}

Err MFldSetTextFromCharsByIdx( FormType* formP, FrmObjectIdx_t fieldIdx,
                const Char *s, UInt32 len, MoreSetTextFlags flags )
{
        _validate_object_idx( formP, fieldIdx );
        return MFldSetTextFromChars( MFldGetByIdx( formP, fieldIdx ), s,
                        len, flags );
}

//-----------------------------------------------------------------------------

Err MFldSetTextFromStr( FieldType* fieldP, const char *s,
                MoreSetTextFlags flags )
{
        return MFldSetTextFromChars( fieldP, s, MStrLen( s ), flags );
}

Err MFldSetTextFromStrByID( FormType* formP, FrmObjectID_t fieldID,
                const Char *s, MoreSetTextFlags flags )
{
        _validate_object_id( formP, fieldID );
        return MFldSetTextFromStr( MFldGetByID( formP, fieldID ), s,
                        flags );
}

Err MFldSetTextFromStrByIdx( FormType* formP, FrmObjectIdx_t fieldIdx,
                const Char *s, MoreSetTextFlags flags )
{
        _validate_object_idx( formP, fieldIdx );
        return MFldSetTextFromStr( MFldGetByIdx( formP, fieldIdx ), s,
                        flags );
}

//-----------------------------------------------------------------------------

Err MFldClearText( FieldType* fieldP, MoreSetTextFlags flags )
{
        _check( fieldP );
        return MFldSetTextFromChars( fieldP, NULL, 0, flags );
}

Err MFldClearTextByID( FormType* formP, FrmObjectID_t fieldID,
                MoreSetTextFlags flags )
{
        _validate_object_id( formP, fieldID );
        return MFldClearText( MFldGetByID( formP, fieldID ), flags );
}

Err MFldClearTextByIdx( FormType* formP, FrmObjectIdx_t fieldIdx,
                MoreSetTextFlags flags )
{
        _validate_object_idx( formP, fieldIdx );
        return MFldClearText( MFldGetByIdx( formP, fieldIdx ), flags );
}
//-----------------------------------------------------------------------------

Err MFldSetTextFromHandle( FieldPtr fieldP, MemHandle text,
                MoreSetTextFlags flags )
{
        Err err;
        if ( mstReuseOld & flags )
        {
                /* We were asked to reuse the old handle, so lock down this handle
                   and pass the text to MFldSetTextFromChars. */
                MemPtr textP;
                UInt16 textSize;
                _validate_field_ptr( fieldP );
                _validate_memhandle( text );
                textSize = MemHandleSize( text );
                textP = MemHandleLock( text );
                err = MFldSetTextFromChars( fieldP, (char*)textP, textSize, flags );
                /* Whether or not MFldSetTextFromChars() fails, we still need to
                   unlock the text handle. */
                MemHandleUnlock( text );
                return err;
        }
        else
        {
                /* We weren't asked to reuse the old handle, so assign the new handle
                   to the field. */
                MemHandle oldH = FldGetTextHandle( fieldP );
                if ( oldH != text ) /* Is this actually a new handle? */
                {
                        FldSetTextHandle( fieldP, text );
                        PrvMFldAbandonHandle( oldH, flags );
                        // Redraw the field if so asked. 
                        PrvMFldRedraw( fieldP, flags );
                }
                return errNone;
        }
}

Err MFldSetTextFromHandleByID( FormType* formP, FrmObjectID_t fieldID,
                MemHandle text, MoreSetTextFlags flags )
{
        _validate_object_id( formP, fieldID );
        return MFldSetTextFromHandle( MFldGetByID( formP, fieldID ), text,
                        flags );
}

Err MFldSetTextFromHandleByIdx( FormType* formP, FrmObjectIdx_t fieldIdx,
                MemHandle text, MoreSetTextFlags flags )
{
        _validate_object_idx( formP, fieldIdx );
        return MFldSetTextFromHandle( MFldGetByIdx( formP, fieldIdx ), text,
                        flags );
}

//---------------------------------------------------------------------------

Copyright © 2004 Steven Fisher