d4d_object.h

Go to the documentation of this file.

/**************************************************************************
*
* Copyright 2014 by Petr Gargulak. eGUI Community.
* Copyright 2009-2013 by Petr Gargulak. Freescale Semiconductor, Inc.
*
***************************************************************************
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License Version 3
* or later (the "LGPL").
*
* As a special exception, the copyright holders of the eGUI project give you
* permission to link the eGUI sources with independent modules to produce an
* executable, regardless of the license terms of these independent modules,
* and to copy and distribute the resulting executable under terms of your
* choice, provided that you also meet, for each linked independent module,
* the terms and conditions of the license of that module.
* An independent module is a module which is not derived from or based
* on this library.
* If you modify the eGUI sources, you may extend this exception
* to your version of the eGUI sources, but you are not obligated
* to do so. If you do not wish to do so, delete this
* exception statement from your version.
*
* 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.
*
* You should have received a copy of the GNU General Public License
* and the GNU Lesser General Public License along with this program.
* If not, see <http://www.gnu.org/licenses/>.
*
***************************************************************************/
#ifndef __D4D_OBJECT_H
#define __D4D_OBJECT_H

/******************************************************************************
* Includes
******************************************************************************/

/******************************************************************************
* D4D OBJECT setting  constants
*
*/
// Common flags as for initial as for runtime
#define D4D_OBJECT_F_VISIBLE        0x0001      
#define D4D_OBJECT_F_ENABLED        0x0002      
#define D4D_OBJECT_F_TABSTOP        0x0004      
#define D4D_OBJECT_F_TOUCHENABLE    0x0008      
#define D4D_OBJECT_F_FASTTOUCH      0x0010      
#define D4D_OBJECT_F_FOCUSRECT      0x0020      
#define D4D_OBJECT_F_TIMETICK       0x0040      
#define D4D_OBJECT_F_RESERVED1      0x0080      

#define D4D_OBJECT_F_BEVEL_MASK     0x0300      
#define D4D_OBJECT_F_BEVEL_SHIFT    8           

#define D4D_OBJECT_F_BEVEL_RAISED   0x0100      
#define D4D_OBJECT_F_BEVEL_DENTED   0x0200      

#define D4D_OBJECT_F_MOUSE_MASK         0x0C00  
#define D4D_OBJECT_F_MOUSE_SHIFT        10      

#define D4D_OBJECT_F_MOUSE_NORMAL       0x0400  
#define D4D_OBJECT_F_MOUSE_BUSY         0x0800  
#define D4D_OBJECT_F_MOUSE_UNAVAILABLE  0x0C00  

#define D4D_OBJECT_F_SYSTEM_MASK        0x000FFFFF      
#define D4D_OBJECT_F_OBJECT_MASK        0xFFF00000      
#define D4D_OBJECT_F_OBJECT_SHIFT       20              


#define D4D_OBJECT_USR_DATA_PARENT_IX   0

#define D4D_OBJECT_USR_DATA_CHILD_IX    1

/******************************************************************************
* Internal constants
******************************************************************************/
// just runtime flags
#define D4D_OBJECT_F_REDRAW             0x10000
#define D4D_OBJECT_F_REDRAWC            0x20000
#define D4D_OBJECT_F_REDRAWSTATE        0x40000
#define D4D_OBJECT_F_NOTINIT            0x80000

struct D4D_OBJECT_S;
struct D4D_SCREEN_S;
struct D4D_MESSAGE_S;
struct D4D_CLR_SCHEME_S;

/******************************************************************************
* D4D Object types
*
*/
typedef LWord D4D_OBJECT_FLAGS;

typedef LWord D4D_OBJECT_INITFLAGS;

typedef struct D4D_OBJECT_SYS_FUNCTION_S
{
  D4D_TCHAR* strName;                                   
  void (*OnSysMessage)(struct D4D_MESSAGE_S* pMsg);     
  D4D_BOOL (*CheckCoordinates)(struct D4D_OBJECT_S* pObj, D4D_POINT point);     
  struct D4D_STRING_S* (*GetTextBuffer)(struct D4D_OBJECT_S* pObj);             
}D4D_OBJECT_SYS_FUNCTION;

typedef struct D4D_OBJECT_DATA_S
{
  D4D_OBJECT_FLAGS flags;               
  struct D4D_SCREEN_S* pScreen;         
}D4D_OBJECT_DATA, *D4D_OBJECT_DATA_PTR;

typedef void* D4D_OBJECT_USR_DATA;

typedef const struct D4D_OBJECT_S* const * D4D_OBJECT_RELATIONS;

/**************************************************************************/ 
typedef Byte (*D4D_ON_USR_MSG)(struct D4D_MESSAGE_S* pMsg);

