inmarket
10 years ago
8 changed files with 532 additions and 20 deletions
@ -0,0 +1,169 @@ |
|||
/*
|
|||
* This file is subject to the terms of the GFX License. If a copy of |
|||
* the license was not distributed with this file, you can obtain one at: |
|||
* |
|||
* http://chibios-gfx.com/license.html
|
|||
*/ |
|||
|
|||
/**
|
|||
* @file include/gwin/radio.h |
|||
* @brief GWIN Graphic window subsystem header file. |
|||
* |
|||
* @defgroup RadioButton RadioButton |
|||
* @ingroup GWIN |
|||
* |
|||
* @details GWIN allows it to easily create radio buttons with different styles. |
|||
* |
|||
* @pre GFX_USE_GWIN must be set to TRUE in your gfxconf.h |
|||
* @pre GWIN_NEED_RADIO must be set to TRUE in your gfxconf.h |
|||
* @{ |
|||
*/ |
|||
|
|||
#ifndef _GWIN_RADIO_H |
|||
#define _GWIN_RADIO_H |
|||
|
|||
/* This file is included within "gwin/gwidget.h" */ |
|||
|
|||
/**
|
|||
* @brief The Event Type for a Radio Event |
|||
*/ |
|||
#define GEVENT_GWIN_RADIO (GEVENT_GWIN_FIRST+3) |
|||
|
|||
/**
|
|||
* @brief A Button Event |
|||
* @note There are currently no GEventGWinRadio listening flags - use 0 as the flags to @p gwinAttachListener() |
|||
*/ |
|||
typedef struct GEventGWinRadio { |
|||
GEventType type; // The type of this event (GEVENT_GWIN_RADIO)
|
|||
GHandle radio; // The radio button that has been depressed
|
|||
uint16_t group; // The group for this radio button
|
|||
} GEventGWinRadio; |
|||
|
|||
/**
|
|||
* @brief Button colors |
|||
*/ |
|||
typedef struct GRadioColors { |
|||
color_t color_edge; |
|||
color_t color_fill; |
|||
color_t color_txt; |
|||
} GRadioColors; |
|||
|
|||
/**
|
|||
* @brief The radio button widget structure |
|||
* @note Do not use the members directly - treat it as a black-box. |
|||
*/ |
|||
typedef struct GRadioObject_t { |
|||
GWidgetObject w; |
|||
#if GINPUT_NEED_TOGGLE |
|||
uint16_t toggle; |
|||
#endif |
|||
uint16_t group; |
|||
GRadioColors c_up; |
|||
GRadioColors c_dn; |
|||
GRadioColors c_dis; |
|||
} GRadioObject; |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" { |
|||
#endif |
|||
|
|||
/**
|
|||
* @brief Create a radio widget. |
|||
* @return NULL if there is no resultant drawing area, otherwise a window handle. |
|||
* |
|||
* @param[in] gb The GRadioObject structure to initialise. If this is NULL the structure is dynamically allocated. |
|||
* @param[in] pInit The initialisation parameters |
|||
* @param[in] group The group of radio buttons this radio button belongs to. |
|||
* |
|||
* @note Only one radio button in any group is ever pressed at one time. Pressing one radio button will |
|||
* release all others in the group. |
|||
* @note The drawing color and the background color get set to the current defaults. If you haven't called |
|||
* @p gwinSetDefaultColor() or @p gwinSetDefaultBgColor() then these are White and Black respectively. |
|||
* @note The font gets set to the current default font. If you haven't called @p gwinSetDefaultFont() then there |
|||
* is no default font and text drawing operations will no nothing. |
|||
* @note A radio button remembers its normal drawing state. If there is a window manager then it is automatically |
|||
* redrawn if the window is moved or its visibility state is changed. |
|||
* @note A radio button supports mouse and a toggle input. |
|||
* @note When assigning a toggle, only one toggle is supported. If you try to assign more than one toggle it will |
|||
* forget the previous toggle. When assigning a toggle the role parameter must be 0. |
|||
* |
|||
* @api |
|||
*/ |
|||
GHandle gwinCreateRadio(GRadioObject *gb, const GWidgetInit *pInit, uint16_t group); |
|||
|
|||
/**
|
|||
* @brief Set the colors of a button. |
|||
* |
|||
* @param[in] gh The window handle (must be a radio widget) |
|||
* @param[in] pUp The colors for the button when in the up state. |
|||
* @param[in] pDown The colors for the button when in the down state. |
|||
* @param[in] pDisabled The colors for the button when it is disabled. |
|||
* |
|||
* @note The button is not automatically redrawn. Call gwinButtonDraw() after changing the button style |
|||
* @note The button style is copied into the internal button structure - there is no need to |
|||
* maintain static style structures (they can be temporary structures on the stack). |
|||
* @note The pUp, pDown and pDisabled parameters can be NULL. If they are then the existing color styles |
|||
* are not changed for that button state. |
|||
* @note Some custom drawn buttons will ignore he specified colors |
|||
* |
|||
* @api |
|||
*/ |
|||
void gwinSetRadioColors(GHandle gh, const GRadioColors *pUp, const GRadioColors *pDown, const GRadioColors *pDisabled); |
|||
|
|||
/**
|
|||
* @brief Press this radio button (and by definition unset any others in the group) |
|||
* |
|||
* @param[in] gh The window handle (must be a radio widget) |
|||
* |
|||
* @api |
|||
*/ |
|||
void gwinPressRadio(GHandle gh); |
|||
|
|||
/**
|
|||
* @brief Is the radio button currently pressed |
|||
* @return TRUE if the button is pressed |
|||
* |
|||
* @param[in] gh The window handle (must be a radio widget) |
|||
* |
|||
* @api |
|||
*/ |
|||
bool_t gwinIsRadioPressed(GHandle gh); |
|||
|
|||
/**
|
|||
* @brief Find the currently pressed radio button in the specified group |
|||
* @return The handle of the pressed radio button or NULL if none are pressed |
|||
* |
|||
* @param[in] gh The window handle (must be a radio widget) |
|||
* |
|||
* @api |
|||
*/ |
|||
GHandle gwinActiveRadio(uint16_t group); |
|||
|
|||
/**
|
|||
* @brief Some custom radio button drawing routines |
|||
* @details These function may be passed to @p gwinSetCustomDraw() to get different radio button drawing styles |
|||
* |
|||
* @param[in] gw The widget object (in this case a radio button) |
|||
* @param[in] param A parameter passed in from the user |
|||
* |
|||
* @note In your custom radio drawing function you may optionally call these |
|||
* standard functions and then draw your extra details on top. |
|||
* @note The standard functions below ignore the param parameter. |
|||
* @note These custom drawing routines don't have to worry about setting clipping as the framework |
|||
* sets clipping to the object window prior to calling these routines. |
|||
* |
|||
* @api |
|||
* @{ |
|||
*/ |
|||
void gwinRadioDraw_Radio(GWidgetObject *gw, void *param); // @< A standard radio button
|
|||
void gwinRadioDraw_Button(GWidgetObject *gw, void *param); // @< Draw as a button
|
|||
void gwinRadioDraw_Tab(GWidgetObject *gw, void *param); // @< Draw as a tab
|
|||
/** @} */ |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif /* _GWIN_RADIO_H */ |
|||
/** @} */ |
|||
|
|||
@ -0,0 +1,260 @@ |
|||
/*
|
|||
* This file is subject to the terms of the GFX License. If a copy of |
|||
* the license was not distributed with this file, you can obtain one at: |
|||
* |
|||
* http://chibios-gfx.com/license.html
|
|||
*/ |
|||
|
|||
/**
|
|||
* @file src/gwin/radio.c |
|||
* @brief GWIN sub-system radio button code. |
|||
* |
|||
* @defgroup RadioButton RadioButton |
|||
* @ingroup GWIN |
|||
* |
|||
* @{ |
|||
*/ |
|||
|
|||
#include "gfx.h" |
|||
|
|||
#if GFX_USE_GWIN && GWIN_NEED_RADIO |
|||
|
|||
#include "gwin/class_gwin.h" |
|||
|
|||
// Our pressed state
|
|||
#define GRADIO_FLG_PRESSED (GWIN_FIRST_CONTROL_FLAG<<0) |
|||
|
|||
// Default color scheme
|
|||
static const GRadioColors GRadioDefaultColorsUp = { |
|||
HTML2COLOR(0x404040), // color_up_edge;
|
|||
HTML2COLOR(0xE0E0E0), // color_up_fill;
|
|||
HTML2COLOR(0x000000), // color_up_txt;
|
|||
}; |
|||
static const GRadioColors GRadioDefaultColorsDown = { |
|||
HTML2COLOR(0x404040), // color_dn_edge;
|
|||
HTML2COLOR(0x808080), // color_dn_fill;
|
|||
HTML2COLOR(0x404040), // color_dn_txt;
|
|||
}; |
|||
static const GRadioColors GRadioDefaultColorsDisabled = { |
|||
HTML2COLOR(0x808080), // color_dis_edge;
|
|||
HTML2COLOR(0xE0E0E0), // color_dis_fill;
|
|||
HTML2COLOR(0xC0C0C0), // color_dis_txt;
|
|||
}; |
|||
|
|||
// Send the button event
|
|||
static void SendButtonEvent(GWidgetObject *gw) { |
|||
GSourceListener * psl; |
|||
GEvent * pe; |
|||
#define pbe ((GEventGWinRadio *)pe) |
|||
|
|||
// Trigger a GWIN Button Event
|
|||
psl = 0; |
|||
while ((psl = geventGetSourceListener(GWIDGET_SOURCE, psl))) { |
|||
if (!(pe = geventGetEventBuffer(psl))) |
|||
continue; |
|||
pbe->type = GEVENT_GWIN_RADIO; |
|||
pbe->radio = (GHandle)gw; |
|||
pbe->group = ((GRadioObject *)gw)->group; |
|||
geventSendEvent(psl); |
|||
} |
|||
|
|||
#undef pbe |
|||
} |
|||
|
|||
#if GINPUT_NEED_MOUSE |
|||
// A mouse down has occurred over the button
|
|||
static void MouseDown(GWidgetObject *gw, coord_t x, coord_t y) { |
|||
(void) x; (void) y; |
|||
|
|||
gwinPressRadio((GHandle)gw); |
|||
} |
|||
#endif |
|||
|
|||
#if GINPUT_NEED_TOGGLE |
|||
// A toggle on has occurred
|
|||
static void ToggleOn(GWidgetObject *gw, uint16_t role) { |
|||
(void) role; |
|||
|
|||
gwinPressRadio((GHandle)gw); |
|||
} |
|||
|
|||
static void ToggleAssign(GWidgetObject *gw, uint16_t role, uint16_t instance) { |
|||
(void) role; |
|||
((GRadioObject *)gw)->toggle = instance; |
|||
} |
|||
|
|||
static uint16_t ToggleGet(GWidgetObject *gw, uint16_t role) { |
|||
(void) role; |
|||
return ((GRadioObject *)gw)->toggle; |
|||
} |
|||
#endif |
|||
|
|||
// The radio button VMT table
|
|||
static const gwidgetVMT radioVMT = { |
|||
{ |
|||
"Radio", // The classname
|
|||
sizeof(GRadioObject), // The object size
|
|||
_gwidgetDestroy, // The destroy routine
|
|||
_gwidgetRedraw, // The redraw routine
|
|||
0, // The after-clear routine
|
|||
}, |
|||
gwinRadioDraw_Radio, // The default drawing routine
|
|||
#if GINPUT_NEED_MOUSE |
|||
{ |
|||
MouseDown, // Process mouse down events
|
|||
0, // Process mouse up events (NOT USED)
|
|||
0, // Process mouse move events (NOT USED)
|
|||
}, |
|||
#endif |
|||
#if GINPUT_NEED_TOGGLE |
|||
{ |
|||
1, // 1 toggle role
|
|||
ToggleAssign, // Assign Toggles
|
|||
ToggleGet, // Get Toggles
|
|||
0, // Process toggle off events (NOT USED)
|
|||
ToggleOn, // Process toggle on events
|
|||
}, |
|||
#endif |
|||
#if GINPUT_NEED_DIAL |
|||
{ |
|||
0, // No dial roles
|
|||
0, // Assign Dials (NOT USED)
|
|||
0, // Get Dials (NOT USED)
|
|||
0, // Process dial move events (NOT USED)
|
|||
}, |
|||
#endif |
|||
}; |
|||
|
|||
GHandle gwinCreateRadio(GRadioObject *gw, const GWidgetInit *pInit, uint16_t group) { |
|||
if (!(gw = (GRadioObject *)_gwidgetCreate(&gw->w, pInit, &radioVMT))) |
|||
return 0; |
|||
|
|||
#if GINPUT_NEED_TOGGLE |
|||
gw->toggle = GWIDGET_NO_INSTANCE; |
|||
#endif |
|||
gw->group = group; |
|||
gw->c_up = GRadioDefaultColorsUp; |
|||
gw->c_dn = GRadioDefaultColorsDown; |
|||
gw->c_dis = GRadioDefaultColorsDisabled; |
|||
gwinSetVisible((GHandle)gw, pInit->g.show); |
|||
return (GHandle)gw; |
|||
} |
|||
|
|||
void gwinSetRadioColors(GHandle gh, const GRadioColors *pUp, const GRadioColors *pDown, const GRadioColors *pDisabled) { |
|||
if (gh->vmt != (gwinVMT *)&radioVMT) |
|||
return; |
|||
|
|||
if (pUp) ((GRadioObject *)gh)->c_up = *pUp; |
|||
if (pDown) ((GRadioObject *)gh)->c_dn = *pDown; |
|||
if (pDisabled) ((GRadioObject *)gh)->c_dis = *pDisabled; |
|||
} |
|||
|
|||
void gwinPressRadio(GHandle gh) { |
|||
GHandle gx; |
|||
|
|||
if (gh->vmt != (gwinVMT *)&radioVMT || (gh->flags & GRADIO_FLG_PRESSED)) |
|||
return; |
|||
|
|||
if ((gx = gwinActiveRadio(((GRadioObject *)gh)->group))) { |
|||
gx->flags &= ~GRADIO_FLG_PRESSED; |
|||
_gwidgetRedraw(gx); |
|||
} |
|||
gh->flags |= GRADIO_FLG_PRESSED; |
|||
_gwidgetRedraw(gh); |
|||
SendButtonEvent((GWidgetObject *)gh); |
|||
} |
|||
|
|||
bool_t gwinIsRadioPressed(GHandle gh) { |
|||
if (gh->vmt != (gwinVMT *)&radioVMT) |
|||
return FALSE; |
|||
|
|||
return (gh->flags & GRADIO_FLG_PRESSED) ? TRUE : FALSE; |
|||
} |
|||
|
|||
/**
|
|||
* @brief Find the currently pressed radio button in the specified group |
|||
* @return The handle of the pressed radio button or NULL if none are pressed |
|||
* |
|||
* @param[in] gh The window handle (must be a radio widget) |
|||
* |
|||
* @api |
|||
*/ |
|||
GHandle gwinActiveRadio(uint16_t group) { |
|||
const gfxQueueASyncItem * qi; |
|||
GHandle gh; |
|||
|
|||
for(qi = gfxQueueASyncPeek(&_GWINList); qi; qi = gfxQueueASyncNext(qi)) { |
|||
gh = QItem2GWindow(qi); |
|||
if (gh->vmt == (gwinVMT *)&radioVMT && ((GRadioObject *)gh)->group == group && (gh->flags & GRADIO_FLG_PRESSED)) |
|||
return gh; |
|||
} |
|||
return 0; |
|||
} |
|||
|
|||
/*----------------------------------------------------------
|
|||
* Custom Draw Routines |
|||
*----------------------------------------------------------*/ |
|||
|
|||
static GRadioColors *getDrawColors(GWidgetObject *gw) { |
|||
if (!(gw->g.flags & GWIN_FLG_ENABLED)) return &((GRadioObject *)gw)->c_dis; |
|||
if ((gw->g.flags & GRADIO_FLG_PRESSED)) return &((GRadioObject *)gw)->c_dn; |
|||
return &((GRadioObject *)gw)->c_up; |
|||
} |
|||
|
|||
void gwinRadioDraw_Radio(GWidgetObject *gw, void *param) { |
|||
#define gcw ((GRadioObject *)gw) |
|||
coord_t ld, df; |
|||
GRadioColors * pcol; |
|||
(void) param; |
|||
|
|||
if (gw->g.vmt != (gwinVMT *)&radioVMT) return; |
|||
pcol = getDrawColors(gw); |
|||
|
|||
ld = gw->g.width < gw->g.height ? gw->g.width : gw->g.height; |
|||
|
|||
#if GDISP_NEED_CIRCLE |
|||
df = ld/2; |
|||
gdispFillArea(gw->g.x, gw->g.y, ld, ld, gw->g.bgcolor); |
|||
gdispDrawCircle(gw->g.x+df, gw->g.y+df, df, pcol->color_edge); |
|||
|
|||
if (gw->g.flags & GRADIO_FLG_PRESSED) |
|||
gdispFillCircle(gw->g.x+df, gw->g.y+df, df <= 2 ? 1 : (df-2), pcol->color_fill); |
|||
#else |
|||
gdispFillArea(gw->g.x+1, gw->g.y+1, ld, ld-2, gw->g.bgcolor); |
|||
gdispDrawBox(gw->g.x, gw->g.y, ld, ld, pcol->color_edge); |
|||
|
|||
df = ld < 4 ? 1 : 2; |
|||
if (gw->g.flags & GRADIO_FLG_PRESSED) |
|||
gdispFillArea(gw->g.x+df, gw->g.y+df, ld-2*df, ld-2*df, pcol->color_fill); |
|||
#endif |
|||
|
|||
gdispFillStringBox(gw->g.x+ld+1, gw->g.y, gw->g.width-ld-1, gw->g.height, gw->txt, gw->g.font, pcol->color_txt, gw->g.bgcolor, justifyLeft); |
|||
#undef gcw |
|||
} |
|||
|
|||
void gwinRadioDraw_Button(GWidgetObject *gw, void *param) { |
|||
(void) param; |
|||
GRadioColors * pcol; |
|||
|
|||
if (gw->g.vmt != (gwinVMT *)&radioVMT) return; |
|||
pcol = getDrawColors(gw); |
|||
|
|||
gdispFillStringBox(gw->g.x, gw->g.y, gw->g.width-1, gw->g.height-1, gw->txt, gw->g.font, pcol->color_txt, pcol->color_fill, justifyCenter); |
|||
gdispDrawLine(gw->g.x+gw->g.width-1, gw->g.y, gw->g.x+gw->g.width-1, gw->g.y+gw->g.height-1, pcol->color_edge); |
|||
gdispDrawLine(gw->g.x, gw->g.y+gw->g.height-1, gw->g.x+gw->g.width-2, gw->g.y+gw->g.height-1, pcol->color_edge); |
|||
} |
|||
|
|||
void gwinRadioDraw_Tab(GWidgetObject *gw, void *param) { |
|||
(void) param; |
|||
GRadioColors * pcol; |
|||
|
|||
if (gw->g.vmt != (gwinVMT *)&radioVMT) return; |
|||
pcol = getDrawColors(gw); |
|||
|
|||
gdispFillStringBox(gw->g.x+1, gw->g.y+1, gw->g.width-2, gw->g.height-2, gw->txt, gw->g.font, pcol->color_txt, pcol->color_fill, justifyCenter); |
|||
gdispDrawBox(gw->g.x, gw->g.y, gw->g.width, gw->g.height, pcol->color_edge); |
|||
} |
|||
|
|||
#endif /* GFX_USE_GWIN && GWIN_NEED_BUTTON */ |
|||
/** @} */ |
|||
|
|||
Loading…
Reference in new issue