control.h

Go to the documentation of this file.

 
 
/*
 * control.h
 *
*  Created on: Mar 20, 2022
 *      Author: micahbly
 */
 
#ifndef CONTROL_H_
#define CONTROL_H_
 
 
/* about this class: Control
 *
 * Provides structures and functions for managing window controls such as close widgets, buttons, sliders, etc.
 *
 *** things this class needs to be able to do
 * Create a control instance from a proto-control (control template struct)
 * Toggle a control between active to inactive state
 * Tell a control to reposition itself on the window
 * Toggle a control's visibility
 * Render a control onto its parent bitmap
 * Get and Set the ID of a control
 * Get and Set the caption of the control (if any)
 * Get and Set the state of the control
 * Get and Set the max, minimum, and current values of the control
 * 
 *
 * STRETCH GOALS
 * 
 *
 * SUPER STRETCH GOALS
 * 
 * 
 */
 
 
/*****************************************************************************/
/*                                Includes                                   */
/*****************************************************************************/
 
// project includes
 
 
// C includes
#include <stdbool.h>
 
 
// A2560 includes
#include <mcp/syscalls.h>
#include "a2560k.h"
 
 
/*****************************************************************************/
/*                            Macro Definitions                              */
/*****************************************************************************/
 
#define CONTROL_NO_GROUP            -1  
#define CONTROL_MAX_CAPTION_SIZE    128 
 
#define CONTROL_ID_ERROR            -2  
#define CONTROL_ID_NOT_FOUND        -1  
 
 
/*****************************************************************************/
/*                               Enumerations                                */
/*****************************************************************************/
 
typedef enum control_active_state
{
    CONTROL_INACTIVE = 0,
    CONTROL_ACTIVE = 1,
} control_active_state;
 
typedef enum control_pushed_state
{
    CONTROL_NOT_PRESSED = 0,
    CONTROL_PRESSED = 1,
} control_pushed_state;
 
typedef enum control_type
{
    CONTROL_TYPE_ERROR = -1,    
    TEXT_BUTTON         = 0,    
    TEXT_FIELD          = 1,    
    RADIO_BUTTON    ,       
    CHECKBOX        ,       
    TITLEBAR        ,       
    TEXT_BOX        ,       
    IMAGE_BUTTON    ,       
    CLOSE_WIDGET    ,       
    SIZE_MINIMIZE   ,       
    SIZE_NORMAL     ,       
    SIZE_MAXIMIZE   ,       
    H_SCROLLER      ,       
    V_SCROLLER      ,       
    LABEL           ,       
    FUTURE_GROW_L   ,       
    FUTURE_GROW_R   ,       
    FUTURE_GROW_UP  ,       
    FUTURE_GROW_DN  ,       
    RESERVED1x      ,       
    RESERVED2x      ,       
    CUSTOM          ,       
} control_type;
 
 
typedef enum h_align_type
{
    H_ALIGN_LEFT    = 0,
    H_ALIGN_CENTER  = 1,
    H_ALIGN_RIGHT   = 2
} h_align_type;
 
typedef enum v_align_type
{
    V_ALIGN_TOP     = 0,
    V_ALIGN_CENTER  = 1,
    V_ALIGN_BOTTOM  = 2
} v_align_type;
 
 
/*****************************************************************************/
/*                                 Structs                                   */
/*****************************************************************************/
 
struct Control
{
    int16_t                 group_id_;                          
    int16_t                 id_;                            
    control_type            type_;                          
    Control*                next_;                          
    Window*                 parent_win_;                    
    Rectangle*              parent_rect_;                   
    Rectangle               rect_;                          
    h_align_type            h_align_;                       
    v_align_type            v_align_;                       
    int16_t                 x_offset_;                      
    int16_t                 y_offset_;                      
    int16_t                 width_;                         
    int16_t                 height_;                        
    bool                    visible_;
    bool                    active_;                        
    bool                    enabled_;                       
    bool                    pressed_;                       
    bool                    invalidated_;                   // if true, the control needs to be re-drawn and re-blitted in the next render pass
    int16_t                 value_;                         
    int16_t                 min_;                           
    int16_t                 max_;                           
    Bitmap*                 image_[2][2];                   
    char*                   caption_;                       
    int16_t                 avail_text_width_;              
//  char*                   hover_text_;                    //! optional string to show in help/hover-text situations
};
 
 
 
 
/*****************************************************************************/
/*                             Global Variables                              */
/*****************************************************************************/
 
 
/*****************************************************************************/
/*                       Public Function Prototypes                          */
/*****************************************************************************/
 
 
// **** CONSTRUCTOR AND DESTRUCTOR *****
 