// this is allocated in ROM always
typedef struct D4D_OBJECT_S
{
  D4D_POINT                             position;             
  D4D_SIZE                              size;                 
  D4D_COOR                              radius;               
  D4D_MARGIN*                           pMargin;              
  void*                                 pParam;               
  D4D_OBJECT_SYS_FUNCTION*              pObjFunc;             
  D4D_ON_USR_MSG                        OnUsrMessage;         
  D4D_OBJECT_USR_DATA                   userData;             
  D4D_OBJECT_RELATIONS                  pRelations;           
  D4D_OBJECT_INITFLAGS                  initFlags;            
  struct D4D_CLR_SCHEME_S*              clrScheme;            
  D4D_OBJECT_DATA_PTR                   pData;                
} D4D_OBJECT;

typedef const D4D_OBJECT* D4D_OBJECT_PTR;




/******************************************************************************
* Internal types
******************************************************************************/


/******************************************************************************
* D4D Object macros
*
*/
/**************************************************************************/ 
#define D4D_EXTERN_OBJECT(name) \
    extern const D4D_OBJECT name;

/**************************************************************************/ 
#define D4D_GET_OBJECT_DATA(pObject) ((pObject)->pData)

/**************************************************************************/ 
#define D4D_BORDER_WIDTH(flags) (((flags) & D4D_OBJECT_F_BEVEL_MASK)? (D4D_BEVEL_WIDTH) : (((flags) & D4D_OBJECT_F_FOCUSRECT)? 1:0))

/**************************************************************************/ 
#define D4D_OBJECT_FLAGS2BEVEL(pObject) ((D4D_BEVEL)(((pObject)->pData->flags & D4D_OBJECT_F_BEVEL_MASK) >> D4D_OBJECT_F_BEVEL_SHIFT))


/**************************************************************************/ 
#define D4D_DECLARE_OBJECT(type, name, x, y, cx, cy, rad, margin, relations, onusrmsg, sysFunc , param, initFlags, userData, pScheme) \
    D4D_OBJECT_DATA name##_Data = {(D4D_OBJECT_FLAGS)((initFlags | D4D_OBJECT_F_NOTINIT) & D4D_OBJECT_F_SYSTEM_MASK), NULL}; \
    type D4D_OBJECT name = \
    { \
        {x, y},\
        {cx, cy},\
        rad,\
        margin,\
        (void*)param, \
        (D4D_OBJECT_SYS_FUNCTION*)sysFunc, \
        onusrmsg, \
        (D4D_OBJECT_USR_DATA)userData, \
        relations,\
        initFlags, \
        pScheme, \
        &(name##_Data) \
    };

/**************************************************************************/ 
 #define D4D_DECLARE_OBJECT_RELATIONS(name, pParent, ...)\
    const D4D_OBJECT * const name[] =  {pParent, __VA_ARGS__ , NULL};

 // next way how to define object relation array

/**************************************************************************/ 
 #define D4D_DECLARE_OBJECT_RELATIONS_BEGIN(name, pParent)\
    const D4D_OBJECT * const name[] = \
    {\
     pParent,

/**************************************************************************/ 
 #define D4D_DECLARE_OBJECT_RELATIONS_CHILD(child) &child,

/**************************************************************************/ 
 #define D4D_DECLARE_OBJECT_RELATIONS_END NULL };

 #define D4D_OBJECT_MAX_TEXT_LEN(str) 1000



/******************************************************************************
* Public functions
******************************************************************************/
D4D_BOOL D4D_ObjectCheckCoordinates(D4D_OBJECT* pThis, D4D_POINT point);
D4D_BOOL D4D_IsEnabled(D4D_OBJECT* pObject);
D4D_BOOL D4D_IsVisible(D4D_OBJECT* pObject);
D4D_BOOL D4D_IsMineFocus(D4D_OBJECT* pObject);
void D4D_EnableTabStop(D4D_OBJECT_PTR pObj, D4D_BOOL bEnable);
void D4D_EnableObject(D4D_OBJECT_PTR pObj, D4D_BOOL bEnable);
void D4D_EnableTouchScreen(D4D_OBJECT_PTR pObj, D4D_BOOL bEnable, D4D_BOOL bFastTouch);
void D4D_ShowObject(D4D_OBJECT_PTR pObject, D4D_BOOL bShow);
void D4D_EnableTimeTicks(D4D_OBJECT_PTR pObj, D4D_BOOL bEnable);
void D4D_InvalidateObject(D4D_OBJECT_PTR pObject, D4D_BOOL bComplete);
void* D4D_GetUserPointer(D4D_OBJECT *pThis);
void D4D_CaptureKeys(D4D_OBJECT_PTR pObj);
D4D_OBJECT* D4D_GetCapturedObject(void);
D4D_SIZE D4D_GetClientScreenSize(D4D_OBJECT* pObject);

#endif  /* __D4D_OBJECT_H */