diff options
Diffstat (limited to 'abs/extra/lcdproc/lcdproc-add-serdisplib')
| -rw-r--r-- | abs/extra/lcdproc/lcdproc-add-serdisplib | 1353 |
1 files changed, 1353 insertions, 0 deletions
diff --git a/abs/extra/lcdproc/lcdproc-add-serdisplib b/abs/extra/lcdproc/lcdproc-add-serdisplib new file mode 100644 index 0000000..48d239a --- /dev/null +++ b/abs/extra/lcdproc/lcdproc-add-serdisplib @@ -0,0 +1,1353 @@ +[PATCH] Add serdisplib driver + +This patch adds a serdisplib driver for the serdisplib library +(http://serdisplib.sf.net) that is used for low-level accessing of dot-matrix +devices (i.e. such displays that are drived by pixel and not by characters +unlike HD44780, for example). + +I know there's already glcdlib. But that approach has several disadvantages: + + o Unnecessary library dependencies. + o Complicated installation, i.e. you have to edit two configuration files. + o Too much redraws. In fact, that was the reason for me to write this + driver because my ctinclud display (http://www.ct-maeusekino.de) was quite + unusable with the glcdlib driver. The problem is simply that lcdproc + redraws the whole screen each second and it's the task of the driver + to not to redraw it in reality. The problem is now that the glcdproc + driver only has the view of characters, and cannot decide which pixels it + actually has to redraw. And graphlcd which has the per-pixel view doesn't + do that "caching" and simply redraws all. Of course, that _can_ + be changed in graphlcd, but I'm sure that leads to endless discussions and + because I didn't like the glcdlib -> graphlcd -> serdisplib approach + anyway, I decided to write that driver. + +Some important design decisions: + + o The driver is split into lcdgraphic.c and serdisplib.c. All function that + do the character -> pixel "rendering" are split out into lcdgraphic.c, + so it would be possible to write another low-level driver that uses that + function. However, in normal cases it makes more sense to add that part to + serdisplib. + o It only requires FreeType (http://freetype.sf.net) for font rendering. + That's no new real dependency because in almost all cases, graphlcd was + compiled with FreeType support. + o Only mono space fonts are supported. + o The driver implements symbols (arrow, etc.) using Unicode characters of the + font. (The recommended font is Andale Mono which is available for free + from http://corefonts.sf.net) + o Works on i686 and x86_64. + +Please review. The patch is against 0.5.2. If you consider to add this into +CVS, I'll provide documentation. And this time, I'll provide the documentation +in time unlike with the ula200 driver. ;-) + + +Signed-off-by: Bernhard Walle <bernhard.walle@gmx.de> + +--- + LCDd.conf | 28 ++ + acinclude.m4 | 27 +- + server/drivers/Makefile.am | 5 + server/drivers/lcdgraphic.c | 590 ++++++++++++++++++++++++++++++++++++++++++++ + server/drivers/lcdgraphic.h | 195 ++++++++++++++ + server/drivers/serdisplib.c | 379 ++++++++++++++++++++++++++++ + 6 files changed, 1220 insertions(+), 4 deletions(-) + +--- a/acinclude.m4 ++++ b/acinclude.m4 +@@ -10,13 +10,13 @@ AC_ARG_ENABLE(drivers, + [ irman,joy,lb216,lcdm001,lcterm,lirc,MD8800,ms6931,] + [ mtc_s16209x,MtxOrb,NoritakeVFD,picolcd,pyramid,sed1330] + [ sed1520,serialPOS,serialVFD,sli,stv5730,svga,t6963,text,] +- [ tyan,ula200,xosd] ++ [ tyan,ula200,serdisplib,xosd] + [ 'all' compiles all drivers;] + [ 'all,!xxx,!yyy' de-selects previously selected drivers], + drivers="$enableval", + drivers=[bayrad,CFontz,CFontz633,curses,CwLnx,glk,lb216,lcdm001,MtxOrb,pyramid,text]) + +-allDrivers=[bayrad,CFontz,CFontz633,CFontzPacket,curses,CwLnx,ea65,EyeboxOne,g15,glcdlib,glk,hd44780,icp_a106,imon,IOWarrior,irman,joy,lb216,lcdm001,lcterm,lirc,MD8800,ms6931,mtc_s16209x,MtxOrb,NoritakeVFD,picolcd,pyramid,sed1330,sed1520,serialPOS,serialVFD,sli,stv5730,svga,t6963,text,tyan,ula200,xosd] ++allDrivers=[bayrad,CFontz,CFontz633,CFontzPacket,curses,CwLnx,ea65,EyeboxOne,g15,glcdlib,glk,hd44780,icp_a106,imon,IOWarrior,irman,joy,lb216,lcdm001,lcterm,lirc,MD8800,ms6931,mtc_s16209x,MtxOrb,NoritakeVFD,picolcd,pyramid,sed1330,sed1520,serialPOS,serialVFD,sli,stv5730,svga,t6963,text,tyan,ula200,serdisplib,xosd] + + drivers=`echo $drivers | sed -e 's/,/ /g'` + +@@ -383,6 +383,29 @@ dnl else + AC_MSG_WARN([The ula200 driver needs ftdi.h and usb.h]) + ]) + ;; ++ serdisplib) ++ LIBFREETYPE_CFLAGS=`pkg-config --cflags freetype2` ++ LIBFREETYPE_LIBS=`pkg-config --libs freetype2` ++ if test x"$LIBFREETYPE_CFLAGS" = "x" ; then ++ AC_MSG_WARN([The serdisplib driver needs freetype2]) ++ fi ++ ++ AC_CHECK_HEADERS([serdisplib/serdisp.h],[ ++ AC_CHECK_LIB(serdisp, serdisp_nextdisplaydescription,[ ++ LIBSERDISP="-lserdisp" ++ DRIVERS="$DRIVERS serdisplib${SO}" ++ actdrivers=["$actdrivers serdisplib"] ++ ],[ ++ AC_MSG_WARN([The serdisplib driver needs serdisplib]) ++ ]) ++ ],[ ++ AC_MSG_WARN([The serdisplib driver needs serdislib/serdisp.h]) ++ ]) ++ ++ AC_SUBST(LIBFREETYPE_CFLAGS) ++ AC_SUBST(LIBFREETYPE_LIBS) ++ AC_SUBST(LIBSERDISP) ++ ;; + xosd) + AC_CHECK_HEADERS([xosd.h],[ + AC_CHECK_LIB(xosd, main,[ +--- a/server/drivers/Makefile.am ++++ b/server/drivers/Makefile.am +@@ -19,12 +19,13 @@ AM_LDFLAGS = @LDSHARED@ + #LIBS = + + pkglib_PROGRAMS = @DRIVERS@ +-EXTRA_PROGRAMS = bayrad CFontz CFontz633 CFontzPacket curses CwLnx ea65 EyeboxOne g15 glcdlib glk hd44780 icp_a106 imon IOWarrior irman joy lb216 lcdm001 lcterm lirc MD8800 ms6931 mtc_s16209x MtxOrb NoritakeVFD picolcd pyramid sed1330 sed1520 serialPOS serialVFD stv5730 svga t6963 text tyan sli ula200 xosd ++EXTRA_PROGRAMS = bayrad CFontz CFontz633 CFontzPacket curses CwLnx ea65 EyeboxOne g15 glcdlib glk hd44780 icp_a106 imon IOWarrior irman joy lb216 lcdm001 lcterm lirc MD8800 ms6931 mtc_s16209x MtxOrb NoritakeVFD picolcd pyramid sed1330 sed1520 serialPOS serialVFD stv5730 svga t6963 text tyan sli ula200 serdisplib xosd + noinst_LIBRARIES = libLCD.a libbignum.a + + IOWarrior_CFLAGS = @libusb_cflags@ $(AM_CFLAGS) + hd44780_CFLAGS = @libusb_cflags@ $(AM_CFLAGS) + g15_CFLAGS = @libusb_cflags@ $(AM_CFLAGS) ++serdisplib_CFLAGS = @LIBFREETYPE_CFLAGS@ $(AM_CFLAGS) + + CFontz_LDADD = libLCD.a libbignum.a + CFontz633_LDADD = libLCD.a libbignum.a +@@ -53,6 +54,7 @@ svga_LDADD = @LIBSVGA@ + t6963_LDADD = libLCD.a + tyan_LDADD = libLCD.a libbignum.a + ula200_LDADD = libLCD.a @LIBFTDI@ ++serdisplib_LDADD = libLCD.a @LIBSERDISP@ @LIBFREETYPE_LIBS@ + sli_LDADD = libLCD.a + xosd_LDADD = @LIBXOSD@ + +@@ -99,6 +101,7 @@ t6963_SOURCES = lcd.h lcd_lib.h t69 + text_SOURCES = lcd.h text.h text.c report.h + tyan_SOURCES = lcd.h lcd_lib.h tyan_lcdm.h tyan_lcdm.c report.h adv_bignum.h + ula200_SOURCES = lcd.h lcd_lib.h ula200.h ula200.c report.h ++serdisplib_SOURCES = lcd.h serdisplib.h serdisplib.c lcdgraphic.c lcdgraphic.h + sli_SOURCES = lcd.h lcd_lib.h wirz-sli.h wirz-sli.c report.h + xosd_SOURCES = lcd.h xosdlib_drv.c xosdlib_drv.h report.h + +--- /dev/null ++++ b/server/drivers/lcdgraphic.c +@@ -0,0 +1,590 @@ ++// Description: ++ ++/* Copyright (C) 2007 Bernhard Walle <bernhard.walle@gmx.de> ++ ++ This program is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation; either version 2 of the License, or ++ any later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; if not, write to the Free Software ++ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 */ ++ ++#include <stdlib.h> ++#include <stdio.h> ++#include <unistd.h> ++#include <termios.h> ++#include <fcntl.h> ++#include <string.h> ++#include <errno.h> ++#include <limits.h> ++#include <syslog.h> ++#include <stdint.h> ++ ++#include "lcdgraphic.h" ++ ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Defines ++ ++#undef report ++#define lcdgr_report lcdgr->drv->report ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Returns the value of a pixel in the new_buffer buffer. ++// ++// @param lcdgr a pointer to a valid lcdgraphic structure ++// @param x the x location of the pixel ++// @param y the y location of the pixel ++// ++// @return the value of the pixel ++// ++static inline int get_pixel_new(struct lcdgraphic *lcdgr, int x, int y) ++{ ++ if (x >= lcdgr->width || y >= lcdgr->height) ++ return -1; ++ else ++ return lcdgr->new_buffer[lcdgr->width * y + x]; ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Returns the value of a pixel in the disp_buffer buffer. ++// ++// @param lcdgr a pointer to a valid lcdgraphic structure ++// @param x the x location of the pixel ++// @param y the y location of the pixel ++// ++// @return the value of the pixel ++// ++static inline int get_pixel_disp(struct lcdgraphic *lcdgr, int x, int y) ++{ ++ if (x >= lcdgr->width || y >= lcdgr->height) ++ return -1; ++ else ++ return lcdgr->disp_buffer[lcdgr->width * y + x]; ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Sets the value of a pixel in the new_buffer buffer. ++// ++// @param lcdgr a pointer to a valid lcdgraphic structure ++// @param x the x location of the pixel ++// @param y the y location of the pixel ++// @param value the value to which the buffer should be set ++// ++static void set_pixel_new(struct lcdgraphic *lcdgr, int x, int y, int value) ++{ ++ if (x < lcdgr->width && y < lcdgr->height) ++ lcdgr->new_buffer[lcdgr->width * y + x] = value; ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Sets the value of a pixel in the disp_buffer buffer. ++// ++// @param lcdgr a pointer to a valid lcdgraphic structure ++// @param x the x location of the pixel ++// @param y the y location of the pixel ++// @param value the value to which the buffer should be set ++// ++static void set_pixel_disp(struct lcdgraphic *lcdgr, int x, int y, int value) ++{ ++ if (x < lcdgr->width && y < lcdgr->height) ++ lcdgr->disp_buffer[lcdgr->width * y + x] = value; ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Maps a lcdproc icon to a unicode code for an icon. ++// ++// @param icon the lcdproc icon constant ++// ++// @return Unicode value ++// ++static int icon2unicode(int icon) ++{ ++ switch (icon) { ++ case ICON_BLOCK_FILLED: ++ return UNICODE_BLOCK_FILLED; ++ case ICON_HEART_FILLED: ++ return UNICODE_HEART_FILLED; ++ case ICON_HEART_OPEN: ++ return UNICODE_HEART_OPEN; ++ case ICON_ARROW_UP: ++ return UNICODE_ARROW_UP; ++ case ICON_ARROW_DOWN: ++ return UNICODE_ARROW_DOWN; ++ case ICON_ARROW_LEFT: ++ return UNICODE_ARROW_LEFT; ++ case ICON_ARROW_RIGHT: ++ return UNICODE_ARROW_RIGHT; ++ case ICON_SELECTOR_AT_LEFT: ++ return UNICODE_SELECTOR_AT_LEFT; ++ case ICON_SELECTOR_AT_RIGHT: ++ return UNICODE_SELECTOR_AT_RIGHT; ++ case ICON_ELLIPSIS: ++ return UNICODE_ELLIPSIS; ++ default: ++ return -1; ++ } ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Initialises the instance ++// ++// @param lcdgr a pointer to a valid lcdgraphic structure (not initialised, ++// only allocated ++// @param settings a pointer to a settings structure, for a description of the ++// members, see above ++// @param functions a pointer to the functions structure, for a description of ++// the members, see above ++// ++// @return 0 on success, != 0 on failure ++// ++int lcdgraphic_init(struct lcdgraphic *lcdgr, ++ struct lcdgraphic_settings *settings, ++ struct lcdgraphic_functions *functions) ++{ ++ int ret; ++ ++ // check the arguments ++ if (!lcdgr || !functions || !settings) { ++ lcdgr_report(RPT_ERR, "lcdgraphic_init: one of the arguments is NULL"); ++ return -EINVAL; ++ } ++ ++ // check functions ++ if (!functions->setpixel || !functions->clear || !functions->flush) { ++ lcdgr_report(RPT_ERR, "lcdgraphic_init: all functions must be valid"); ++ return -EINVAL; ++ } ++ ++ // validation ++ if (settings->cwidth == 0 || settings->cheight == 0) { ++ lcdgr_report(RPT_ERR, "lcdgraphic_init: cwidth / cheight is 0"); ++ return -EINVAL; ++ } ++ ++ // zero all first ++ memset(lcdgr, 0, sizeof(struct lcdgraphic)); ++ ++ // assign some members ++ lcdgr->width = settings->width; ++ lcdgr->height = settings->height; ++ lcdgr->cwidth = settings->cwidth; ++ lcdgr->cheight = settings->cheight; ++ lcdgr->bwidth = settings->bheight; ++ lcdgr->drv = settings->drv; ++ strncpy(lcdgr->normal_font, settings->normal_font, PATH_MAX); ++ lcdgr->normal_font[PATH_MAX-1] = 0; ++ lcdgr->funcs = *functions; ++ lcdgr->all_dirty = 1; ++ ++ // calculate some stuff ++ lcdgr->num_pixels = lcdgr->width * lcdgr->height; ++ lcdgr->xchars = (lcdgr->width - 2*lcdgr->bwidth) / lcdgr->cwidth; ++ lcdgr->ychars = (lcdgr->height - 2*lcdgr->bheight) / lcdgr->cheight; ++ ++ // initialise freetype ++ ret = FT_Init_FreeType(&lcdgr->ft_library); ++ if (ret != 0) { ++ lcdgr_report(RPT_ERR, "Freetype initialisation failed"); ++ goto out; ++ } ++ ++ // load the font face for freetype ++ ret = FT_New_Face(lcdgr->ft_library, lcdgr->normal_font, 0, ++ &lcdgr->ft_normal_font); ++ if (ret != 0) { ++ lcdgr_report(RPT_ERR, "Freetype creation of font '%s' failed", ++ lcdgr->normal_font); ++ goto out; ++ } ++ ++ // allocate the buffers ++ lcdgr->disp_buffer = (int *)malloc(sizeof(int) * lcdgr->num_pixels); ++ if (!lcdgr->disp_buffer) { ++ lcdgr_report(RPT_ERR, "lcdgraphic_init: malloc of disp_buffer failed"); ++ ret = -ENOMEM; ++ goto out; ++ } ++ ++ lcdgr->new_buffer = (int *)malloc(sizeof(int) * lcdgr->num_pixels); ++ if (!lcdgr->new_buffer) { ++ lcdgr_report(RPT_ERR, "lcdgraphic_init: malloc of new_buffer failed"); ++ ret = -ENOMEM; ++ goto out; ++ } ++ ++ // clear buffers initially ++ memset(lcdgr->new_buffer, 0, sizeof(int) * lcdgr->num_pixels); ++ memset(lcdgr->disp_buffer, 0, sizeof(int) * lcdgr->num_pixels); ++ ++ return 0; ++ ++out: ++ if (lcdgr->ft_normal_font) ++ FT_Done_Face(lcdgr->ft_normal_font); ++ if (lcdgr->ft_library) ++ FT_Done_FreeType(lcdgr->ft_library); ++ if (lcdgr->new_buffer) ++ free(lcdgr->new_buffer); ++ if (lcdgr->disp_buffer) ++ free(lcdgr->disp_buffer); ++ ++ return ret; ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Destroys the instance ++// ++// @param lcdgr a pointer to a valid lcdgraphic structure ++// ++void lcdgraphic_destroy(struct lcdgraphic *lcdgr) ++{ ++ if (!lcdgr) { ++ lcdgr_report(RPT_ERR, "lcdgraphic_destroy: lcdgr == NULL"); ++ return; ++ } ++ ++ if (lcdgr->ft_normal_font) ++ FT_Done_Face(lcdgr->ft_normal_font); ++ if (lcdgr->ft_library) ++ FT_Done_FreeType(lcdgr->ft_library); ++ ++ free(lcdgr->disp_buffer); ++ free(lcdgr->new_buffer); ++ ++ // allow multiple calls of that function ++ lcdgr->disp_buffer = NULL; ++ lcdgr->new_buffer = NULL; ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Returns the number of characters in one line. This function can be used ++// inside the width callback of the display driver. ++// ++// @param lcdgr a pointer to a valid lcdgraphic structure ++// ++// @return the number of characters in a line ++// ++int lcdgraphic_width(struct lcdgraphic *lcdgr) ++{ ++ if (!lcdgr) { ++ lcdgr_report(RPT_ERR, "lcdgraphic_destroy: lcdgr == NULL"); ++ return -1; ++ } ++ ++ return lcdgr->xchars; ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Returns the number of lines. This function can be used inside the height ++// callback of the display driver. ++// ++// @param lcdgr a pointer to a valid lcdgraphic structure ++// ++// @return the number lines ++// ++int lcdgraphic_height(struct lcdgraphic *lcdgr) ++{ ++ if (!lcdgr) { ++ lcdgr_report(RPT_ERR, "lcdgraphic_destroy: lcdgr == NULL"); ++ return -1; ++ } ++ ++ return lcdgr->ychars; ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Clears the buffer. Doesn't draw anything. ++// ++// @param lcdgr a pointer to a valid lcdgraphic structure ++// ++void lcdgraphic_clear(struct lcdgraphic *lcdgr) ++{ ++ if (!lcdgr) { ++ lcdgr_report(RPT_ERR, "lcdgraphic_destroy: lcdgr == NULL"); ++ return; ++ } ++ ++ memset(lcdgr->new_buffer, 0, sizeof(int) * lcdgr->num_pixels); ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Draws a string into the display buffer. This calls lcdgraphic_draw_char() ++// internally. ++// ++// @param lcdgr a pointer to a valid lcdgraphic structure ++// @param x the column (position in characters!) where the character ++// should be drawn ++// @param y the line (position in characters!) where the character ++// should be drawn ++// @param str the string that should be drawn ++// ++void lcdgraphic_draw_string(struct lcdgraphic *lcdgr, int x, int y, char *str) ++{ ++ int i; ++ int num_chars = strlen(str); ++ ++ // check string length ++ if (x + num_chars > lcdgr->xchars) { ++ lcdgr_report(RPT_WARNING, "lcdgraphic_draw_string: %dx%d - %s too long", ++ x, y, str); ++ return; ++ } ++ ++ for (i = 0; i < num_chars; i++) ++ lcdgraphic_draw_char(lcdgr, x + i, y, str[i]); ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Draws a Unicode character into the display buffer. ++// ++// @param lcdgr a pointer to a valid lcdgraphic structure ++// @param x the column (position in characters!) where the character ++// should be drawn ++// @param y the line (position in characters!) where the character ++// should be drawn ++// @param c the character that should be drawn (unicode code) ++// @param scale for big numbers -- the number of cells that the rendered ++// string should occupy ++// @param width the width in characters ++// ++static int lcdgraphic_draw_char_unicode(struct lcdgraphic *lcdgr, ++ int x, ++ int y, ++ int c, ++ int scale, ++ int width) ++{ ++ static int last_font_size = -1; ++ int xoffset, yoffset; // in pixel ++ int err; ++ FT_Bitmap *bitmap; ++ unsigned char *bitmap_buf; ++ int col, row; ++ FT_GlyphSlot glyph; ++ FT_Face face; ++ int cwidth, cheight; ++ int font_size; ++ ++ face = lcdgr->ft_normal_font; ++ xoffset = lcdgr->bwidth + x*lcdgr->cwidth; ++ yoffset = lcdgr->bheight + y*lcdgr->cheight; ++ ++ // set the font size ++ font_size = lcdgr->cheight * scale; ++ if (last_font_size != font_size) { ++ err = FT_Set_Pixel_Sizes(lcdgr->ft_normal_font, font_size, font_size); ++ if (err != 0) { ++ lcdgr_report(RPT_ERR, "Failed to set pixel size (%dx%x)", ++ lcdgr->cwidth * scale, lcdgr->cheight * scale); ++ return -1; ++ } ++ ++ last_font_size = font_size; ++ } ++ ++ // load the glyph and render it ++ err = FT_Load_Char(lcdgr->ft_normal_font, c, ++ FT_LOAD_RENDER | FT_LOAD_MONOCHROME); ++ if (err != 0) { ++ lcdgr_report(RPT_WARNING, "lcdgraphic_draw_char: loading char " ++ "'%c' (%d) failed", c, c); ++ ++ return -1; ++ } ++ ++ // clear the rectangle first ++ cwidth = lcdgr->cwidth * width; ++ cheight = lcdgr->cheight * scale; ++ for (col = 0; col < cwidth; col++) ++ for (row = 0; row < cheight; row++) ++ set_pixel_new(lcdgr, xoffset + col, yoffset + row, 0); ++ ++ // set some data elements for convenience ++ glyph = lcdgr->ft_normal_font->glyph; ++ bitmap = &glyph->bitmap; ++ bitmap_buf = bitmap->buffer; ++ ++ // and now copy the pixels ++ for (row = 0; row < bitmap->rows; row++) { ++ for (col = 0; col < bitmap->width; col++) { ++ int bitmap_left = glyph->bitmap_left; ++ ++ if (scale != width) ++ bitmap_left = (cwidth - bitmap->width)/2; ++ ++ set_pixel_new(lcdgr, xoffset + col + bitmap_left, ++ yoffset + row + lcdgr->cheight + (face->size->metrics.descender >> 6) ++ - glyph->bitmap_top, ++ bitmap_buf[col/8] >> (7 - (col % 8)) & 1); ++ } ++ bitmap_buf += bitmap->pitch; ++ } ++ ++ return 0; ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Draws a character into the display buffer. ++// ++// @param lcdgr a pointer to a valid lcdgraphic structure ++// @param x the column (position in characters!) where the character ++// should be drawn ++// @param y the line (position in characters!) where the character ++// should be drawn ++// @param c the character that should be drawn ++// ++void lcdgraphic_draw_char(struct lcdgraphic *lcdgr, int x, int y, char c) ++{ ++ if (lcdgraphic_draw_char_unicode(lcdgr, x, y, c & 0xff, 1, 1) != 0) ++ lcdgraphic_draw_char_unicode(lcdgr, x, y, '?', 1, 1); ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Draws a big number into the display buffer. ++// ++// @param lcdgr a pointer to a valid lcdgraphic structure ++// @param x the x position ++// @param num the actual number ++// ++void lcdgraphic_draw_num(struct lcdgraphic *lcdgr, int x, int num) ++{ ++ int y; ++ const int BIG_HEIGHT = 3; ++ ++ if (num < 0 || num > 10) { ++ lcdgr_report(RPT_WARNING, "lcdgraphic_draw_num: num out of range (%d)", num); ++ return; ++ } ++ ++ y = lcdgr->ychars - (lcdgr->ychars - BIG_HEIGHT + 1)/2; ++ if (num == 10) ++ lcdgraphic_draw_char_unicode(lcdgr, x, y, ':', BIG_HEIGHT, 1); ++ else ++ lcdgraphic_draw_char_unicode(lcdgr, x, y, '0' + num, BIG_HEIGHT, BIG_HEIGHT); ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Draws an icon (which standard lcdproc icon syntax) ++// ++// @param lcdgr a pointer to a valid lcdgraphic structure ++// @param x the x position of the icon ++// @param y the y position of the icon ++// @param icon the icon constant ++// ++// @return 0 on success, -1 on failure (i.e. the core replaces the icon by a ++// suitable character ++// ++int lcdgraphic_icon(struct lcdgraphic *lcdgr, int x, int y, int icon) ++{ ++ int unicode; ++ ++ unicode = icon2unicode(icon); ++ if (unicode > 0) ++ return lcdgraphic_draw_char_unicode(lcdgr, x, y, unicode, 1, 1); ++ else ++ return -1; ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Draws a horizontal bar ++// ++// @param lcdgr a pointer to a valid lcdgraphic structure ++// @param x the x position of the bar ++// @param y the y position of the bar ++// @param len the maximum length ++// @param promille the current state ++// @param options ++// ++void lcdgraphic_hbar(struct lcdgraphic *lcdgr, ++ int x, ++ int y, ++ int len, ++ int promille, ++ int options) ++{ ++ int startx, midx, endx, starty, endy; ++ int col, row; ++ ++ /* calculate positions */ ++ startx = lcdgr->bwidth + x*lcdgr->cwidth; ++ midx = startx + promille * (len*lcdgr->cwidth) / 1000; ++ endx = startx + len*lcdgr->cwidth; ++ starty = lcdgr->bheight + y*lcdgr->cheight; ++ endy = starty + lcdgr->cheight - 1; /* don't draw the last line */ ++ ++ for (col = startx; col < endx; col++) ++ for (row = starty; row < endy; row++) ++ set_pixel_new(lcdgr, col, row, col < midx); ++} ++ ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Draws a vertical bar ++// ++// @param lcdgr a pointer to a valid lcdgraphic structure ++// @param x the x position of the bar ++// @param y the y position of the bar ++// @param len the maximum length ++// @param promille the current state ++// @param options ++// ++void lcdgraphic_vbar(struct lcdgraphic *lcdgr, ++ int x, ++ int y, ++ int len, ++ int promille, ++ int options) ++{ ++ int startx, endx, starty, midy, endy; ++ int col, row; ++ ++ /* calculation positions */ ++ startx = lcdgr->bwidth + x*lcdgr->cwidth; ++ endx = startx + lcdgr->cwidth - 1; /* don't draw the last column */ ++ starty = lcdgr->bheight + (y + 1)*lcdgr->cheight - 1; ++ midy = starty - promille * (len*lcdgr->cheight) / 1000; ++ endy = starty - len*lcdgr->cheight; ++ ++ for (col = startx; col < endx; col++) ++ for (row = starty; row > endy; row--) ++ set_pixel_new(lcdgr, col, row, row > midy); ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Flushes the output to the display. Uses the provided callback functions ++// of the underlying display. ++// ++// @param lcdgr a pointer to a valid lcdgraphic structure ++// ++void lcdgraphic_flush(struct lcdgraphic *lcdgr) ++{ ++ int x, y; ++ ++ if (lcdgr->all_dirty) ++ lcdgr->funcs.clear(lcdgr->drv); ++ ++ for (y = 0; y < lcdgr->height; y++) { ++ for (x = 0; x < lcdgr->width; x++) { ++ int val = get_pixel_new(lcdgr, x, y); ++ ++ if (lcdgr->all_dirty || ++ (val != get_pixel_disp(lcdgr, x, y)) ) { ++ lcdgr->funcs.setpixel(lcdgr->drv, x, y, val); ++ set_pixel_disp(lcdgr, x, y, val); ++ } ++ } ++ } ++ ++ lcdgr->funcs.flush(lcdgr->drv); ++ lcdgr->all_dirty = 0; ++} ++ ++// vimx: set sw=4 ts=4 et: +--- /dev/null ++++ b/server/drivers/lcdgraphic.h +@@ -0,0 +1,195 @@ ++// Description: ++ ++/* Copyright (C) 2007 Bernhard Walle <bernhard.walle@gmx.de> ++ ++ This program is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation; either version 2 of the License, or ++ any later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; if not, write to the Free Software ++ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 */ ++ ++#ifndef LCDGRAPHIC_H ++#define LCDGRAPHIC_H ++ ++#include <stdlib.h> ++#include <stdio.h> ++#include <unistd.h> ++#include <termios.h> ++#include <fcntl.h> ++#include <string.h> ++#include <errno.h> ++#include <syslog.h> ++#include <iconv.h> ++ ++#ifdef HAVE_CONFIG_H ++# include "config.h" ++#endif ++ ++#include <ft2build.h> ++#include FT_FREETYPE_H ++ ++#include <serdisplib/serdisp.h> ++ ++ ++#include "lcd.h" ++#include "report.h" ++#include "timing.h" ++ ++/////////////////////////////////////////////////////////////////////////////// ++// constants ++// ++ ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Unicode characters ++// ++ ++#define UNICODE_BLOCK_FILLED 0x2588 ++#define UNICODE_HEART_OPEN 0x2661 ++#define UNICODE_HEART_FILLED 0x2665 ++#define UNICODE_ARROW_UP 0x2191 ++#define UNICODE_ARROW_DOWN 0x2193 ++#define UNICODE_ARROW_LEFT 0x2190 ++#define UNICODE_ARROW_RIGHT 0x2192 ++#define UNICODE_CHECKBOX_OFF -1 /* -1 == not implemented */ ++#define UNICODE_CHECKBOX_ON -1 ++#define UNICODE_CHECKBOX_GRAY -1 ++#define UNICODE_SELECTOR_AT_LEFT -1 ++#define UNICODE_SELECTOR_AT_RIGHT -1 ++#define UNICODE_ELLIPSIS -1 ++ ++/////////////////////////////////////////////////////////////////////////////// ++// These are callback functions that the low level driver must provide ++// ++struct lcdgraphic_functions { ++ ++ // sets the colour of a pixel ++ void (*setpixel)(Driver *drvthis, int x, int y, int pixel); ++ ++ // clears the whole display ++ void (*clear)(Driver *drvthis); ++ ++ // flushes the display ++ void (*flush)(Driver *drvthis); ++}; ++ ++ ++/////////////////////////////////////////////////////////////////////////////// ++// That structure should be passed by the user, while struct lcdgraphic is ++// entirely private to the library ++struct lcdgraphic_settings { ++ ++ // the width and the height (in number of pixels) of the display ++ int width, height; ++ ++ // the width and the height of one character ++ int cwidth, cheight; ++ ++ // defines unused area on the display (border width / border height) ++ int bwidth, bheight; ++ ++ // that's the cookie that is passed to the callback functions ++ // it's also used for reporting errors ++ Driver *drv; ++ ++ // font file used for normal characters (TTF, must be monospaced) ++ char normal_font[PATH_MAX]; ++}; ++ ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Private structure for drivers that use the functions of that library. ++// Don't access the members by hand here. ++// ++struct lcdgraphic { ++ ++ // --- public members from the structure above ----- ++ ++ // the width and the height (in number of pixels) of the display ++ int width, height; ++ ++ // the width and the height of one character ++ int cwidth, cheight; ++ ++ // defines unused area on the display (border width / border height) ++ int bwidth, bheight; ++ ++ // that's the cookie that is passed to the callback functions ++ // it's also used for reporting errors ++ Driver *drv; ++ ++ // font file used for normal characters (TTF, must be monospaced) ++ char normal_font[PATH_MAX]; ++ ++ // a set of callback functions ++ struct lcdgraphic_functions funcs; ++ ++ // --- private members ----- ++ ++ // the framebuffer that's actually displayed ++ int *disp_buffer; ++ ++ // the buffer that shows the contents of the next update but wasn't ++ // flushed yet ++ int *new_buffer; ++ ++ // (calculated) convenience value because we need that often ++ int num_pixels; ++ ++ // (calculated) number of characters in both directions ++ int xchars, ychars; ++ ++ // all buffers are dirty, i.e. update all ++ int all_dirty; ++ ++ // freetype library handle ++ FT_Library ft_library; ++ ++ // handle for the normal font ++ FT_Face ft_normal_font; ++ ++ // handle for charset convertions ++ iconv_t iconv_handle; ++}; ++ ++// Forward declarations for 'clients' ++ ++int lcdgraphic_init(struct lcdgraphic *lcdgr, ++ struct lcdgraphic_settings *settings, ++ struct lcdgraphic_functions *functions); ++ ++int lcdgraphic_width(struct lcdgraphic *lcdgr); ++int lcdgraphic_height(struct lcdgraphic *lcdgr); ++void lcdgraphic_destroy(struct lcdgraphic *lcdgr); ++void lcdgraphic_clear(struct lcdgraphic *lcdgr); ++void lcdgraphic_flush(struct lcdgraphic *lcdgr); ++void lcdgraphic_draw_string(struct lcdgraphic *lcdgr, int x, int y, char *str); ++void lcdgraphic_draw_char(struct lcdgraphic *lcdgr, int x, int y, char c); ++void lcdgraphic_draw_num(struct lcdgraphic *lcdgr, int x, int num); ++int lcdgraphic_icon(struct lcdgraphic *lcdgr, int x, int y, int icon); ++ ++void lcdgraphic_hbar(struct lcdgraphic *lcdgr, ++ int x, ++ int y, ++ int len, ++ int promille, ++ int options); ++ ++void lcdgraphic_vbar(struct lcdgraphic *lcdgr, ++ int x, ++ int y, ++ int len, ++ int promille, ++ int options); ++ ++#endif /* LCDGRAPHIC_H */ ++ ++// vim: set sw=4 ts=4 et: +--- /dev/null ++++ b/server/drivers/serdisplib.c +@@ -0,0 +1,379 @@ ++// Description: ++ ++/* Copyright (C) 2007 Bernhard Walle <bernhard.walle@gmx.de> ++ ++ This program is free software; you can redistribute it and/or modify ++ it under the terms of the GNU General Public License as published by ++ the Free Software Foundation; either version 2 of the License, or ++ any later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++ GNU General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; if not, write to the Free Software ++ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 */ ++ ++#include <stdlib.h> ++#include <stdio.h> ++#include <unistd.h> ++#include <termios.h> ++#include <fcntl.h> ++#include <string.h> ++#include <errno.h> ++#include <limits.h> ++#include <syslog.h> ++ ++#include <serdisplib/serdisp.h> ++ ++#ifdef HAVE_CONFIG_H ++# include "config.h" ++#endif ++ ++#include "lcd.h" ++#include "report.h" ++#include "timing.h" ++#include "lcdgraphic.h" ++ ++/* Vars for the server core */ ++MODULE_EXPORT char *api_version = API_VERSION; ++MODULE_EXPORT int stay_in_foreground = 0; ++MODULE_EXPORT int supports_multiple = 1; ++MODULE_EXPORT char *symbol_prefix = "serdisplib_"; ++ ++/////////////////////////////////////////////////////////////////////////////// ++// constants ++// ++#define SERDISPLIB_MAX_DISPLAYNAME 32 ++#define SERDISPLIB_MAX_DEVICENAME PATH_MAX ++ ++/////////////////////////////////////////////////////////////////////////////// ++// private data types ++// ++typedef struct { ++ ++ // the name of the display driver in serdisplib, e.g. 'ctinclud' ++ char display_name[SERDISPLIB_MAX_DISPLAYNAME]; ++ ++ // the name of the device in serdisplib, e.g. /dev/parport0 ++ char display_device[SERDISPLIB_MAX_DEVICENAME]; ++ ++ // the serdisplib connection handle ++ serdisp_CONN_t* serdisplib_conn; ++ ++ // the serdisplib handle ++ serdisp_t *serdisplib; ++ ++ // invert the display ++ int invert; ++ ++ // the lcdgraphic handle ++ struct lcdgraphic *lcdgraphic; ++ ++} PrivateData; ++ ++ ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Callback functions ++// ++ ++static void callback_setpixel(Driver *drvthis, int x, int y, int pixel) ++{ ++ PrivateData *p = (PrivateData *) drvthis->private_data; ++ ++ serdisp_setcolour(p->serdisplib, x, y, pixel ? SD_COL_BLACK : SD_COL_WHITE); ++} ++ ++static void callback_clear(Driver *drvthis) ++{ ++ PrivateData *p = (PrivateData *) drvthis->private_data; ++ ++ serdisp_clearbuffer(p->serdisplib); ++} ++ ++static void callback_flush(Driver *drvthis) ++{ ++ PrivateData *p = (PrivateData *) drvthis->private_data; ++ ++ serdisp_update(p->serdisplib); ++} ++ ++struct lcdgraphic_functions lcdgraphic_functions = { ++ .setpixel = callback_setpixel, ++ .clear = callback_clear, ++ .flush = callback_flush ++}; ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Init the driver and display ++// ++MODULE_EXPORT int ++serdisplib_init(Driver *drvthis) ++{ ++ PrivateData *p; ++ int ret; ++ struct lcdgraphic_settings settings; ++ const char *s; ++ ++ // Alocate and store private data ++ p = (PrivateData *) malloc(sizeof(PrivateData)); ++ if (!p) ++ return -1; ++ if (drvthis->store_private_ptr(drvthis, p)) ++ return -1; ++ memset(p, 0, sizeof(PrivateData)); ++ ++ // get the display name ++ s = drvthis->config_get_string(drvthis->name, "display_name", 0, NULL); ++ if (!s) { ++ report(RPT_ERR, "You must specify display_name in configuration"); ++ goto out; ++ } ++ strncpy(p->display_name, s, SERDISPLIB_MAX_DISPLAYNAME); ++ p->display_name[SERDISPLIB_MAX_DISPLAYNAME-1] = 0; ++ ++ // get the display device ++ s = drvthis->config_get_string(drvthis->name, "display_device", 0, NULL); ++ if (!s) { ++ report(RPT_ERR, "You must specify display_device in configuration"); ++ goto out; ++ } ++ strncpy(p->display_device, s, SERDISPLIB_MAX_DEVICENAME); ++ p->display_device[SERDISPLIB_MAX_DEVICENAME-1] = 0; ++ ++ // get the normal font ++ s = drvthis->config_get_string(drvthis->name, "normal_font", 0, NULL); ++ if (!s) { ++ report(RPT_ERR, "You must specify normal_font in configuration"); ++ goto out; ++ } ++ strncpy(settings.normal_font, s, PATH_MAX); ++ settings.normal_font[PATH_MAX-1] = 0; ++ ++ // character size ++ s = drvthis->config_get_string(drvthis->name, "char_size", 0, "6x10"); ++ if (!s) { ++ report(RPT_ERR, "Could not retrieve char_size from configuration"); ++ goto out; ++ } ++ if (sscanf(s, "%dx%d", &settings.cwidth, &settings.cheight) != 2) { ++ report(RPT_ERR, "Could not scan '%s' correctly", s); ++ goto out; ++ } ++ ++ // border size ++ s = drvthis->config_get_string(drvthis->name, "border_size", 0, "0x0"); ++ if (!s) { ++ report(RPT_ERR, "Could not retrieve border size from configuration"); ++ goto out; ++ } ++ if (sscanf(s, "%dx%d", &settings.bwidth, &settings.bheight) != 2) { ++ report(RPT_ERR, "Could not scan '%s' correctly", s); ++ goto out; ++ } ++ ++ // invert ++ p->invert = drvthis->config_get_bool(drvthis->name, "invert", 0, 1); ++ ++ ++ /* End of config file parsing */ ++ ++ // opening the output device */ ++ p->serdisplib_conn = SDCONN_open(p->display_device); ++ if (!p->serdisplib_conn) { ++ report(RPT_ERR, "Could not open %s: %s", p->display_device, ++ sd_geterrormsg()); ++ goto out; ++ } ++ ++ // opening and initialising the display ++ p->serdisplib = serdisp_init(p->serdisplib_conn, p->display_name, ""); ++ if (!p->serdisplib) { ++ report(RPT_ERR, "Error opening display %s: %s\n", p->display_name, ++ sd_geterrormsg()); ++ goto out; ++ } ++ ++ // invert settings ++ serdisp_setoption(p->serdisplib, "INVERT", p->invert ++ ? SD_OPTION_YES : SD_OPTION_NO); ++ ++ // allocate lcdgraphic handle ++ p->lcdgraphic = (struct lcdgraphic *)malloc(sizeof(struct lcdgraphic)); ++ if (!p->lcdgraphic) { ++ report(RPT_ERR, "Not enough memory to allocate struct lcdgraphic"); ++ goto out; ++ } ++ ++ // register at the lcdgraphic backend ++ settings.width = serdisp_getwidth(p->serdisplib); ++ settings.height = serdisp_getheight(p->serdisplib); ++ settings.drv = drvthis; ++ ++ ret = lcdgraphic_init(p->lcdgraphic, &settings, &lcdgraphic_functions); ++ if (ret != 0) { ++ report(RPT_ERR, "Error registering at lcdgraphic subsystem"); ++ goto out; ++ } ++ ++ return 0; ++ ++out: ++ if (p->serdisplib_conn && !p->serdisplib) ++ SDCONN_close(p->serdisplib_conn); ++ if (p->serdisplib) ++ serdisp_quit(p->serdisplib); ++ drvthis->store_private_ptr(drvthis, NULL); ++ free(p); ++ ++ return -1; ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Clean-up ++// ++MODULE_EXPORT void ++serdisplib_close(Driver *drvthis) ++{ ++ PrivateData *p = (PrivateData *) drvthis->private_data; ++ ++ if (p) { ++ if (p->serdisplib) ++ serdisp_quit(p->serdisplib); ++ if (p->lcdgraphic) ++ lcdgraphic_destroy(p->lcdgraphic); ++ } ++ drvthis->store_private_ptr(drvthis, NULL); ++ free(p); ++} ++ ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Returns the display width ++// ++MODULE_EXPORT int ++serdisplib_width (Driver *drvthis) ++{ ++ PrivateData *p = (PrivateData *) drvthis->private_data; ++ ++ return lcdgraphic_width(p->lcdgraphic); ++} ++ ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Returns the display height ++// ++MODULE_EXPORT int ++serdisplib_height (Driver *drvthis) ++{ ++ PrivateData *p = (PrivateData *) drvthis->private_data; ++ ++ return lcdgraphic_height(p->lcdgraphic); ++} ++ ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Clear the framebuffer ++// ++MODULE_EXPORT void ++serdisplib_clear (Driver *drvthis) ++{ ++ PrivateData *p = (PrivateData *) drvthis->private_data; ++ ++ lcdgraphic_clear(p->lcdgraphic); ++} ++ ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Place a character in the framebuffer ++// ++MODULE_EXPORT void ++serdisplib_chr (Driver *drvthis, int x, int y, char ch) ++{ ++ PrivateData *p = (PrivateData *) drvthis->private_data; ++ ++ lcdgraphic_draw_char(p->lcdgraphic, x - 1, y - 1, ch); ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Place a string in the framebuffer ++// ++MODULE_EXPORT void ++serdisplib_string (Driver *drvthis, int x, int y, char *s) ++{ ++ PrivateData *p = (PrivateData *) drvthis->private_data; ++ ++ lcdgraphic_draw_string(p->lcdgraphic, x - 1, y - 1, s); ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Place a big number in the framebuffer ++// ++MODULE_EXPORT void ++serdisplib_num (Driver *drvthis, int x, int num) ++{ ++ PrivateData *p = (PrivateData *) drvthis->private_data; ++ ++ lcdgraphic_draw_num(p->lcdgraphic, x - 1, num); ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Sets the backlight on or off ++// ++MODULE_EXPORT void ++serdisplib_backlight (Driver *drvthis, int on) ++{ ++ PrivateData *p = (PrivateData *) drvthis->private_data; ++ ++ serdisp_setoption(p->serdisplib, "BACKLIGHT", on ? SD_OPTION_YES : SD_OPTION_NO); ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Flush the framebuffer to the display ++// ++MODULE_EXPORT void ++serdisplib_flush(Driver *drvthis) ++{ ++ PrivateData *p = (PrivateData *) drvthis->private_data; ++ ++ lcdgraphic_flush(p->lcdgraphic); ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Set default icon into a userdef char ++// ++MODULE_EXPORT int ++serdisplib_icon(Driver *drvthis, int x, int y, int icon) ++{ ++ PrivateData *p = (PrivateData *) drvthis->private_data; ++ ++ return lcdgraphic_icon(p->lcdgraphic, x - 1, y - 1, icon); ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Draws a horizontal bar ++// ++MODULE_EXPORT void ++serdisplib_hbar(Driver *drvthis, int x, int y, int len, int promille, int options) ++{ ++ PrivateData *p = (PrivateData *) drvthis->private_data; ++ ++ lcdgraphic_hbar(p->lcdgraphic, x - 1, y - 1, len, promille, options); ++} ++ ++/////////////////////////////////////////////////////////////////////////////// ++// Draws a vertical bar ++// ++MODULE_EXPORT void ++serdisplib_vbar(Driver *drvthis, int x, int y, int len, int promille, int options) ++{ ++ PrivateData *p = (PrivateData *) drvthis->private_data; ++ ++ lcdgraphic_vbar(p->lcdgraphic, x - 1, y - 1, len, promille, options); ++} ++ ++ ++// vim: set sw=4 ts=4 et: +--- a/LCDd.conf ++++ b/LCDd.conf +@@ -40,7 +40,8 @@ + # EyeboxOne, g15, glcdlib, glk, hd44780, icp_a106, imon, IOWarrior, + # irman, joy, lb216, lcdm001, lcterm, lirc, MD8800, ms6931, mtc_s16209x, + # MtxOrb, NoritakeVFD, picolcd, pyramid, sed1330, sed1520, serialPOS, +-# serialVFD, sli, stv5730, svga, t6963, text, tyan, ula200, xosd ++# serialVFD, sli, stv5730, svga, t6963, text, tyan, ula200, serdisplib, ++# xosd + Driver=curses + + # Tells the driver to bind to the given interface +@@ -931,6 +932,31 @@ Size=20x4 + # KeyMap_E=Enter + # KeyMap_F=Escape + ++## serdisplib meta-driver for dot-matrix displays ## ++[serdisplib] ++ ++# the underlying serdisplib driver, e.g. ctinclud ++display_name=ctinclud ++ ++# the display device, e.g. serraw:/dev/ttyS0, parport:/dev/parport0 ++# or USB:07c0/1501 (vendor ID, device ID) ++display_device=USB:07c0/1501 ++ ++# the font which is used for rendering, this font must be monospace ++# and should contain some special Unicode characters like arrows ++# (Andale Mono is recommended and can be fetched at ++# http://corefonts.sf.net or from a Windows installation) ++normal_font=/usr/share/fonts/truetype/andalemo.ttf ++ ++# invert the display (black => white, white => black) ++invert=0 ++ ++# the size of one characters, the number of characters is calculated ++# automatically from this and from border_size (see below) ++char_size=6x10 ++ ++# size of the border around the drawing area ++border_size=0 + + + ## Wirz SLI LCD driver ## |