legato_string.h

Go to the documentation of this file.

/*******************************************************************************
* Copyright (C) 2020 Microchip Technology Inc. and its subsidiaries.
*
* Subject to your compliance with these terms, you may use Microchip software
* and any derivatives exclusively with Microchip products. It is your
* responsibility to comply with third party license terms applicable to your
* use of third party software (including open source software) that may
* accompany Microchip software.
*
* THIS SOFTWARE IS SUPPLIED BY MICROCHIP "AS IS". NO WARRANTIES, WHETHER
* EXPRESS, IMPLIED OR STATUTORY, APPLY TO THIS SOFTWARE, INCLUDING ANY IMPLIED
* WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY, AND FITNESS FOR A
* PARTICULAR PURPOSE.
*
* IN NO EVENT WILL MICROCHIP BE LIABLE FOR ANY INDIRECT, SPECIAL, PUNITIVE,
* INCIDENTAL OR CONSEQUENTIAL LOSS, DAMAGE, COST OR EXPENSE OF ANY KIND
* WHATSOEVER RELATED TO THE SOFTWARE, HOWEVER CAUSED, EVEN IF MICROCHIP HAS
* BEEN ADVISED OF THE POSSIBILITY OR THE DAMAGES ARE FORESEEABLE. TO THE
* FULLEST EXTENT ALLOWED BY LAW, MICROCHIP'S TOTAL LIABILITY ON ALL CLAIMS IN
* ANY WAY RELATED TO THIS SOFTWARE WILL NOT EXCEED THE AMOUNT OF FEES, IF ANY,
* THAT YOU HAVE PAID DIRECTLY TO MICROCHIP FOR THIS SOFTWARE.
*******************************************************************************/

/*******************************************************************************
 Module for Microchip Graphics Library - Legato User Interface Library

  Company:
    Microchip Technology Inc.

  File Name:
    legato_string.h

  Summary:
    A string library implementation for the Legato user interface library.  

  Description:
    This is a string library implementation that is used internally by the 
    Legato user interface library.  
    
    This implementation relies on the leChar definition for characters.  
    This chararcter definition is 16 bits in size and allows the library to
    support international character code points and Unicode encoding standards.
*******************************************************************************/

#ifndef LEGATO_STRING_H
#define LEGATO_STRING_H

#include "gfx/legato/common/legato_common.h"

#include "gfx/legato/font/legato_font.h"
#include "gfx/legato/common/legato_error.h"

/* internal use only */
struct leString;

typedef void (*leString_InvalidateCallback)(const struct leString* str, void* userData);

#define LE_STRING_VTABLE(THIS_TYPE) \
    void        (*destructor)(THIS_TYPE* _this); \
    leFont*     (*getFont)(const THIS_TYPE* _this); \
    leResult    (*setFont)(THIS_TYPE* _this, const leFont* font); \
    leResult    (*setFromString)(THIS_TYPE* _this, const struct leString* src); \
    leResult    (*setFromChar)(THIS_TYPE* _this, const leChar* buf, uint32_t size); \
    leResult    (*setFromCStr)(THIS_TYPE* _this, const char* cstr); \
    leChar      (*charAt)(const THIS_TYPE* _this, uint32_t idx); \
    uint32_t    (*length)(const THIS_TYPE* _this); \
    leBool      (*isEmpty)(const THIS_TYPE* _this); \
    int32_t     (*compare)(const THIS_TYPE* _this, const struct leString* tgt); \
    leResult    (*append)(THIS_TYPE* _this, const struct leString* val); \
    leResult    (*insert)(THIS_TYPE* _this, const struct leString* val, uint32_t idx); \
    leResult    (*remove)(THIS_TYPE* _this, uint32_t idx, uint32_t count); \
    void        (*clear)(THIS_TYPE* _this); \
    uint32_t    (*toChar)(const THIS_TYPE* _this, leChar* buf, uint32_t size); \
    leResult    (*getRect)(const THIS_TYPE* _this, leRect* rect); \
    uint32_t    (*getLineCount)(const THIS_TYPE* _this); \
    leResult    (*getLineRect)(const THIS_TYPE* _this, uint32_t line, leRect* rect); \
    leResult    (*getLineIndices)(const THIS_TYPE* _this, uint32_t line, uint32_t* start, uint32_t* end); \
    leResult    (*getCharRect)(const THIS_TYPE* _this, uint32_t idx, leRect* rect); \
    leResult    (*getCharIndexAtPoint)(const THIS_TYPE* _this, const lePoint* pt, uint32_t* idx); \
    leResult    (*_draw)(const THIS_TYPE* _this, int32_t x, int32_t y, leHAlignment align, leColor clr, uint32_t a); \
    void        (*preinvalidate)(THIS_TYPE* _this); \
    void        (*invalidate)(THIS_TYPE* _this); \
    leResult    (*setPreInvalidateCallback)(THIS_TYPE* _this, leString_InvalidateCallback, void* userData); \
    leResult    (*setInvalidateCallback)(THIS_TYPE* _this, leString_InvalidateCallback, void* userData); \