// constructor
Control* Control_New(ControlTemplate* the_template, Window* the_window, Rectangle* the_parent_rect, int16_t control_id, int16_t group_id);
 
// destructor
// frees all allocated memory associated with the passed object, and the object itself
bool Control_Destroy(Control** the_control);
 
 
 
 
 
 
// **** xxx functions *****
 
 
 
 
// **** Set xxx functions *****
 
//  uint16_t                id_;                            //! used to identify the control in the control list, etc. 
//  control_type            type_;                          //! button vs checkbox vs radio button, etc. 
//  int8_t                  group_;                         //! group number, if this control is part of a group of controls. -1 (no group) is default. Typical use case: radio buttons.
//  Control*                next_;                          //! next control in the list
//  Window*                 parent_;                        //! parent window
//  Rectangle               rect_;                          //! coordinates relative to the parent window (ie, these are not global coordinates)
//  bool                    visible_;
//  bool                    active_;                        //! is the control activated or not (in appearance). Does not affect ability to receive events.
//  bool                    enabled_;                       //! is the control enabled or not. If not enabled, it will not receive events.
//  int16_t                 value_;                         //! current value of the control
//  int16_t                 min_;                           //! minimum allowed value
//  int16_t                 max_;                           //! maximum allowed value
//  Bitmap*                 image_inactive_;                //! image of the control in inactive state. size must match the length and width defined in the rect_. If not supplied, the control will be effectively invisible.
//  Bitmap*                 image_active_up_;               //! image of the control when active, and not clicked/pressed. size must match the length and width defined in the rect_. If not supplied, the control will be effectively invisible.
//  Bitmap*                 image_active_down_;             //! image of the control when active, and clicked/depressed. size must match the length and width defined in the rect_. If not supplied, the control will be effectively invisible.
//  char*                   caption_;                       //! optional string to draw centered horizontally and vertically on the control. Typical use cases include buttons and labels.
 
 
int16_t Control_GetID(Control* the_control);
 
control_type Control_GetType(Control* the_control);
 
bool Control_GetPressed(Control* the_control);
 
int8_t Control_GetGroup(Control* the_control);
 
Control* Control_GetNextControl(Control* the_control);
 
Window* Control_GetParent(Control* the_control);
Rectangle Control_GetRect(Control* the_control);
bool Control_GetVisible(Control* the_control);
bool Control_GetActive(Control* the_control);
bool Control_GetEnabled(Control* the_control);
int16_t Control_GetValue(Control* the_control);
int16_t Control_GetMinValue(Control* the_control);
int16_t Control_GetMaxValue(Control* the_control);
Bitmap* Control_GetImageUp(Control* the_control);
Bitmap* Control_GetImageDown(Control* the_control);
Bitmap* Control_GetImageInactive(Control* the_control);
char* Control_GetCaption(Control* the_control);
 
bool Control_SetID(Control* the_control, uint16_t the_new_id);
bool Control_SetType(Control* the_control, control_type the_type);
bool Control_SetGroup(Control* the_control, int16_t the_group_id);
 
bool Control_SetNextControl(Control* the_control, Control* the_next_control);
 
bool Control_SetParent(Control* the_control, Window* the_window);
bool Control_SetRect(Control* the_control, Rectangle the_rect);
 
void Control_SetActive(Control* the_control, bool is_active);
 
void Control_SetPressed(Control* the_control, bool is_pressed);
 
void Control_MarkInvalidated(Control* the_control, bool invalidated);
 
bool Control_SetEnabled(Control* the_control, bool is_enabled);
bool Control_SetValue(Control* the_control, int16_t the_value);
bool Control_SetMinValue(Control* the_control, int16_t the_value);
bool Control_SetMaxValue(Control* the_control, int16_t the_value);
bool Control_SetImageUp(Control* the_control, Bitmap* the_image);
bool Control_SetImageDown(Control* the_control, Bitmap* the_image);
bool Control_SetImageInactive(Control* the_control, Bitmap* the_image);
bool Control_SetCaption(Control* the_control, char* the_text);
 
void Control_AlignToParentRect(Control* the_control);
 
 
 
bool Control_IsRighter(Control* the_control, int16_t* x);
 
bool Control_IsLefter(Control* the_control, int16_t* x);
 
 
// **** Get xxx functions *****
 
 
 
 
 
// **** xxx functions *****
 
bool Control_UpdateFromTemplate(Control* the_control, ControlTemplate* the_template);
 
 
 
// **** Render functions *****
 
void Control_Render(Control* the_control);
 
 
 
 
#endif /* CONTROL_H_ */