This is the David Smart RA8875 Library with mods for working with FRDM-K64F
Diff: RA8875.h
- Revision:
- 190:3132b7dfad82
- Parent:
- 186:910fc2335c45
- Child:
- 191:0fad2e45e196
diff -r 53a64d3ce163 -r 3132b7dfad82 RA8875.h --- a/RA8875.h Thu Sep 19 21:45:18 2019 +0000 +++ b/RA8875.h Sat Sep 21 17:30:00 2019 +0000 @@ -2,51 +2,51 @@ /// @mainpage RA8875 Display Controller Driver library /// /// The RA8875 Display controller is a powerful interface for low cost displays. It -/// can support displays up to 800 x 480 pixels x 16-bit color. +/// can support displays up to 800 x 480 pixels x 16-bit color. /// /// @image html Example_Program.png "Image of an Example Program" /// -/// Aside from 800 x 480 pixel displays, another common implementation is -/// 480 x 272 x 16 with two layers. The two layers can be exchanged, or blended -/// in various ways (transparency, OR, AND, and more). It includes graphics -/// acceleration capabilities for drawing primitives, such as line, rectangle, +/// Aside from 800 x 480 pixel displays, another common implementation is +/// 480 x 272 x 16 with two layers. The two layers can be exchanged, or blended +/// in various ways (transparency, OR, AND, and more). It includes graphics +/// acceleration capabilities for drawing primitives, such as line, rectangle, /// circles, and more. /// -/// It is not a display for video-speed animations, and maybe could hold its own -/// as a slow picture frame, at least when using the SPI ports. How the performance +/// It is not a display for video-speed animations, and maybe could hold its own +/// as a slow picture frame, at least when using the SPI ports. How the performance /// differs using I2C, 8-bit parallel or 16-bit parallel has not been evaluated. /// Certainly the parallel interface option would be expected to be a lot faster. /// /// What it is good at is performing as a basic display for appliance or simple -/// home automation, and because of the built-in capability to draw lines, circles, -/// ellipses, rectangles, rounded rectangles, and triangles, it does a lot of the +/// home automation, and because of the built-in capability to draw lines, circles, +/// ellipses, rectangles, rounded rectangles, and triangles, it does a lot of the /// work that your host micro would otherwise be doing, and in many cases it does /// it much faster. /// /// While it is good to know about Bresenham's algorithm (to draw a line) and how -/// to implement it in software, this controller simplifies things - -/// You just give it (x1,y1), (x2,y2) and tell it to draw a line. +/// to implement it in software, this controller simplifies things - +/// You just give it (x1,y1), (x2,y2) and tell it to draw a line. /// Without the hardware acceleration built into the RA8875, the host would have to /// compute every point, set the graphics cursor to that point, and fill in that /// point with the target color. A diagonal line of some length might take 100 -/// interactions instead of just a few. Other drawing primitives are similarly easy. +/// interactions instead of just a few. Other drawing primitives are similarly easy. /// -/// It has some built-in fonts, which can be enhanced with optional font-chips, and +/// It has some built-in fonts, which can be enhanced with optional font-chips, and /// with the provided software font engine, and a few instructions, you can convert -/// most any True Type Font into the data structures suitable for this display. +/// most any True Type Font into the data structures suitable for this display. /// /// To round out the features, this library offers the ability to render Bitmap (BMP), -/// Icon (ICO), Join Photographic Experts Group (JPG), and Graphics Interchange Format -/// (GIF) images. These are implemented primarily in software, taking advantage of the -/// hardware acceleration where it can. +/// Icon (ICO), Join Photographic Experts Group (JPG), and Graphics Interchange Format +/// (GIF) images. These are implemented primarily in software, taking advantage of the +/// hardware acceleration where it can. /// -/// When you are satisfied with what appears on screen, there is a PrintScreen method +/// When you are satisfied with what appears on screen, there is a PrintScreen method /// to pull that image back out and write it to a file system as a BitMap image. /// /// The controller additionally supports backlight control (via PWM), keypad scanning /// (for a 4 x 5 matrix) and resistive touch-panel support. Support for capacitive /// touch screens is also integrated, in a manner that makes the resistive and -/// capacitive interfaces nearly API identical. The capacitive touch support is for +/// capacitive interfaces nearly API identical. The capacitive touch support is for /// either the FT5206 or the GSL1680 controller chips. /// /// Here's a few hints to get started: @@ -66,19 +66,19 @@ /// was within main(), then it seemed to work as expected. /// /// @note As the author of this library, let me state that I am not affiliated with -/// Raio (silicon provider of the RA8875), or with BuyDisplay.com (where a lot -/// of these displays can be purchased), I am simply a very satisfied customer +/// Raio (silicon provider of the RA8875), or with BuyDisplay.com (where a lot +/// of these displays can be purchased), I am simply a very satisfied customer /// of the technology of the RA8875 chip. /// /// @copyright Copyright © 2012-2019 by Smartware Computing, all rights reserved. /// This library is predominantly, that of Smartware Computing, however some -/// portions are compiled from the work of others. Where the contribution of -/// others was listed as copyright, that copyright is maintained, even as a +/// portions are compiled from the work of others. Where the contribution of +/// others was listed as copyright, that copyright is maintained, even as a /// derivative work may have been created for better integration in this library. /// See @ref Copyright_References. /// /// @page Copyright_References Copyright References -/// +/// /// Following are links to the known copyright references. If I overlooked any, it was /// unintentional - please let me know so I can update it. Some portions of the code /// have been acquired from the cloud, and where any copyright information was available, @@ -99,12 +99,12 @@ /// /// During the instantiation, the display is powered on, cleared, and the backlight /// is energized. Additionally, the keypad and touchscreen features are activated. -/// It is important to keep in mind that the keypad has its default mapping, -/// a resistive touchscreen does not yet have the calibration matrix configured, +/// It is important to keep in mind that the keypad has its default mapping, +/// a resistive touchscreen does not yet have the calibration matrix configured, /// and the RA8875::init() function is required to configure other important options /// like the display resolution. -/// -/// @code +/// +/// @code /// RA8875 lcd(p5, p6, p7, p12, NC, "tft"); /// lcd.init(); /// lcd.foreground(Blue); @@ -119,7 +119,7 @@ /// * 800 x 480 pixels /// /// @subsection RA8875_Layers Display Layers -/// The RA8875 Controller, depending on the resolution and color depth, can support +/// The RA8875 Controller, depending on the resolution and color depth, can support /// multiple display layers. /// /// * 1 Layer - when the color depth is 16 bits per pixel @@ -130,16 +130,16 @@ /// @page Touch_Panel Touch Panel /// /// There is support for various touch panel interfaces. -/// * @ref Resistive_Touch_Panel - native control for a resistive touch panel. +/// * @ref Resistive_Touch_Panel - native control for a resistive touch panel. /// There are a few steps to enable this interface. /// /// For the Capacitive Touch controllers, an I2C interface is required. /// /// @image html RA8875_Touch.png "Schematic Representation of the Touch Interface" /// -/// * @ref CapSense_FT5206 - FT5206 capacitive touch controller, integrated in +/// * @ref CapSense_FT5206 - FT5206 capacitive touch controller, integrated in /// several popular RA8875-based displays. See @ref Capacitive_Touch_Panel. -/// * @ref CapSense_GSL1680 - GSL1680 capacitive touch controller, integrated in +/// * @ref CapSense_GSL1680 - GSL1680 capacitive touch controller, integrated in /// several popular RA8875-based displays. See @ref Capacitive_Touch_Panel. /// /// @page MicroSD_Interface Micro SD Interface @@ -155,7 +155,7 @@ /// /// The RA8875 controller supports a hardwired matrix of keys, which can be used to /// easily monitor for up to 20 keys (4 x 5 matrix). It is quite flexible, so these -/// could be a set of independent functions, or they could be wired as a simple +/// could be a set of independent functions, or they could be wired as a simple /// calculator or telephone style of keypad. /// /// @image html RA8875_Keypad.png "Schematic Representation of the Keypad Interface" @@ -167,19 +167,19 @@ /// @page Resistive_Touch_Panel Resistive Touch Panel /// /// The RA8875 controller supports a native resistive touchscreen interface than can -/// track a single touch-point. +/// track a single touch-point. /// /// If your display has this option, you can easily accept touch input, but it comes with /// some additional requirements - calibration being the primary concern. /// /// @section Touch_Panel_Enable Touch Panel Enable /// -/// @ref RA8875::TouchPanelInit() has two forms - one fully automatic, and more controlled. +/// @ref RA8875::TouchPanelInit() has two forms - one fully automatic, and more controlled. /// See the APIs for details. /// /// @section Touch_Panel_Calibration -/// -/// The touch panel is not initially calibrated on startup. The application should +/// +/// The touch panel is not initially calibrated on startup. The application should /// provide a means to activate the calibration process, and that should not require /// the touchscreen as it may not yet be usable. Alternately, a calibration matrix /// can be loaded from non-volatile and installed. @@ -192,7 +192,7 @@ /// /// * @ref CapSense_FT5206. /// * @ref CapSense_GSL1680. -/// +/// /// @page CapSense_FT5206 Capacitive Sense - FT5206 Controller /// /// This is the more common controller. It supports up to 5 simultaneous touch point @@ -215,7 +215,7 @@ /// #include "mbed.h" // Working: v146, not fully working: v147 /// #include "RA8875.h" // Working: v149 /// RA8875 lcd(p5, p6, p7, p12, NC, "tft"); -/// +/// /// int main() /// { /// lcd.init(480,272,16,100); @@ -231,7 +231,7 @@ /// lcd.roundrect( 410,160, 475,190, 10,8, Yellow); /// lcd.fillroundrect(415,165, 470,185, 5,3, Orange); /// lcd.line( 430,200, 460,230, RGB(0,255,0)); -/// for (int i=0; i<=30; i+=5) +/// for (int i=0; i<=30; i+=5) /// lcd.pixel(435+i,200+i, White); /// } /// @endcode @@ -240,15 +240,15 @@ /// @page Wiring_Diagram Example Wiring Diagram /// -/// This library was crafted around the 4-Wire SPI interface. This was the chosen -/// interface method in order to balance the requirements of the host micro IO with +/// This library was crafted around the 4-Wire SPI interface. This was the chosen +/// interface method in order to balance the requirements of the host micro IO with /// the capability of this display. Alternatives include: 3-Wire SPI, I2C, 8-bit and /// 16-bit parallel. -/// -/// @section Schematic_Basic Basic Schematic +/// +/// @section Schematic_Basic Basic Schematic /// /// The basic schematic should be the most portable to any system that has SPI support. -/// +/// /// @image html RA8875_display_schematic.png "Basic Display support" /// /// @section Schematic_DisplayTouch Display with Capacitive Touch @@ -260,23 +260,23 @@ /// /// @section Schematic_DisplayTouchMicroSD Display with Capacitive Touch and micro SD /// -/// The most advanced schematic - taking advantage of the display, the capacitive touch -/// controller, and the peripheral support for a micro SD card on some of the display +/// The most advanced schematic - taking advantage of the display, the capacitive touch +/// controller, and the peripheral support for a micro SD card on some of the display /// modules. /// /// @note There are online indications that the RA8875 has a defect in its SPI interface /// where it will not release the MISO pin. If this pin is shared with the micro SD -/// port, then it could interfere with successful read/write of the files. +/// port, then it could interfere with successful read/write of the files. /// The easiest solution is to put that interface on a separate SPI port. /// /// @image html RA8875_display_full.png "Display, Touch, and micro SD support" /// /// @page External_Resources External Resources /// -/// There are many websites with information on the RA8875 Display. This partial list +/// There are many websites with information on the RA8875 Display. This partial list /// may be helpful: /// -/// * <a href="https://os.mbed.com/components/RA8875-Based-Display/">RA8875 Library</a> +/// * <a href="https://os.mbed.com/components/RA8875-Based-Display/">RA8875 Library</a> /// on the <a href="https://os.mbed.com/">mbed site</a><br/> /// This page has **a lot** of detail, schematices, sample programs, instructions to /// create your own fonts, and more... @@ -326,14 +326,14 @@ /// - @ref RA8875::window() /// - @ref RA8875::WindowMax() /// -/// - Change the title-case of the functions to be consistent. Because this was adapted +/// - Change the title-case of the functions to be consistent. Because this was adapted /// from parts of several different libraries, it isn't very consistently titled. /// -/// - Change names of some of the functions to be more consistent. Why are some Set* +/// - Change names of some of the functions to be more consistent. Why are some Set* /// and others are Select*. The layer commands SetDrawingLayer and GetDrawingLayer do /// not need 'Drawing' in them. /// -/// - Improve the PrintScreen method. There are two functions - one that accepts a filename, +/// - Improve the PrintScreen method. There are two functions - one that accepts a filename, /// and a second more experimental version that could pipe the image stream back to /// a calling process. This could be used, for example, to send the image over a /// network interface. The intended side effect is that there is then only a single @@ -342,14 +342,14 @@ /// /// - Add support for the hardware reset pin /// -/// - Figure out how to "init()" in the constructor when it is not in main(). I ran into -/// some issues if the display was instantiated before main(), and the code would not -/// run, thus the exposure and activation of the init() function. If the instantiation -/// is within main(), then it seemed to work as expected. +/// - Figure out how to "init()" in the constructor when it is not in main(). I ran into +/// some issues if the display was instantiated before main(), and the code would not +/// run, thus the exposure and activation of the init() function. If the instantiation +/// is within main(), then it seemed to work as expected. /// -/// - Add Scroll support for text. +/// - Add Scroll support for text. /// -/// - Add high level objects - x-y graph, meter, buttons, ... but these will probably be +/// - Add high level objects - x-y graph, meter, buttons, ... but these will probably be /// best served in another class, since they may not be needed for many uses. /// #ifndef RA8875_H @@ -381,10 +381,10 @@ /// @page PredefinedColors Predefined Colors /// /// Keep in mind that the color scheme shown here is unlikely to precisely match -/// that on the actual display. The perceived color is additional affected by +/// that on the actual display. The perceived color is additional affected by /// other attributes, such as the backlight brightness. /// -/// These are the predefined colors that are typically used where any @ref color_t +/// These are the predefined colors that are typically used where any @ref color_t /// variable is applied. /// /// <blockquote> @@ -498,7 +498,7 @@ /// lcd.roundrect( 410,160, 475,190, 10,8, Yellow); /// lcd.fillroundrect(415,165, 470,185, 5,3, Orange); /// lcd.line( 430,200, 460,230, RGB(0,255,0)); -/// for (int i=0; i<=30; i+=5) +/// for (int i=0; i<=30; i+=5) /// lcd.pixel(435+i,200+i, White); /// } /// @endcode @@ -508,10 +508,26 @@ /// @todo Add high level objects - x-y graph, meter, others... but these will /// probably be best served in another class, since they may not /// be needed for many uses. -/// +/// class RA8875 : public GraphicsDisplay { -public: +public: + /// Vertical alignment attribute. Used to align one rect against another. + /// @ref AlignRectInRect + typedef enum { + top, ///< vertically align to the top + middle, ///< vertically align to the middle + bottom ///< vertically align to the bottom + } valign_t; + + /// Horizontal alignment attribute. Used to align one rect against another. + /// @ref AlignRectInRect + typedef enum { + left, ///< horizontally align to the left + center, ///< horizontally align to the center + right ///< horizontally align to the right + } halign_t; + /// cursor type argument for @ref SetTextCursorControl() typedef enum { @@ -529,7 +545,7 @@ ISO8859_3, ///< ISO8859-3 font ISO8859_4 ///< ISO8859-4 font } font_t; - + /// display orientation argument for @ref SetOrientation() /// with landscape mode as the normal (0 degree) orientation. typedef enum @@ -540,17 +556,17 @@ rotate_180, ///< rotated (clockwise) 180 degree rotate_270, ///< rotated clockwise 270 degree } orientation_t; - + /// alignment control argument for @ref SetTextFontControl() typedef enum { align_none, ///< align - none align_full ///< align - full - } alignment_t; - + } alignment_t; + /// Font Horizontal Scale factor - 1, 2, 3 4 for @ref SetTextFontSize(), @ref GetTextFontSize() typedef int HorizontalScale; - + /// Font Vertical Scale factor - 1, 2, 3, 4 for @ref SetTextFontSize(), @ref GetTextFontSize() typedef int VerticalScale; @@ -572,7 +588,7 @@ BooleanAND, ///< Boolean AND mode FloatingWindow ///< Floating Window mode } LayerMode_T; - + /// Touch Panel modes typedef enum { @@ -590,7 +606,7 @@ /// print screen callback /// - /// The special form of the print screen will pass one blob at a time + /// The special form of the print screen will pass one blob at a time /// to the callback. There are basic commands declaring that the stream /// can be opened, a block written, and the stream closed. There is /// also a command to communicate the total size being delivered. @@ -600,7 +616,7 @@ /// /// @code /// lcd.PrintScreen(x,y,w,h,callback); - /// ... + /// ... /// void callback(filecmd_t cmd, uint8_t * buffer, uint16_t size) { /// switch(cmd) { /// case OPEN: @@ -626,7 +642,7 @@ /// @returns @ref RetCode_t value. /// typedef RetCode_t (* PrintCallback_T)(filecmd_t cmd, uint8_t * buffer, uint16_t size); - + /// Idle reason provided in the Idle Callback @ref IdleCallback_T() typedef enum { unknown, ///< reason has not been assigned (this should not happen) @@ -637,10 +653,10 @@ touchcal_wait, ///< driver is performing a touch calibration progress, ///< communicates progress } IdleReason_T; - - /// Idle Callback - /// - /// This defines the interface for an idle callback. That is, when the + + /// Idle Callback + /// + /// This defines the interface for an idle callback. That is, when the /// driver is held up, pending some event, it can call a previously registered /// idle function. This could be most useful for servicing a watchdog. /// @@ -669,16 +685,16 @@ /// for 'progress' reason code, param ranges from 0 to 100 (percent) /// @returns @ref RetCode_t value. /// - typedef RetCode_t (* IdleCallback_T)(IdleReason_T reason, uint16_t param = 0); - - /// Basic constructor for a display based on the RAiO RA8875 + typedef RetCode_t (* IdleCallback_T)(IdleReason_T reason, uint16_t param); + + /// Basic constructor for a display based on the RAiO RA8875 /// display controller, which can be used with no touchscreen, /// or the RA8875 managed resistive touchscreen. /// /// This constructor differs from the alternate by supportting /// either No Touch Screen, or the RA8875 built-in resistive /// touch screen. If the application requires the use of the - /// capacitive touchscreen, the alternate constructor must + /// capacitive touchscreen, the alternate constructor must /// be used. /// /// This configures the registers and calls the @ref init method. @@ -700,23 +716,23 @@ /// @param[in] sclk is the SPI shift clock pin on the mbed. /// @param[in] csel is the DigitalOut pin on the mbed to use as the /// active low chip select for the display controller. - /// @param[in] reset is the DigitalOut pin on the mbed to use as the - /// active low reset input on the display controller - + /// @param[in] reset is the DigitalOut pin on the mbed to use as the + /// active low reset input on the display controller - /// but this is not currently used. /// @param[in] name is a text name for this object, which will permit /// capturing stdout to puts() and printf() directly to it. /// - RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset, + RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset, const char * name = "lcd"); - - - /// Constructor for a display based on the RAiO RA8875 display controller + + + /// Constructor for a display based on the RAiO RA8875 display controller /// (using the FT5206 Capacitive TouchScreen Controller) /// /// @code /// #include "RA8875.h" /// RA8875 lcd(p5, p6, p7, p12, NC, p9,p10,p13, "tft"); - /// + /// /// int main() /// { /// lcd.init(); @@ -733,8 +749,8 @@ /// @param[in] sclk is the SPI shift clock pin on the mbed. /// @param[in] csel is the DigitalOut pin on the mbed to use as the /// active low chip select for the display controller. - /// @param[in] reset is the DigitalOut pin on the mbed to use as the - /// active low reset input on the display controller - + /// @param[in] reset is the DigitalOut pin on the mbed to use as the + /// active low reset input on the display controller - /// but this is not currently used. /// @param[in] sda is the I2C Serial Data pin you are wiring to the FT5206. /// @param[in] scl is the I2C Serial Clock pin you are wiring to the FT5206. @@ -742,17 +758,17 @@ /// @param[in] name is a text name for this object, which will permit /// capturing stdout to puts() and printf() directly to it. /// - RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset, + RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset, PinName sda, PinName scl, PinName irq, const char * name = "lcd"); - - - /// Constructor for a display based on the RAiO RA8875 display controller + + + /// Constructor for a display based on the RAiO RA8875 display controller /// (using the GSL1680 Capacitive TouchScreen Controller) /// /// @code /// #include "RA8875.h" /// RA8875 lcd(p5, p6, p7, p12, NC, p9,p10,p13,p14, "tft"); - /// + /// /// int main() /// { /// lcd.init(); @@ -769,8 +785,8 @@ /// @param[in] sclk is the SPI shift clock pin on the mbed. /// @param[in] csel is the DigitalOut pin on the mbed to use as the /// active low chip select for the display controller. - /// @param[in] reset is the DigitalOut pin on the mbed to use as the - /// active low reset input on the display controller - + /// @param[in] reset is the DigitalOut pin on the mbed to use as the + /// active low reset input on the display controller - /// but this is not currently used. /// @param[in] sda is the I2C Serial Data pin you are wiring to the GSL1680. /// @param[in] scl is the I2C Serial Clock pin you are wiring to the GSL1680. @@ -779,19 +795,19 @@ /// @param[in] name is a text name for this object, which will permit /// capturing stdout to puts() and printf() directly to it. /// - RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset, + RA8875(PinName mosi, PinName miso, PinName sclk, PinName csel, PinName reset, PinName sda, PinName scl, PinName wake, PinName irq, const char * name = "lcd"); - - + + // Destructor doesn't have much to do as this would typically be created // at startup, and not at runtime. //~RA8875(); - + /// Initialize the driver. /// - /// The RA8875 can control typical displays from the 480x272 to 800x480, and it supports 8 or 16-bit color. - /// It also supports 2 graphics layers, but it cannot support 2 layers at the maximum color depth and - /// screen size. When configured under 480x400, it will support both 16-bit color depth and 2 drawing layers. + /// The RA8875 can control typical displays from the 480x272 to 800x480, and it supports 8 or 16-bit color. + /// It also supports 2 graphics layers, but it cannot support 2 layers at the maximum color depth and + /// screen size. When configured under 480x400, it will support both 16-bit color depth and 2 drawing layers. /// Above 480x400 it support either 16-bit color, or 2 layers, but not both. /// /// Typical of the displays that are readily purchased, you will find 480x272 and 800x480 resolutions. @@ -810,15 +826,15 @@ /// required for full brightness). See @ref Power. /// @param[in] keypadon defines if the keypad support should be enabled. This parameter is optional /// and the default is true (enabled). See @ref KeypadInit. - /// @param[in] touchscreeenon defines if the touchscreen support should be enabled. + /// @param[in] touchscreeenon defines if the touchscreen support should be enabled. /// This parameter is optional and the default is true (enabled). See @ref TouchPanelInit. - /// - If the constructor was called with support for the capacitive driver, this + /// - If the constructor was called with support for the capacitive driver, this /// parameter causes the driver to initialize. /// - If the constructor was called without support for the capacitive driver, this /// parameter is used to enable and initialize the resistive touchscreen driver. /// @returns @ref RetCode_t value. /// - RetCode_t init(int width = 480, int height = 272, int color_bpp = 16, + RetCode_t init(int width = 480, int height = 272, int color_bpp = 16, uint8_t poweron = 40, bool keypadon = true, bool touchscreeenon = true); @@ -832,12 +848,12 @@ /// is not a valid value, then it returns the text for bad_parameter; /// const char * GetErrorMessage(RetCode_t code); - - + + /// Select the drawing layer for subsequent commands. /// - /// If the screen configuration is 480 x 272, or if it is 800 x 480 - /// and 8-bit color, the the display supports two layers, which can + /// If the screen configuration is 480 x 272, or if it is 800 x 480 + /// and 8-bit color, the the display supports two layers, which can /// be independently drawn on and shown. Additionally, complex /// operations involving both layers are permitted. /// @@ -858,7 +874,7 @@ /// others that reference the layers use the values 0 and 1 for /// cleaner iteration in the code. /// - /// @param[in] layer is 0 or 1 to select the layer for subsequent + /// @param[in] layer is 0 or 1 to select the layer for subsequent /// commands. /// @param[out] prevLayer is an optiona pointer to where the previous layer /// will be written, making it a little easer to restore layers. @@ -866,8 +882,8 @@ /// @returns @ref RetCode_t value. /// virtual RetCode_t SelectDrawingLayer(uint16_t layer, uint16_t * prevLayer = NULL); - - + + /// Get the currently active drawing layer. /// /// This returns a value, 0 or 1, based on the screen configuration @@ -886,10 +902,10 @@ /// cleaner iteration in the code. /// /// @returns the current drawing layer; 0 or 1. - /// + /// virtual uint16_t GetDrawingLayer(void); - - + + /// Set the Layer presentation mode. /// /// This sets the presentation mode for layers, and permits showing @@ -911,8 +927,8 @@ /// @returns @ref RetCode_t value. /// RetCode_t SetLayerMode(LayerMode_T mode); - - + + /// Get the Layer presentation mode. /// /// This gets the current layer mode. See @ref LayerMode_T. @@ -920,8 +936,8 @@ /// @returns layer mode. /// LayerMode_T GetLayerMode(void); - - + + /// Set the layer transparency for each layer. /// /// Set the transparency, where the range of values is @@ -940,22 +956,22 @@ /// @param[in] layer1 sets the layer 1 transparency. /// @param[in] layer2 sets the layer 2 transparency. /// @returns @ref RetCode_t value. - /// + /// RetCode_t SetLayerTransparency(uint8_t layer1, uint8_t layer2); - - + + /// Set the background color register used for transparency. /// /// This command sets the background color registers that are used /// in the transparent color operations involving the layers. - /// + /// /// @param[in] color is optional and expressed in 16-bit format. If not /// supplied, a default of Black is used. /// @returns @ref RetCode_t value. /// RetCode_t SetBackgroundTransparencyColor(color_t color = RGB(0,0,0)); - - + + /// Get the background color value used for transparency. /// /// This command reads the background color registers that define @@ -964,9 +980,9 @@ /// @returns the color. /// color_t GetBackgroundTransparencyColor(void); - - - /// Initialize theTouch Panel controller with default values + + + /// Initialize theTouch Panel controller with default values /// /// This activates the simplified touch panel init, which may work for /// most uses. The alternate API is available if fine-grained control @@ -978,8 +994,8 @@ /// @returns @ref RetCode_t value. /// RetCode_t TouchPanelInit(void); - - + + /// Initialize the Touch Panel controller with detailed settings. /// /// This is the detailed touch panel init, which provides the ability @@ -996,44 +1012,44 @@ /// - TP_MODE_MANUAL: manual capture /// @param[in] bTpDebounce Debounce circuit enable for touch panel interrupt: /// - TP_DEBOUNCE_OFF: disable the debounce circuit - /// - TP_DEBOUNCE_ON: enable the debounce circuit + /// - TP_DEBOUNCE_ON: enable the debounce circuit /// @param[in] bTpManualMode When Manual Mode is selected, this sets the mode: - /// - TP_MANUAL_IDLE: touch panel is idle - /// - TP_MANUAL_WAIT: wait for touch panel event - /// - TP_MANUAL_LATCH_X: latch X data - /// - TP_MANUAL_LATCH_Y: latch Y data + /// - TP_MANUAL_IDLE: touch panel is idle + /// - TP_MANUAL_WAIT: wait for touch panel event + /// - TP_MANUAL_LATCH_X: latch X data + /// - TP_MANUAL_LATCH_Y: latch Y data /// @param[in] bTpAdcClkDiv Sets the ADC clock as a fraction of the System CLK: - /// - TP_ADC_CLKDIV_1: Use CLK - /// - TP_ADC_CLKDIV_2: Use CLK/2 - /// - TP_ADC_CLKDIV_4: Use CLK/4 - /// - TP_ADC_CLKDIV_8: Use CLK/8 - /// - TP_ADC_CLKDIV_16: Use CLK/16 - /// - TP_ADC_CLKDIV_32: Use CLK/32 - /// - TP_ADC_CLKDIV_64: Use CLK/64 - /// - TP_ADC_CLKDIV_128: Use CLK/128 + /// - TP_ADC_CLKDIV_1: Use CLK + /// - TP_ADC_CLKDIV_2: Use CLK/2 + /// - TP_ADC_CLKDIV_4: Use CLK/4 + /// - TP_ADC_CLKDIV_8: Use CLK/8 + /// - TP_ADC_CLKDIV_16: Use CLK/16 + /// - TP_ADC_CLKDIV_32: Use CLK/32 + /// - TP_ADC_CLKDIV_64: Use CLK/64 + /// - TP_ADC_CLKDIV_128: Use CLK/128 /// @param[in] bTpAdcSampleTime Touch Panel sample time delay before ADC data is ready: - /// - TP_ADC_SAMPLE_512_CLKS: Wait 512 system clocks - /// - TP_ADC_SAMPLE_1024_CLKS: Wait 1024 system clocks - /// - TP_ADC_SAMPLE_2048_CLKS: Wait 2048 system clocks - /// - TP_ADC_SAMPLE_4096_CLKS: Wait 4096 system clocks - /// - TP_ADC_SAMPLE_8192_CLKS: Wait 8192 system clocks - /// - TP_ADC_SAMPLE_16384_CLKS: Wait 16384 system clocks - /// - TP_ADC_SAMPLE_32768_CLKS: Wait 32768 system clocks + /// - TP_ADC_SAMPLE_512_CLKS: Wait 512 system clocks + /// - TP_ADC_SAMPLE_1024_CLKS: Wait 1024 system clocks + /// - TP_ADC_SAMPLE_2048_CLKS: Wait 2048 system clocks + /// - TP_ADC_SAMPLE_4096_CLKS: Wait 4096 system clocks + /// - TP_ADC_SAMPLE_8192_CLKS: Wait 8192 system clocks + /// - TP_ADC_SAMPLE_16384_CLKS: Wait 16384 system clocks + /// - TP_ADC_SAMPLE_32768_CLKS: Wait 32768 system clocks /// - TP_ADC_SAMPLE_65536_CLKS: Wait 65536 system clocks - /// @returns @ref RetCode_t value. - /// - RetCode_t TouchPanelInit(uint8_t bTpEnable, uint8_t bTpAutoManual, uint8_t bTpDebounce, + /// @returns @ref RetCode_t value. + /// + RetCode_t TouchPanelInit(uint8_t bTpEnable, uint8_t bTpAutoManual, uint8_t bTpDebounce, uint8_t bTpManualMode, uint8_t bTpAdcClkDiv, uint8_t bTpAdcSampleTime); - - + + /// Get the screen calibrated point of touch. /// /// This method determines if there is a touch and if so it will provide /// the screen-relative touch coordinates. This method can be used in - /// a manner similar to Serial.readable(), to determine if there was a + /// a manner similar to Serial.readable(), to determine if there was a /// touch and indicate that - but not care about the coordinates. Alternately, /// if a valid pointer to a point_t is provided, then if a touch is detected - /// the point_t will be populated with data. + /// the point_t will be populated with data. /// /// @code /// Timer t; @@ -1046,7 +1062,7 @@ /// } while (t.read_ms() < 30000); /// @endcode /// - /// @param[out] TouchPoint is a pointer to a point_t, which is set as the touch point, + /// @param[out] TouchPoint is a pointer to a point_t, which is set as the touch point, /// if a touch is registered. /// @returns a value indicating the state of the touch, /// - no_cal: no calibration matrix is available, touch coordinates are not returned. @@ -1059,7 +1075,7 @@ /// Get the reported touch gesture, if any. - /// + /// /// If it could detect a gesture, it will return a value based on /// the interpreted gesture. /// @@ -1078,7 +1094,7 @@ /// @returns gesture information. /// uint8_t TouchGesture(void) { return gesture; } - + /// Get the count of registered touches. /// @@ -1086,22 +1102,22 @@ /// int TouchCount(void) { return numberOfTouchPoints; } - + /// Get the count of possible touch channels. /// /// @returns count of touch channels supported by the hardware. /// int TouchChannels(void); - + /// Get the Touch ID value for a specified touch channel. /// /// Touch ID is a tracking number based on the order of the touch - /// detections. The first touch is ID 0, the next is ID 1, and + /// detections. The first touch is ID 0, the next is ID 1, and /// so on. If the first touch is lifted (no touch), the touch count /// decrements, and the remaining touch is communicated on /// touch channel zero, even as the Touch ID remains as originally - /// reported (1 in this example). In this way, it is easy to track + /// reported (1 in this example). In this way, it is easy to track /// a specific touch. /// /// It is possible to query the data for a channel that is not @@ -1113,7 +1129,7 @@ /// @returns 0 if an invalid channel is queried. /// uint8_t TouchID(uint8_t channel = 0); - + /// Get the Touch Code for a touch channel. /// /// It is possible to query the data for a channel that is not @@ -1141,7 +1157,7 @@ /// @returns channel 0 information if an invalid channel is queried. /// point_t TouchCoordinates(uint8_t channel = 0); - + /// Poll the TouchPanel and on a touch event return the a to d filtered x, y coordinates. /// @@ -1150,11 +1166,11 @@ /// /// @note The returned values are not in display (pixel) units but are in analog to /// digital converter units. - /// - /// @note This API is usually not needed and is likely to be deprecated. - /// See @ref TouchPanelComputeCalibration. + /// + /// @note This API is usually not needed and is likely to be deprecated. + /// See @ref TouchPanelComputeCalibration. /// See @ref TouchPanelReadable. - /// + /// /// @param[out] x is the x scale a/d value. /// @param[out] y is the y scale a/d value. /// @returns a value indicating the state of the touch, @@ -1171,15 +1187,15 @@ /// /// This method reads the touch controller, which has a 10-bit range for each the /// x and the y axis. A number of samples of the raw data are taken, filtered, - /// and the results are returned. + /// and the results are returned. /// /// @note The returned values are not in display (pixel) units but are in analog to /// digital converter units. - /// - /// @note This API is usually not needed and is likely to be deprecated. - /// See @ref TouchPanelComputeCalibration. + /// + /// @note This API is usually not needed and is likely to be deprecated. + /// See @ref TouchPanelComputeCalibration. /// See @ref TouchPanelReadable. - /// + /// /// @param[out] x is the x scale a/d value. /// @param[out] y is the y scale a/d value. /// @returns a value indicating the state of the touch, @@ -1191,9 +1207,9 @@ /// TouchCode_t TouchPanelA2DRaw(int *x, int *y); - + /// Wait for a touch panel touch and return it. - /// + /// /// This method is similar to Serial.getc() in that it will wait for a touch /// and then return. In order to extract the coordinates of the touch, a /// valid pointer to a point_t must be provided. @@ -1232,10 +1248,11 @@ /// @code /// RA8875 lcd(p5, p6, p7, p12, NC); /// ... + /// LocalFileSystem local(); /// // Be sure you previously mounted the "/sd" file system to put the cal there. /// lcd.ResTouchPanelCfg("/sd/tpcal.cfg", "Touch '+' to calibrate the touch panel"); /// - /// // Only if the touch panel is enabled, AND is configured as the resistive + /// // Only if the touch panel is enabled, AND is configured as the resistive /// // panel will the prior command be useful. /// lcd.init(LCD_W,LCD_H,LCD_C,40, false, true); /// @@ -1244,7 +1261,7 @@ /// @param[in] tpFQFN is a pointer to a fully qualified read-write accessible /// filename where the calibration is held. /// @param[in] tpCalMessage is an optional pointer to a message shown to the - /// user in the calibration process. + /// user in the calibration process. /// - If this parameter is not included, a default message will be shown. /// - If this parameter points to a NULL string, no message is shown. /// - If this parameter points to a non-NULL string, that string will be shown. @@ -1255,7 +1272,7 @@ /// Calibrate the touch panel. /// /// This method accepts two lists - one list is target points in , - /// display coordinates and the other is a lit of raw touch coordinate + /// display coordinates and the other is a lit of raw touch coordinate /// values. It generates a calibration matrix for later use. This /// matrix is also accessible to the calling API, which may store /// the matrix in persistent memory and then install the calibration @@ -1269,30 +1286,30 @@ /// http://www.embedded.com/design/system-integration/4023968/How-To-Calibrate-Touch-Screens /// /// @copyright Copyright © 2001, Carlos E. Vidales. All rights reserved. - /// This sample program was written and put in the public domain - /// by Carlos E. Vidales. The program is provided "as is" + /// This sample program was written and put in the public domain + /// by Carlos E. Vidales. The program is provided "as is" /// without warranty of any kind, either expressed or implied. /// If you choose to use the program within your own products /// you do so at your own risk, and assume the responsibility /// for servicing, repairing or correcting the program should /// it prove defective in any manner. - /// You may copy and distribute the program's source code in any + /// You may copy and distribute the program's source code in any /// medium, provided that you also include in each copy an /// appropriate copyright notice and disclaimer of warranty. /// You may also modify this program and distribute copies of - /// it provided that you include prominent notices stating + /// it provided that you include prominent notices stating /// that you changed the file(s) and the date of any change, - /// and that you do not charge any royalties or licenses for + /// and that you do not charge any royalties or licenses for /// its use. /// - /// @param[in] display is a pointer to a set of 3 points, which + /// @param[in] display is a pointer to a set of 3 points, which /// are in display units of measure. These are the targets /// the calibration was aiming for. /// @param[in] screen is a pointer to a set of 3 points, which /// are in touchscreen units of measure. These are the /// registered touches. - /// @param[out] matrix is an optional parameter to hold the calibration matrix - /// as a result of the calibration. This can be saved in + /// @param[out] matrix is an optional parameter to hold the calibration matrix + /// as a result of the calibration. This can be saved in /// non-volatile memory to recover the calibration after a power fail. /// @returns @ref RetCode_t value. /// @@ -1307,8 +1324,8 @@ /// matrix, and optionally provide the calibration matrix to the calling code /// for persistence in non-volatile memory. /// - /// @param[out] matrix is an optional parameter to hold the calibration matrix - /// as a result of the calibration. This can be saved in + /// @param[out] matrix is an optional parameter to hold the calibration matrix + /// as a result of the calibration. This can be saved in /// non-volatile memory to recover the calibration after a power fail. /// @returns @ref RetCode_t value. /// @@ -1325,8 +1342,8 @@ /// /// @param[in] msg is a text message to present on the screen during the /// calibration process. - /// @param[out] matrix is an optional parameter to hold the calibration matrix - /// as a result of the calibration. This can be saved in + /// @param[out] matrix is an optional parameter to hold the calibration matrix + /// as a result of the calibration. This can be saved in /// non-volatile memory to recover the calibration after a power fail. /// @param[in] maxwait_s is the maximum number of seconds to wait for a touch /// calibration. If no touch panel installed, it then reports @@ -1354,10 +1371,11 @@ /// fclose(fh); /// } /// @endcode - /// + /// /// @param[in] matrix is a pointer to the touch panel calibration matrix. /// @returns @ref RetCode_t value. /// + /// RetCode_t TouchPanelSetMatrix(tpMatrix_t * matrix); /// Get the calibration matrix for the resistive touch panel. @@ -1367,7 +1385,7 @@ /// process, the results are indeterminate. /// /// return const tpMatrix_t pointer - /// + /// const tpMatrix_t * TouchPanelGetMatrix(); #if 0 @@ -1378,7 +1396,7 @@ /// - RA8875_INT_DMA: DMA interrupt /// - RA8875_INT_TP: Touch panel interrupt /// - RA8875_INT_BTE: BTE process complete interrupt - /// - RA8875_INT_BTEMCU_FONTWR: Multi-purpose interrupt (see spec sheet) + /// - RA8875_INT_BTEMCU_FONTWR: Multi-purpose interrupt (see spec sheet) /// @param[in] fptr is a callback function to handle the interrupt event. /// @returns none /// @@ -1391,7 +1409,7 @@ /// - RA8875_INT_DMA: DMA interrupt /// - RA8875_INT_TP: Touch panel interrupt /// - RA8875_INT_BTE: BTE process complete interrupt - /// - RA8875_INT_BTEMCU_FONTWR: Multi-purpose interrupt (see spec sheet) + /// - RA8875_INT_BTEMCU_FONTWR: Multi-purpose interrupt (see spec sheet) /// @return none /// void UnAppendISR(uint8_t bISRType); @@ -1418,8 +1436,8 @@ /// /// @returns @ref RetCode_t value. /// - RetCode_t KeypadInit(bool scanEnable = true, bool longDetect = false, - uint8_t sampleTime = 0, uint8_t scanFrequency = 0, + RetCode_t KeypadInit(bool scanEnable = true, bool longDetect = false, + uint8_t sampleTime = 0, uint8_t scanFrequency = 0, uint8_t longTimeAdjustment = 0, bool interruptEnable = false, bool wakeupEnable = false); @@ -1437,7 +1455,7 @@ /// /// @code /// // Return Value by Row, Column Example reassignment - /// // Column 0 1 2 3 4 + /// // Column 0 1 2 3 4 /// // +-------------------------+ +-------------------------+ /// // Row 0 | 1 2 3 4 5 | | '7' '8' '9' ',' '<-' | /// // 1 | 6 7 8 9 10 | | '4' '5' '6' '/' '-' | @@ -1446,17 +1464,17 @@ /// // +-------------------------+ +-------------------------+ /// // Return value 0 = No Key pressed /// // Return value 21 = Error - /// const uint8_t CodeList[22] = - /// {0, '7', '8', '9', ',', '\h', + /// const uint8_t CodeList[22] = + /// {0, '7', '8', '9', ',', '\h', /// '4', '5', '6', '/', '-', /// '1', '2', '3', '*', '+', - /// '0', '.', '(', ')', '\n', + /// '0', '.', '(', ')', '\n', /// '\x1b'}; /// lcd.SetKeyMap(CodeList); /// @endcode - /// - /// @param[in] CodeList is a pointer to an always available byte-array - /// where the first 22 bytes are used as the transformation + /// + /// @param[in] CodeList is a pointer to an always available byte-array + /// where the first 22 bytes are used as the transformation /// from raw code to your reassigned value. /// If CodeList is NULL, the original raw value key map is /// restored. @@ -1489,8 +1507,21 @@ /// keypress using 0 = no key pressed, 1 - 20 = the key pressed. /// uint8_t getc(); - - + + + /// Align one rectangle against another. + /// + /// This will accept a rectangle to align and align it against another rectangle. + /// It would be most typical if the rectangle to align is smaller than the reference rectangle. + /// + /// @param[in] toAlign is a rectangular region to align against another. + /// @param[in] inRect is a rectangle to align against. + /// @param[in] v specifies the vertical alignment - top, middle, bottom. + /// @param[in] h specified the horizontal alignment - left, center, right. + /// @returns a new rectangle, the size of the toAlign. + /// + rect_t AlignRectInRect(rect_t toAlign, rect_t inRect, valign_t v, halign_t h); + /// Determine if a point is within a rectangle. /// /// @param[in] rect is a rectangular region to use. @@ -1506,7 +1537,7 @@ /// @returns true if any part of rect2 intersects rect1. /// bool Intersect(rect_t rect1, rect_t rect2); - + /// Determine if a rectangle intersects another rectangle and provides /// the area of intersection. /// @@ -1522,7 +1553,7 @@ /// +------------------+ /// @endcode /// - /// @note that the first parameter is a pointer to a rect and the + /// @note that the first parameter is a pointer to a rect and the /// /// @param[inout] pRect1 is a pointer to a rectangular region, and returns /// the area of intersection. @@ -1531,8 +1562,8 @@ /// the rectangle describing the intersection. /// bool Intersect(rect_t * pRect1, const rect_t * pRect2); - - + + /// Write a command to the display with a word of data. /// /// This is a high level command, and may invoke several primitives. @@ -1555,7 +1586,7 @@ /// virtual RetCode_t WriteCommand(unsigned char command, unsigned int data = 0xFFFF); - + /// Write a data word to the display /// /// This is a high level command, and may invoke several primitives. @@ -1565,7 +1596,7 @@ /// RetCode_t WriteDataW(uint16_t data); - + /// Write a data byte to the display /// /// This is a high level command, and may invoke several primitives. @@ -1575,7 +1606,7 @@ /// virtual RetCode_t WriteData(unsigned char data); - + /// Read a command register /// /// @param[in] command is the command register to read. @@ -1590,8 +1621,8 @@ /// @returns the value read from the register. /// uint16_t ReadCommandW(unsigned char command); - - + + /// Read a data byte from the display /// /// This is a high level command, and may invoke several primitives. @@ -1600,7 +1631,7 @@ /// unsigned char ReadData(void); - + /// Read a word from the display /// /// This is a high level command, and may invoke several primitives. @@ -1622,28 +1653,28 @@ /// get the width in pixels of the currently active font /// /// @returns font width in pixels. - /// + /// dim_t fontwidth(void); - + /// get the height in pixels of the currently active font /// /// @returns font height in pixels. - /// + /// dim_t fontheight(void); - + /// get the number of colums based on the currently active font /// /// @returns number of columns. - /// + /// virtual int columns(void); /// get the number of rows based on the currently active font /// /// @returns number of rows. - /// + /// virtual int rows(void); @@ -1668,13 +1699,24 @@ virtual dim_t color_bpp(void); /// Set cursor position based on the current font size. - /// + /// /// @param[in] column is the horizontal position in character positions /// @param[in] row is the vertical position in character positions /// @returns @ref RetCode_t value. /// virtual RetCode_t locate(textloc_t column, textloc_t row); + /// Enable word-wrap in _puts() + /// + /// @todo Consider adding a method to define the word-delimiters, which could then + /// include user-selection of characters (e.g. ' ', '-', ';', and so on). + /// + /// @param[in] _wordwrap when true controls _puts() to wrap on word-boundary, which + /// is delimited by 'space' character or 'cr' 'lf' sequences. + /// @returns previous wordwrap setting to permit an easy restore. + /// + bool SetWordWrap(bool _wordwrap); + /// Prepare the controller to write text to the screen by positioning /// the cursor. @@ -1717,7 +1759,7 @@ /// @returns cursor position. /// point_t GetTextCursor(void); - + /// Get the current cursor horizontal position in pixels. /// @@ -1735,8 +1777,8 @@ /// Configure additional Cursor Control settings. /// - /// This API lets you modify other cursor control settings; - /// Cursor visible/hidden, Cursor blink/normal, + /// This API lets you modify other cursor control settings; + /// Cursor visible/hidden, Cursor blink/normal, /// Cursor I-Beam/underscore/box. /// /// @param[in] cursor can be set to NOCURSOR (default), IBEAM, @@ -1746,7 +1788,7 @@ /// RetCode_t SetTextCursorControl(cursor_t cursor = NOCURSOR, bool blink = false); - + /// Select the built-in ISO 8859-X font to use next. /// /// Supported fonts: ISO 8859-1, -2, -3, -4 @@ -1761,7 +1803,7 @@ /// @returns @ref RetCode_t value. /// RetCode_t SetTextFont(font_t font = ISO8859_1); - + /// Sets the display orientation. /// @@ -1778,17 +1820,17 @@ /// lcd.SetOrientation(RA8875::normal); /// lcd.puts(30,30, "Normal Landscape"); /// wait_ms(2500); - /// + /// /// lcd.cls(); /// lcd.SetOrientation(RA8875::rotate_90); /// lcd.puts(30,30, "Rotated 90 Text\r\n"); /// wait_ms(2500); - /// + /// /// lcd.cls(); /// lcd.SetOrientation(RA8875::rotate_180); /// lcd.puts(30,30, "Rotated 180 Text\r\n"); /// wait_ms(2500); - /// + /// /// lcd.cls(); /// lcd.SetOrientation(RA8875::rotate_270); /// lcd.puts(30,30, "Rotated 270 Text\r\n"); @@ -1803,7 +1845,7 @@ /// @returns @ref RetCode_t value. /// RetCode_t SetOrientation(orientation_t angle = normal); - + /// Control the font behavior. /// @@ -1814,8 +1856,8 @@ /// /// Options can be combined: /// Default: - /// @li Full alignment disabled, - /// @li Font with Background color, + /// @li Full alignment disabled, + /// @li Font with Background color, /// @li Font in normal orientiation, or rotated 90, 180, or 270 clockwise, /// @li Horizontal scale x 1, 2, 3, or 4 /// @li Vertical scale x 1, 2, 3, or 4 @@ -1824,7 +1866,7 @@ /// full fonts on one presentation. 'align_full' starts each full /// character on an even alignment. See section 7-4-7 of the RA8875 /// specification. - /// + /// /// @param[in] fillit defaults to FILL, but can be NOFILL /// @param[in] hScale defaults to 1, but can be 1, 2, 3, or 4, /// and scales the font size by this amount. @@ -1832,21 +1874,41 @@ /// and scales the font size by this amount. /// @param[in] alignment defaults to align_none, but can be /// align_full. - /// + /// /// @note if either hScale or vScale is outside of its permitted range, /// the command is not executed. /// @returns @ref RetCode_t value. /// - RetCode_t SetTextFontControl(fill_t fillit = FILL, - HorizontalScale hScale = 1, - VerticalScale vScale = 1, + RetCode_t SetTextFontControl(fill_t fillit = FILL, + HorizontalScale hScale = 1, + VerticalScale vScale = 1, alignment_t alignment = align_none); - + + + /// Control the font - to background fill or "ink-only" + /// + /// This command configures the font presentation to write + /// only the font "ink", or to write the ink and also overwrite + /// the background with the background color. + /// + /// @note This command applies only to the internal fonts not to user fonts + /// e.g. SelectUserFont(...) out of concerns for performance. + /// User fonts always write the character block as a continuous + /// stream (for efficiency). This precludes first reading the + /// character block before writing it. Alternately, addressing + /// individual pixels would also be a significant performance + /// impact. + /// + /// @param[in] fillit set to FILL will also write the background, + /// and set to NOFILL will write only the ink. + /// @returns the previous fill setting permitting easy restore. + /// + fill_t SetTextFontFill(fill_t fillit); /// Control the font size of the RA8875 rendered fonts. /// /// This command lets you set the font enlargement for both horizontal - /// and vertical, independent of the rotation, background, and + /// and vertical, independent of the rotation, background, and /// alignment. See @ref SetTextFontControl. /// /// @note This command operates on the RA8875 internal fonts. @@ -1854,7 +1916,7 @@ /// /// @param[in] hScale defaults to 1, but can be 1, 2, 3, or 4, /// and scales the font size by this amount. - /// @param[in] vScale is an optional parameter that defaults to the hScale value, + /// @param[in] vScale is an optional parameter that defaults to the hScale value, /// but can be 1, 2, 3, or 4, and scales the font size by this amount. /// /// @code @@ -1880,7 +1942,7 @@ /// Get the text font size of the RA8875 internal fonts. /// /// This command lets you retrieve the current settings for the font - /// horizontal and vertical scale factors. The return value is + /// horizontal and vertical scale factors. The return value is /// one of the scale factors 1, 2, 3, or 4. /// /// @param[out] hScale is a pointer to memory where the horizontal scale factor @@ -1893,6 +1955,15 @@ /// put a character on the screen. /// + /// @param[in] text is a pointer to a text string to evaluate. + /// @param[in] charOnly defaults to false, which computes over the whole string. + /// @returns width in pixels, given the selected font and scale. + /// + dim_t GetTextWidth(const char * text, bool charOnly = false); + + + /// put a character on the screen. + /// /// @param[in] c is the character. /// @returns the character, or EOF if there is an error. /// @@ -1909,7 +1980,7 @@ /// void puts(const char * string); - + /// Write string of text to the display at the specified location. /// /// @code @@ -1921,7 +1992,7 @@ /// @param[in] string is the null terminated string to send to the display. /// void puts(loc_t x, loc_t y, const char * string); - + /// Prepare the controller to write binary data to the screen by positioning /// the memory cursor. @@ -1939,14 +2010,14 @@ /// @returns @ref RetCode_t value. /// virtual RetCode_t SetGraphicsCursor(point_t p); - + /// Read the current graphics cursor position as a point. /// /// @returns the graphics cursor as a point. /// virtual point_t GetGraphicsCursor(void); - + /// Prepare the controller to read binary data from the screen by positioning /// the memory read cursor. /// @@ -1955,7 +2026,7 @@ /// @returns @ref RetCode_t value. /// virtual RetCode_t SetGraphicsCursorRead(loc_t x, loc_t y); - + /// Set the window, constraining where items are written to the screen. /// @@ -1982,7 +2053,7 @@ /// @returns @ref RetCode_t value. /// virtual RetCode_t window(rect_t r); - + /// Set the window, constraining where items are written to the screen. /// @@ -2013,7 +2084,7 @@ /// @returns @ref RetCode_t value. /// virtual RetCode_t window(loc_t x = 0, loc_t y = 0, dim_t width = (dim_t)-1, dim_t height = (dim_t)-1); - + /// Clear either the specified layer, or the active layer. /// @@ -2030,15 +2101,15 @@ /// is cleared. If bit 0 is set, layer 0 is cleared, if bit /// 1 is set, layer 1 is cleared. If both are set, both layers /// are cleared. Any other value does not cause an action. - /// + /// /// @returns @ref RetCode_t value. /// virtual RetCode_t cls(uint16_t layers = 0); - + /// Clear the screen, or clear only the active window. /// - /// The default behavior is to clear the whole screen. With the optional + /// The default behavior is to clear the whole screen. With the optional /// parameter, the action can be restricted to the active window, which /// can be set with the See @ref window method. /// @@ -2061,7 +2132,7 @@ /// virtual RetCode_t background(color_t color); - + /// Set the background color. /// /// @param[in] r is the red element of the color. @@ -2070,7 +2141,7 @@ /// @returns @ref RetCode_t value. /// virtual RetCode_t background(unsigned char r, unsigned char g, unsigned char b); - + /// Set the foreground color. /// @@ -2078,7 +2149,7 @@ /// @returns @ref RetCode_t value. /// virtual RetCode_t foreground(color_t color); - + /// Set the foreground color. /// @@ -2088,15 +2159,15 @@ /// @returns @ref RetCode_t value. /// virtual RetCode_t foreground(unsigned char r, unsigned char g, unsigned char b); - - + + /// Get the current foreground color value. /// /// @returns the current foreground color as @ref color_t. /// color_t GetForeColor(void); - - + + /// Draw a pixel in the specified color. /// /// @note Unlike many other operations, this does not @@ -2107,16 +2178,16 @@ /// @returns @ref RetCode_t value. /// virtual RetCode_t pixel(point_t p, color_t color); - - + + /// Draw a pixel in the current foreground color. /// /// @param[in] p is the point_t defining the location. /// @returns @ref RetCode_t value. /// virtual RetCode_t pixel(point_t p); - - + + /// Draw a pixel in the specified color. /// /// @note Unlike many other operations, this does not @@ -2128,8 +2199,8 @@ /// @returns @ref RetCode_t value. /// virtual RetCode_t pixel(loc_t x, loc_t y, color_t color); - - + + /// Draw a pixel in the current foreground color. /// /// @param[in] x is the horizontal offset to this pixel. @@ -2137,8 +2208,8 @@ /// @returns @ref RetCode_t value. /// virtual RetCode_t pixel(loc_t x, loc_t y); - - + + /// Get a pixel from the display. /// /// @param[in] x is the horizontal offset to this pixel. @@ -2146,8 +2217,8 @@ /// @returns the pixel. See @ref color_t /// virtual color_t getPixel(loc_t x, loc_t y); - - + + /// Write an RGB565 stream of pixels to the display. /// /// @param[in] p is a pointer to a color_t array to write. @@ -2157,8 +2228,8 @@ /// @returns @ref RetCode_t value. /// virtual RetCode_t pixelStream(color_t * p, uint32_t count, loc_t x, loc_t y); - - + + /// Get a stream of pixels from the display. /// /// @param[in] p is a pointer to a color_t array to accept the stream. @@ -2177,14 +2248,14 @@ /// to either the foreground or background color value and then that pixel /// is pushed onward. /// - /// This is similar, but different, to the @ref pixelStream API, which is + /// This is similar, but different, to the @ref pixelStream API, which is /// given a stream of color values. - /// + /// /// This is most often used for Soft Fonts, and for that reason, this method - /// will scale the presentation based on the selected font size. + /// will scale the presentation based on the selected font size. /// See @ref SetTextFontSize, So, users may want to SetTextFontSize(1) for /// 1:1 scaling. - /// + /// /// @param[in] x is the horizontal position on the display. /// @param[in] y is the vertical position on the display. /// @param[in] w is the width of the rectangular region to fill. @@ -2195,7 +2266,6 @@ /// virtual RetCode_t booleanStream(loc_t x, loc_t y, dim_t w, dim_t h, const uint8_t * boolStream); - /// Draw a line in the specified color /// /// @note As a side effect, this changes the current @@ -2219,7 +2289,7 @@ /// RetCode_t line(point_t p1, point_t p2); - + /// Draw a line in the specified color /// /// @note As a side effect, this changes the current @@ -2252,10 +2322,14 @@ /// /// Draw a line of a specified thickness and color. /// - /// In order to draw a thick line, this draws filled circles using - /// bresenham's algorithm to move the center point of the circle. - /// As a result, this is much slower than drawing a 1-pixel line which - /// uses the hardware line drawing algorithm. + /// In order to draw a thick line, this draws filled circles using + /// and then draws the 'body' of the thick line using filled triangles. This + /// method makes it significantly faster than in prior versions. + /// + /// An older version of this library used Bresenham's algorithm to move the + /// center point of the circle along the line. As a result, this was much + /// slower than drawing a 1-pixel line which uses the hardware line drawing + /// algorithm. /// /// Drawing multiple parallel lines to create a thick line is faster, /// however the line drawing was not guaranteed to fill every pixel @@ -2266,10 +2340,18 @@ /// @param[in] thickness is the line thickness. /// @param[in] color defines the foreground color. /// @returns @ref RetCode_t value. - /// + /// RetCode_t ThickLine(point_t p1, point_t p2, dim_t thickness, color_t color); + /// Set the end-cap for ThickLines - square (default) or rounded. + /// + /// @param[in] roundCap when true causes the end-cap to be drawn as a filled circle. + /// @returns the previous end-cap setting, permitting easy restore. + /// + bool SetEndCap(bool roundCap); + + /// Draw a rectangle in the specified color /// /// @note As a side effect, this changes the current @@ -2281,7 +2363,7 @@ /// @returns @ref RetCode_t value. /// RetCode_t rect(rect_t rect, color_t color, fill_t fillit = NOFILL); - + /// Draw a filled rectangle in the specified color /// @@ -2309,7 +2391,7 @@ /// @param[in] fillit is optional to FILL the rectangle. default is FILL. /// @returns @ref RetCode_t value. /// - RetCode_t rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2, + RetCode_t rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2, color_t color, fill_t fillit = NOFILL); @@ -2326,7 +2408,7 @@ /// @param[in] fillit is optional to NOFILL the rectangle. default is FILL. /// @returns @ref RetCode_t value. /// - virtual RetCode_t fillrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2, + virtual RetCode_t fillrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2, color_t color, fill_t fillit = FILL); @@ -2341,7 +2423,7 @@ /// @param[in] fillit is optional to FILL the rectangle. default is NOFILL. /// @returns @ref RetCode_t value. /// - RetCode_t rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2, + RetCode_t rect(loc_t x1, loc_t y1, loc_t x2, loc_t y2, fill_t fillit = NOFILL); @@ -2360,16 +2442,16 @@ /// @param[in] x2 is the horizontal end of the line and must be >= x1. /// @param[in] y2 is the vertical end of the line and must be >= y1. /// @param[in] radius1 defines the horizontal radius of the curved corner. Take care - /// that this value < 1/2 the width of the rectangle, or bad_parameter + /// that this value < 1/2 the width of the rectangle, or bad_parameter /// is returned. /// @param[in] radius2 defines the vertical radius of the curved corner. Take care - /// that this value < 1/2 the height of the rectangle, or bad_parameter + /// that this value < 1/2 the height of the rectangle, or bad_parameter /// is returned. /// @param[in] color defines the foreground color. /// @param[in] fillit is optional to FILL the rectangle. default is NOFILL. /// @returns @ref RetCode_t value. /// - RetCode_t fillroundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2, + RetCode_t fillroundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2, dim_t radius1, dim_t radius2, color_t color, fill_t fillit = FILL); @@ -2385,16 +2467,16 @@ /// /// @param[in] r is the rectangle to draw. /// @param[in] radius1 defines the horizontal radius of the curved corner. Take care - /// that this value < 1/2 the width of the rectangle, or bad_parameter + /// that this value < 1/2 the width of the rectangle, or bad_parameter /// is returned. /// @param[in] radius2 defines the vertical radius of the curved corner. Take care - /// that this value < 1/2 the height of the rectangle, or bad_parameter + /// that this value < 1/2 the height of the rectangle, or bad_parameter /// is returned. /// @param[in] color defines the foreground color. /// @param[in] fillit is optional to FILL the rectangle. default is NOFILL. /// @returns @ref RetCode_t value. /// - RetCode_t fillroundrect(rect_t r, + RetCode_t fillroundrect(rect_t r, dim_t radius1, dim_t radius2, color_t color, fill_t fillit = FILL); @@ -2410,16 +2492,16 @@ /// /// @param[in] r is the rectangle to draw. /// @param[in] radius1 defines the horizontal radius of the curved corner. Take care - /// that this value < 1/2 the width of the rectangle, or bad_parameter + /// that this value < 1/2 the width of the rectangle, or bad_parameter /// is returned. /// @param[in] radius2 defines the vertical radius of the curved corner. Take care - /// that this value < 1/2 the height of the rectangle, or bad_parameter + /// that this value < 1/2 the height of the rectangle, or bad_parameter /// is returned. /// @param[in] color defines the foreground color. /// @param[in] fillit is optional to FILL the rectangle. default is NOFILL. /// @returns @ref RetCode_t value. /// - RetCode_t roundrect(rect_t r, + RetCode_t roundrect(rect_t r, dim_t radius1, dim_t radius2, color_t color, fill_t fillit = NOFILL); @@ -2438,16 +2520,16 @@ /// @param[in] x2 is the horizontal end of the line and must be >= x1. /// @param[in] y2 is the vertical end of the line and must be >= y1. /// @param[in] radius1 defines the horizontal radius of the curved corner. Take care - /// that this value < 1/2 the width of the rectangle, or bad_parameter + /// that this value < 1/2 the width of the rectangle, or bad_parameter /// is returned. /// @param[in] radius2 defines the vertical radius of the curved corner. Take care - /// that this value < 1/2 the height of the rectangle, or bad_parameter + /// that this value < 1/2 the height of the rectangle, or bad_parameter /// is returned. /// @param[in] color defines the foreground color. /// @param[in] fillit is optional to FILL the rectangle. default is NOFILL. /// @returns @ref RetCode_t value. /// - RetCode_t roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2, + RetCode_t roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2, dim_t radius1, dim_t radius2, color_t color, fill_t fillit = NOFILL); @@ -2463,15 +2545,15 @@ /// @param[in] x2 is the horizontal end of the line and must be >= x1. /// @param[in] y2 is the vertical end of the line and must be >= y1. /// @param[in] radius1 defines the horizontal radius of the curved corner. Take care - /// that this value < 1/2 the width of the rectangle, or bad_parameter + /// that this value < 1/2 the width of the rectangle, or bad_parameter /// is returned. /// @param[in] radius2 defines the vertical radius of the curved corner. Take care - /// that this value < 1/2 the height of the rectangle, or bad_parameter + /// that this value < 1/2 the height of the rectangle, or bad_parameter /// is returned. /// @param[in] fillit is optional to FILL the rectangle. default is NOFILL. /// @returns @ref RetCode_t value. /// - RetCode_t roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2, + RetCode_t roundrect(loc_t x1, loc_t y1, loc_t x2, loc_t y2, dim_t radius1, dim_t radius2, fill_t fillit = NOFILL); @@ -2502,14 +2584,14 @@ /// @returns @ref RetCode_t value. /// RetCode_t triangle(point_t p1, point_t p2, point_t p3, color_t color, fill_t fillit = NOFILL); - + /// Draw a triangle in the specified color. /// /// @note As a side effect, this changes the current /// foreground color for subsequent operations. /// /// @param[in] x1 is the horizontal for point 1. - /// @param[in] y1 is the vertical for point 1. + /// @param[in] y1 is the vertical for point 1. /// @param[in] x2 is the horizontal for point 2. /// @param[in] y2 is the vertical for point 2. /// @param[in] x3 is the horizontal for point 3. @@ -2518,9 +2600,9 @@ /// @param[in] fillit is optional to FILL the rectangle. default is NOFILL. /// @returns @ref RetCode_t value. /// - RetCode_t triangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2, + RetCode_t triangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2, loc_t x3, loc_t y3, color_t color, fill_t fillit = NOFILL); - + /// Draw a filled triangle in the specified color. /// @@ -2537,7 +2619,7 @@ /// @param[in] fillit is optional to FILL the rectangle. default is NOFILL. /// @returns @ref RetCode_t value. /// - RetCode_t filltriangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2, + RetCode_t filltriangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2, loc_t x3, loc_t y3, color_t color, fill_t fillit = FILL); @@ -2554,9 +2636,9 @@ /// @param[in] fillit is optional to FILL the rectangle. default is NOFILL. /// @returns @ref RetCode_t value. /// - RetCode_t triangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2, + RetCode_t triangle(loc_t x1, loc_t y1, loc_t x2, loc_t y2, loc_t x3, loc_t y3, fill_t fillit = NOFILL); - + /// Draw a circle using the specified color. /// @@ -2653,7 +2735,7 @@ /// @param[in] fillit defines whether the circle is filled or not. /// @returns @ref RetCode_t value. /// - RetCode_t ellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, + RetCode_t ellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, color_t color, fill_t fillit = NOFILL); @@ -2670,7 +2752,7 @@ /// @param[in] fillit defines whether the circle is filled or not. /// @returns @ref RetCode_t value. /// - RetCode_t fillellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, + RetCode_t fillellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, color_t color, fill_t fillit = FILL); @@ -2686,7 +2768,7 @@ /// @returns @ref RetCode_t value. /// RetCode_t ellipse(loc_t x, loc_t y, dim_t radius1, dim_t radius2, fill_t fillit = NOFILL); - + /// Block Move @@ -2701,7 +2783,7 @@ /// /// @code /// // Block Move Demo - /// + /// /// // Calibrate the resistive touch screen, and store the data on the /// // local file system. /// // @@ -2711,7 +2793,7 @@ /// tpMatrix_t matrix; /// RetCode_t r; /// Timer testperiod; - /// + /// /// r = lcd.TouchPanelCalibrate("Calibrate the touch panel", &matrix); /// if (r == noerror) { /// fh = fopen("/local/tpcal.cfg", "wb"); @@ -2728,7 +2810,7 @@ /// } /// lcd.cls(); /// } - /// + /// /// // Try to load a previous resistive touch screen calibration from storage. If it /// // doesn't exist, activate the touch screen calibration process. /// // @@ -2736,7 +2818,7 @@ /// { /// FILE * fh; /// tpMatrix_t matrix; - /// + /// /// fh = fopen("/local/tpcal.cfg", "rb"); /// if (fh) { /// fread(&matrix, sizeof(tpMatrix_t), 1, fh); @@ -2755,7 +2837,7 @@ /// TouchCode_t touch; /// const dim_t RECT_W = 100; /// const dim_t RECT_H = 100; - /// + /// /// pc.baud(460800); //I like a snappy terminal, so crank it up! /// pc.printf("\r\nRA8875 BTE Move Test - Build " __DATE__ " " __TIME__ "\r\n"); /// lcd.init(LCD_W,LCD_H,LCD_C, BL_NORM); @@ -2763,7 +2845,7 @@ /// #ifndef CAP_TOUCH /// InitTS(); // Calibration for resistive touch panel /// #endif - /// + /// /// RetCode_t r = lcd.RenderImageFile(0,0,"/local/fullscrn.jpg"); /// if (r) pc.printf(" Error: %d; %s\r\n", r, lcd.GetErrorMessage(r)); /// while (1) { @@ -2771,7 +2853,7 @@ /// if (touch) { /// point_t xy = lcd.TouchCoordinates(); /// TouchCode_t t = lcd.TouchCode(); - /// + /// /// if (t == touch) { /// src = ComputeTopLeftOfRect(xy, RECT_W/2, RECT_H/2, LCD_W, LCD_H); /// } else if (t == release) { @@ -2791,7 +2873,7 @@ /// @param[in] srcPoint [54-57] is a point_t defining the source coordinate. /// @param[in] bte_width [5C-5D]. operation width. /// @param[in] bte_height [5E-5F]. operation height. - /// @param[in] bte_op_code [51.3-0] defines the raster operation function + /// @param[in] bte_op_code [51.3-0] defines the raster operation function /// (write/read/move/...) /// @param[in] bte_rop_code [51.7-4] defines what type of BTE operation to perform /// (what is placed at the destination) @@ -2816,30 +2898,30 @@ /// @returns @ref RetCode_t value. /// RetCode_t Reset(void); - + /// Set backlight brightness. /// - /// When the built-in PWM is used to control the backlight, this + /// When the built-in PWM is used to control the backlight, this /// API can be used to set the brightness. - /// + /// /// @param[in] brightness ranges from 0 (off) to 255 (full on) /// @returns @ref RetCode_t value. /// RetCode_t Backlight_u8(uint8_t brightness); - + /// Get backlight brightness. /// /// @returns backlight setting from 0 (off) to 255 (full on). - /// + /// uint8_t GetBacklight_u8(void); /// Set backlight brightness. /// - /// When the built-in PWM is used to control the backlight, this + /// When the built-in PWM is used to control the backlight, this /// API can be used to set the brightness. - /// + /// /// @param[in] brightness ranges from 0.0 (off) to 1.0 (full on) /// @returns @ref RetCode_t value. /// @@ -2849,14 +2931,14 @@ /// Get backlight brightness. /// /// @returns backlight setting from 0 (off) to 1.0 (full on). - /// + /// float GetBacklight(void); /// Select a User Font for all subsequent text. /// /// @note Tool to create the fonts is accessible from its creator - /// available at http://www.mikroe.com. + /// available at http://www.mikroe.com. /// For version 1.2.0.0, choose the "Export for TFT and new GLCD" /// format. /// @@ -2874,13 +2956,13 @@ /// Get the @ref color_t value from a DOS color index. /// /// See @ref PredefinedColors, @ref color_t. - /// + /// /// @code /// color_t color = DOSColor(12); /// @endcode /// /// @param[in] i is the color index, in the range 0 to 15; - /// @returns the @ref color_t value of the selected index, + /// @returns the @ref color_t value of the selected index, /// or 0 (@ref Black) if the index is out of bounds. /// color_t DOSColor(int i); @@ -2889,7 +2971,7 @@ /// Get the color name (string) from a DOS color index. /// /// See @ref PredefinedColors, @ref color_t. - /// + /// /// @code /// printf("color is %s\n", DOSColorNames(12)); /// @endcode @@ -2897,7 +2979,7 @@ /// @param[in] i is the color index, in the range 0 to 15; /// @returns a pointer to a string with the color name, /// or NULL if the index is out of bounds. - /// + /// const char * DOSColorNames(int i); @@ -2918,11 +3000,11 @@ /// virtual RetCode_t _StartGraphicsStream(void); - + /// Advanced method to put a single color pixel to the screen. /// - /// This method may be called as many times as necessary after - /// See @ref _StartGraphicsStream() is called, and it should be followed + /// This method may be called as many times as necessary after + /// See @ref _StartGraphicsStream() is called, and it should be followed /// by _EndGraphicsStream. /// /// @code @@ -2934,7 +3016,7 @@ /// virtual RetCode_t _putp(color_t pixel); - + /// Advanced method indicating the end of a graphics stream. /// /// This is called to conclude a stream of pixel data that was sent. @@ -2953,7 +3035,7 @@ /// its capabilities. The RA8875 can accept writes via SPI faster /// than a read can be performed. The frequency set by this API /// is for the SPI writes. It will automatically reduce the SPI - /// clock rate when a read is performed, and restore it for the + /// clock rate when a read is performed, and restore it for the /// next write. Alternately, the 2nd parameters permits setting /// the read speed rather than letting it compute it automatically. /// @@ -2983,7 +3065,7 @@ /// 24-bit format. /// /// This method will interrogate the current display setting and - /// create a bitmap based on those settings. For instance, if + /// create a bitmap based on those settings. For instance, if /// only layer 1 is visible, then the bitmap is only layer 1. However, /// if there is some other operation in effect (transparent mode). /// @@ -2995,7 +3077,7 @@ /// @param[in] w is the width of the region to capture /// @param[in] h is the height of the region to capture. /// @param[in] Name_BMP is the filename to write the image to. - /// @param[in] bitsPerPixel is optional, defaults to 24, and only + /// @param[in] bitsPerPixel is optional, defaults to 24, and only /// accepts the values 24, 8 /// NOTE: The downscaling is CPU intensive, and the operation /// takes longer. @@ -3003,7 +3085,7 @@ /// RetCode_t PrintScreen(loc_t x, loc_t y, dim_t w, dim_t h, const char *Name_BMP, uint8_t bitsPerPixel = 24); - + /// This method captures the specified area as a 24-bit bitmap file /// and delivers it to the previously attached callback. /// @@ -3011,7 +3093,7 @@ /// 24-bit format. /// /// This method will interrogate the current display setting and - /// create a bitmap based on those settings. For instance, if + /// create a bitmap based on those settings. For instance, if /// only layer 1 is visible, then the bitmap is only layer 1. However, /// if there is some other operation in effect (transparent mode), it /// will return the blended image. @@ -3023,7 +3105,7 @@ /// @param[in] y is the top edge of the region to capture /// @param[in] w is the width of the region to capture /// @param[in] h is the height of the region to capture. - /// @param[in] bitsPerPixel is optional, defaults to 24, and only + /// @param[in] bitsPerPixel is optional, defaults to 24, and only /// accepts the values 24, 8 /// NOTE: The downscaling is CPU intensive, and the operation /// takes longer. @@ -3031,13 +3113,13 @@ /// RetCode_t PrintScreen(loc_t x, loc_t y, dim_t w, dim_t h, uint8_t bitsPerPixel = 24); - + /// PrintScreen callback registration. /// /// This method attaches a simple c-compatible callback of type PrintCallback_T. /// Then, the PrintScreen(x,y,w,h) method is called. Each chunk of data in the /// BMP file to be created is passed to this callback. - /// + /// /// @param callback is the optional callback function. Without a callback function /// it will unregister the handler. /// @@ -3049,13 +3131,13 @@ /// This method attaches a c++ class method as a callback of type PrintCallback_T. /// Then, the PrintScreen(x,y,w,h) method is called. Each chunk of data in the /// BMP file to be created is passed to this callback. - /// + /// /// @param object is the class hosting the callback function. /// @param method is the callback method in the object to activate. /// template <class T> - void AttachPrintHandler(T *object, RetCode_t (T::*method)(void)) { - obj_callback = (FPointerDummy *)object; + void AttachPrintHandler(T *object, RetCode_t (T::*method)(void)) { + obj_callback = (FPointerDummy *)object; method_callback = (uint32_t (FPointerDummy::*)(uint32_t, uint8_t *, uint16_t))method; } @@ -3081,7 +3163,7 @@ /// RetCode_t PrintScreen(uint16_t layer, loc_t x, loc_t y, dim_t w, dim_t h, const char *Name_BMP); - + /// idle callback registration. /// /// This method attaches a simple c-compatible callback of type IdleCallback_T. @@ -3119,13 +3201,13 @@ #ifdef PERF_METRICS /// Clear the performance metrics to zero. void ClearPerformance(); - + /// Count idle time. /// /// @param[in] t is the amount of idle time to accumulate. /// void CountIdleTime(uint32_t t); - + /// Report the performance metrics for drawing functions using /// the available serial channel. /// @@ -3139,7 +3221,7 @@ void InitAllMemberVars(); /// Touch panel parameters - common to both resistive and capacitive - + /// Data type to indicate which TP, if any, is in use. typedef enum { TP_NONE, ///< no touch panel in use @@ -3148,16 +3230,16 @@ TP_CAP=TP_FT5206, ///< DEPRECATED: used TP_CAP5206 for that chip-set TP_GSL1680, ///< Capacitive touch panel using GSL1680 chip } WhichTP_T; - + /// boolean flag set true when using Capacitive touch panel, and false /// for resistive. WhichTP_T useTouchPanel; ///< Indicates which TP is selected for use. - + /// Touch State used by TouchPanelReadable. See @ref TouchCode_t. TouchCode_t touchState; ////////////////// Start of Capacitive Touch Panel parameters - + int RoundUp(int value, int roundTo); uint8_t FT5206_TouchPositions(void); uint8_t FT5206_ReadRegU8(uint8_t reg); @@ -3169,7 +3251,7 @@ void TouchPanelISR(void); uint16_t numberOfTouchPoints; uint8_t gesture; ///< Holds the reported gesture information (which doesn't work well for the FT5206) - + /// Touch Information data structure typedef struct { uint8_t touchID; ///< Contains the touch ID, which is the "order" of touch, from 0 to n-1 @@ -3189,9 +3271,9 @@ //uint8_t data[2]; /// Transfer data for the I2C interface bool panelTouched; - + ////////////////// Start of Resistive Touch Panel parameters - + /// Resistive Touch Panel register name definitions #define TPCR0 0x70 #define TPCR1 0x71 @@ -3216,29 +3298,29 @@ // the ticker monitors the timer to see if it has been a long time since // a touch, and if so, it then clears the sample counter so it doesn't get partial old // and partial new. - + /// Touch Panel ticker /// This it bound to a timer to call the _TouchTicker() function periodically. /// Ticker touchTicker; - + /// Touch Panel timer /// Reset on a touch, to expire on a non-touch /// Timer timeSinceTouch; - + /// keeps track of which sample we're collecting to filter out the noise. int touchSample; - + /// Private function for touch ticker callback. void _TouchTicker(void); - + /// Touch Panel calibration matrix. tpMatrix_t tpMatrix; /// RESISTIVE TP: The fully qualified filename for the RESISTIVE touch panel configuration settings. const char * tpFQFN; - + /// RESISTIVE TP: The text message shown to the user during the calibration process. const char * tpCalMessage; @@ -3255,21 +3337,21 @@ /// @returns the character put. /// int _internal_putc(int c); - + /// Internal function to put a character using the external font engine /// /// @param[in] c is the character to put to the screen. /// @returns the character put. /// int _external_putc(int c); - + /// Internal function to get the actual width of a character when using the external font engine /// /// @param[in] c is the character to get the width. /// @returns the width in pixels of the character. zero if not found. /// int _external_getCharWidth(int c); - + /// Write color to an RGB register set /// /// This API takes a color value, and writes it into the specified @@ -3282,7 +3364,7 @@ /// @returns @ref RetCode_t value. /// RetCode_t _writeColorTrio(uint8_t regAddr, color_t color); - + /// Read color from an RGB register set /// /// This API reads a color value from a trio of registers. The actual @@ -3293,8 +3375,8 @@ /// @returns color_t value /// color_t _readColorTrio(uint8_t regAddr); - - + + /// Convert a 16-bit color value to an 8-bit value /// /// @param[in] c16 is the 16-bit color value to convert. @@ -3308,7 +3390,7 @@ /// @returns 16-bit color value. /// color_t _cvt8to16(uint8_t c8); - + /// Select the peripheral to use it. /// /// @param[in] chipsel when true will select the peripheral, and when false @@ -3353,7 +3435,7 @@ /// in while shifting out. /// unsigned char _spiwrite(unsigned char data); - + /// The most primitive - to read a data value to the SPI interface. /// /// This is really just a specialcase of the write command, where @@ -3363,9 +3445,9 @@ /// in while shifting out. /// unsigned char _spiread(); - + const uint8_t * pKeyMap; - + SPI spi; ///< spi port bool spiWriteSpeed; ///< indicates if the current mode is write or read unsigned long spiwritefreq; ///< saved write freq @@ -3373,20 +3455,20 @@ DigitalOut cs; ///< RA8875 chip select pin, assumed active low DigitalOut res; ///< RA8875 reset pin, assumed active low DigitalOut * m_wake; ///< GSL1680 wake pin - + // display metrics to avoid lengthy spi read queries uint8_t screenbpp; ///< configured bits per pixel dim_t screenwidth; ///< configured screen width dim_t screenheight; ///< configured screen height - rect_t windowrect; ///< window commands are held here for speed of access + rect_t windowrect; ///< window commands are held here for speed of access bool portraitmode; ///< set true when in portrait mode (w,h are reversed) - + bool wordwrap; ///< set true when wordwrap is in effect for _puts() const unsigned char * font; ///< reference to an external font somewhere in memory uint8_t extFontHeight; ///< computed from the font table when the user sets the font uint8_t extFontWidth; ///< computed from the font table when the user sets the font - + bool roundCap; ///< draw round end cap on thick lines when set. loc_t cursor_x, cursor_y; ///< used for external fonts only - + #ifdef PERF_METRICS typedef enum { @@ -3410,11 +3492,11 @@ void RegisterPerformance(method_e method); Timer performance; #endif - + RetCode_t _printCallback(RA8875::filecmd_t cmd, uint8_t * buffer, uint16_t size); - + FILE * _printFH; ///< PrintScreen file handle - + RetCode_t privateCallback(filecmd_t cmd, uint8_t * buffer, uint16_t size) { if (c_callback != NULL) { return (*c_callback)(cmd, buffer, size); @@ -3426,12 +3508,12 @@ } return noerror; } - + RetCode_t (* c_callback)(filecmd_t cmd, uint8_t * buffer, uint16_t size); FPointerDummy *obj_callback; RetCode_t (FPointerDummy::*method_callback)(filecmd_t cmd, uint8_t * buffer, uint16_t size); RetCode_t (* idle_callback)(IdleReason_T reason, uint16_t param); - + orientation_t screen_orientation; point_t TranslateOrientation(point_t rawPoint); }; @@ -3457,7 +3539,7 @@ extern "C" void mbed_reset(); -/// This activates a small set of tests for the graphics library. +/// This activates a small set of tests for the graphics library. /// /// Call this API and pass it the reference to the display class. /// It will then run a series of tests. It accepts interaction via @@ -3482,7 +3564,7 @@ // { // pc.baud(460800); // I like a snappy terminal, so crank it up! // pc.printf("\r\nRA8875 Test - Build " __DATE__ " " __TIME__ "\r\n"); -// +// // pc.printf("Turning on display\r\n"); // lcd.init(); // lcd.Reset();