typedef struct leStringVTable
{
    LE_STRING_VTABLE(struct leString)
} leStringVTable;

// *****************************************************************************
typedef struct leString
{
    const leStringVTable* fn;                   
    leString_InvalidateCallback preInvCallback; 
    void* preCBUserData;                        
    leString_InvalidateCallback invCallback;    
    void* invCBUserData;                        
} leString;

// *****************************************************************************
void leString_Delete(leString* str);

#ifdef _DOXYGEN_
#define THIS_TYPE struct leWidget

// *****************************************************************************

virtual void destructor(leString* _this);

// *****************************************************************************
virtual leFont* getFont(const leString* _this);


// *****************************************************************************
virtual leResult setFont(leString* _this,
                         const leFont* font);


// *****************************************************************************
virtual leResult setFromString(leString* _this,
                               const struct leString* src);

// *****************************************************************************
virtual leResult setFromChar(leString* _this,
                             const leChar* buf,
                             uint32_t size);


// *****************************************************************************
virtual leResult setFromCStr(leString* _this,
                             const char* cstr);


// *****************************************************************************
virtual leChar charAt(const leString* _this,
                      uint32_t idx);

// *****************************************************************************
virtual uint32_t length(const leString* _this);

// *****************************************************************************
virtual leBool isEmpty(const leString* _this);


// *****************************************************************************
virtual int32_t compare(const leString* _this,
                        const struct leString* tgt);


// *****************************************************************************
virtual leResult append(leString* _this,
                        const struct leString* val);

// *****************************************************************************
virtual leResult insert(leString* _this,
                        const struct leString* val,
                        uint32_t idx);

// *****************************************************************************
 virtual leResult remove(leString* _this,
                    uint32_t idx,
                    uint32_t count);

// *****************************************************************************
virtual void clear(leString* _this);

// *****************************************************************************
virtual uint32_t toChar(const leString* _this,
                   leChar* buf,
                   uint32_t size);
virtual
// *****************************************************************************
virtual leResult getRect(const leString* _this,
                         leRect* rect);


// *****************************************************************************
uint32_t getLineCount(const leString* _this);


// *****************************************************************************
virtual leResult getLineRect(const leString* _this,
                             uint32_t line,
                             leRect* rect);


// *****************************************************************************
virtual leResult getLineIndices(const leString* _this,
                                uint32_t line,
                                uint32_t* start,
                                uint32_t* end);


// *****************************************************************************
virtual leResult getCharRect(const leString* _this,
                     uint32_t idx,
                     leRect* rect);

// *****************************************************************************
virtual leResult getCharIndexAtPoint(const leString* _this,
                                     const lePoint* pt,
                                     uint32_t* idx);


// *****************************************************************************
virtual leResult _draw(const leString* _this,
                       int32_t x,
                       int32_t y,
                       leHAlignment align,
                       leColor clr,
                       uint32_t a);


// *****************************************************************************
virtual void preinvalidate(leString* _this);

// *****************************************************************************
virtual void invalidate(leString* _this);

// *****************************************************************************
virtual leResult setPreInvalidateCallback(leString* _this,
                                          leString_InvalidateCallback,
                                          void* userData);

// *****************************************************************************
virtual leResult setInvalidateCallback(leString* _this,
                                       leString_InvalidateCallback cb,
                                       void* userData);

#undef THIS_TYPE
#endif

#endif /* LE_STRING_H */