/* $Id: drv_LCDLinux.c,v 1.10 2005/08/27 07:02:25 reinelt Exp $ * * driver for the LCD-Linux HD44780 kernel driver * http://lcd-linux.sourceforge.net * * Copyright (C) 2005 Michael Reinelt * Copyright (C) 2005 The LCD4Linux Team * * This file is part of LCD4Linux. * * LCD4Linux 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, or (at your option) * any later version. * * LCD4Linux 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., 675 Mass Ave, Cambridge, MA 02139, USA. * * * $Log: drv_LCDLinux.c,v $ * Revision 1.10 2005/08/27 07:02:25 reinelt * LCD-Linux updated to 0.9.0 * * Revision 1.9 2005/06/15 05:24:35 reinelt * updated LCD-Linux driver to version 0.8.9 * * Revision 1.8 2005/05/08 04:32:44 reinelt * CodingStyle added and applied * * Revision 1.7 2005/05/02 05:15:46 reinelt * make busy-flag checking configurable for LCD-Linux driver * * Revision 1.6 2005/04/30 06:02:09 reinelt * LCD-Linux display size set up from lcd4linux.conf * * Revision 1.5 2005/04/09 07:36:42 reinelt * updated LCD-Linux driver to version 0.8.8 * * Revision 1.4 2005/02/24 07:06:48 reinelt * SimpleLCD driver added * * Revision 1.3 2005/02/24 06:51:40 reinelt * LCD-Linux driver GOTO_COST corrected * * Revision 1.2 2005/01/30 06:43:22 reinelt * driver for LCD-Linux finished * * Revision 1.1 2005/01/22 22:57:57 reinelt * LCD-Linux driver added * */ /* * * exported fuctions: * * struct DRIVER drv_LCDLinux * */ #include "config.h" #include #include #include #include #include #include #include #include #include #include "debug.h" #include "cfg.h" #include "qprintf.h" #include "plugin.h" #include "widget.h" #include "widget_text.h" #include "widget_icon.h" #include "widget_bar.h" #include "drv.h" #include "drv_generic_text.h" #define LCD_LINUX_MAIN #include "drv_LCDLinux.h" static char Name[] = "LCD-Linux"; static char Device[] = "/dev/lcd"; static int lcdlinux_fd = -1; static int raw_mode = 0; /****************************************/ /*** hardware dependant functions ***/ /****************************************/ static void drv_LL_send(const char *string, const int len) { int run, ret; for (run = 0; run < 10; run++) { ret = write(lcdlinux_fd, string, len); if (ret >= 0 || errno != EAGAIN) break; if (run > 0) info("%s: write(%s): EAGAIN #%d", Name, Device, run); usleep(1000); } if (ret < 0) { error("%s: write(%s) failed: %s", Name, Device, strerror(errno)); } else if (ret != len) { error("%s: partial write(%s): len=%d ret=%d", Name, Device, len, ret); } return; } static void drv_LL_clear(void) { /* No return value check since this ioctl cannot fail */ ioctl(lcdlinux_fd, IOCTL_CLEAR_DISP); } static void drv_LL_write(const int row, const int col, const char *data, int len) { int pos = row * DCOLS + col; if (lseek(lcdlinux_fd, pos, SEEK_SET) == (off_t) - 1) { error("%s: lseek(%s) failed: %s", Name, Device, strerror(errno)); } drv_LL_send(data, len); } static void drv_LL_defchar(const int ascii, const unsigned char *matrix) { char buffer[8]; int pos = 1024 + ascii; int i; for (i = 0; i < 8; i++) { buffer[i] = *matrix++ & 0x1f; } if (lseek(lcdlinux_fd, pos, SEEK_SET) == (off_t) - 1) { error("%s: lseek(%s) failed: %s", Name, Device, strerror(errno)); } drv_LL_send(buffer, 8); } static int drv_LL_start(const char *section, const int quiet) { char *s; int rows = -1, cols = -1; int use_busy = 0, commit = 0; struct lcd_parameters buf; /* emit version information */ info("%s: Version %s", Name, LCD_LINUX_VERSION); /* get size from config file */ s = cfg_get(section, "Size", NULL); if (s != NULL || *s != '\0') { if (sscanf(s, "%dx%d", &cols, &rows) != 2 || rows < 1 || cols < 1) { error("%s: bad %s.Size '%s' from %s", Name, section, s, cfg_source()); free(s); return -1; } } free(s); /* open device */ lcdlinux_fd = open(Device, O_WRONLY); if (lcdlinux_fd == -1) { error("%s: open(%s) failed: %s", Name, Device, strerror(errno)); return -1; } /* get display size */ memset(&buf, 0, sizeof(buf)); if (ioctl(lcdlinux_fd, IOCTL_GET_PARAM, &buf) != 0) { error("%s: ioctl(IOCTL_GET_PARAM) failed: %s", Name, strerror(errno)); error("%s: Could not query display information!", Name); return -1; } info("%s: %dx%d display with %d controllers, flags=0x%02x:", Name, buf.cntr_cols, buf.cntr_rows, buf.num_cntr, buf.flags); info("%s: busy-flag checking %sabled", Name, buf.flags & HD44780_CHECK_BF ? "en" : "dis"); info("%s: bus width %d bits", Name, buf.flags & HD44780_4BITS_BUS ? 4 : 8); info("%s: font size %s", Name, buf.flags & HD44780_5X10_FONT ? "5x10" : "5x8"); /* overwrite with size from lcd4linux.conf */ if ((rows > 0 && rows != buf.cntr_rows) || (cols > 0 && cols != buf.cntr_cols)) { info("%s: changing size to %dx%d", Name, cols, rows); buf.cntr_rows = rows; buf.cntr_cols = cols; commit = 1; } DROWS = buf.cntr_rows; DCOLS = buf.cntr_cols; /* overwrite busy-flag checking from lcd4linux.conf */ cfg_number(section, "UseBusy", 0, 0, 1, &use_busy); if (use_busy && !(buf.flags & HD44780_CHECK_BF)) { info("%s: activating busy-flag checking", Name); buf.flags |= HD44780_CHECK_BF; commit = 1; } else if (!use_busy && (buf.flags & HD44780_CHECK_BF)) { info("%s: deactivating busy-flag checking", Name); buf.flags &= ~HD44780_CHECK_BF; commit = 1; } if (commit && ioctl(lcdlinux_fd, IOCTL_SET_PARAM, &buf) != 0) { error("%s: ioctl(IOCTL_SET_PARAM) failed: %s", Name, strerror(errno)); return -1; } /* initialize display */ drv_LL_clear(); /* clear display */ /* Disable control characters interpretation. */ /* No return value check since this ioctl cannot fail */ raw_mode = 1; ioctl(lcdlinux_fd, IOCTL_RAW_MODE, &raw_mode); if (!quiet) { char buffer[40]; qprintf(buffer, sizeof(buffer), "%s %dx%d", Name, DCOLS, DROWS); if (drv_generic_text_greet(buffer, "lcd-linux.sf.net")) { sleep(3); drv_LL_clear(); } } return 0; } /****************************************/ /*** plugins ***/ /****************************************/ /* none */ /****************************************/ /*** widget callbacks ***/ /****************************************/ /* using drv_generic_text_draw(W) */ /* using drv_generic_text_icon_draw(W) */ /* using drv_generic_text_bar_draw(W) */ /****************************************/ /*** exported functions ***/ /****************************************/ /* list models */ int drv_LL_list(void) { printf("generic"); return 0; } /* initialize driver & display */ int drv_LL_init(const char *section, const int quiet) { WIDGET_CLASS wc; int asc255bug; int ret; /* display preferences */ XRES = 5; /* pixel width of one char */ YRES = 8; /* pixel height of one char */ CHARS = 8; /* number of user-defineable characters */ CHAR0 = 0; /* ASCII of first user-defineable char */ GOTO_COST = -1; /* number of bytes a goto command requires */ /* real worker functions */ drv_generic_text_real_write = drv_LL_write; drv_generic_text_real_defchar = drv_LL_defchar; /* start display */ if ((ret = drv_LL_start(section, quiet)) != 0) return ret; /* initialize generic text driver */ if ((ret = drv_generic_text_init(section, Name)) != 0) return ret; /* initialize generic icon driver */ if ((ret = drv_generic_text_icon_init()) != 0) return ret; /* initialize generic bar driver */ if ((ret = drv_generic_text_bar_init(0)) != 0) return ret; /* add fixed chars to the bar driver */ /* most displays have a full block on ascii 255, but some have kind of */ /* an 'inverted P'. If you specify 'asc255bug 1 in the config, this */ /* char will not be used, but rendered by the bar driver */ cfg_number(section, "asc255bug", 0, 0, 1, &asc255bug); drv_generic_text_bar_add_segment(0, 0, 255, 32); /* ASCII 32 = blank */ if (!asc255bug) drv_generic_text_bar_add_segment(255, 255, 255, 255); /* ASCII 255 = block */ /* register text widget */ wc = Widget_Text; wc.draw = drv_generic_text_draw; widget_register(&wc); /* register icon widget */ wc = Widget_Icon; wc.draw = drv_generic_text_icon_draw; widget_register(&wc); /* register bar widget */ wc = Widget_Bar; wc.draw = drv_generic_text_bar_draw; widget_register(&wc); /* register plugins */ /* none */ return 0; } /* close driver & display */ int drv_LL_quit(const int quiet) { info("%s: shutting down.", Name); drv_generic_text_quit(); /* clear display */ drv_LL_clear(); /* say goodbye... */ if (!quiet) { drv_generic_text_greet("goodbye!", NULL); } /* Enable control characters interpretation. */ /* No return value check since this ioctl cannot fail */ raw_mode = 0; ioctl(lcdlinux_fd, IOCTL_RAW_MODE, &raw_mode); /* close device */ close(lcdlinux_fd); return (0); } DRIVER drv_LCDLinux = { name:Name, list:drv_LL_list, init:drv_LL_init, quit:drv_LL_quit, }; n223' href='#n223'>223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 
/* $Id$
 * $URL$
 *
 * image widget handling
 *
 * Copyright (C) 2006 Michael Reinelt <michael@reinelt.co.at>
 * Copyright (C) 2006 The LCD4Linux Team <lcd4linux-devel@users.sourceforge.net>
 *
 * 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, or (at your option)
 * 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */

/* 
 * exported functions:
 *
 * WIDGET_CLASS Widget_Image
 *   the image widget
 *
 */


#include "config.h"

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <errno.h>

#ifdef HAVE_GD_GD_H
#include <gd/gd.h>
#else
#ifdef HAVE_GD_H
#include <gd.h>
#else
#error "gd.h not found!"
#error "cannot compile image widget"
#endif
#endif

#if GD2_VERS != 2
#error "lcd4linux requires libgd version 2"
#error "cannot compile image widget"
#endif

#include "debug.h"
#include "cfg.h"
#include "qprintf.h"
#include "property.h"
#include "timer.h"
#include "widget.h"
#include "widget_image.h"
#include "rgb.h"

#ifdef WITH_DMALLOC
#include <dmalloc.h>
#endif


static void widget_image_render(const char *Name, WIDGET_IMAGE * Image)
{
    int x, y;
    int inverted;
    gdImagePtr gdImage;

    /* clear bitmap */
    if (Image->bitmap) {
	int i;
	for (i = 0; i < Image->height * Image->width; i++) {
	    RGBA empty = {.R = 0x00,.G = 0x00,.B = 0x00,.A = 0x00 };
	    Image->bitmap[i] = empty;
	}
    }

    /* reload image only on first call or on explicit reload request */
    if (Image->gdImage == NULL || P2N(&Image->reload)) {

	char *file;
	FILE *fd;

	/* free previous image */
	if (Image->gdImage) {
	    gdImageDestroy(Image->gdImage);
	    Image->gdImage = NULL;
	}

	file = P2S(&Image->file);
	if (file == NULL || file[0] == '\0') {
	    error("Warning: Image %s has no file", Name);
	    return;
	}

	fd = fopen(file, "rb");
	if (fd == NULL) {
	    error("Warning: Image %s: fopen(%s) failed: %s", Name, file, strerror(errno));
	    return;
	}

	Image->gdImage = gdImageCreateFromPng(fd);
	fclose(fd);

	if (Image->gdImage == NULL) {
	    error("Warning: Image %s: CreateFromPng(%s) failed!", Name, file);
	    return;
	}

    }

    /* maybe resize bitmap */
    gdImage = Image->gdImage;
    if (gdImage->sx > Image->width) {
	Image->width = gdImage->sx;
	free(Image->bitmap);
	Image->bitmap = NULL;
    }
    if (gdImage->sy > Image->height) {
	Image->height = gdImage->sy;
	free(Image->bitmap);
	Image->bitmap = NULL;
    }
    if (Image->bitmap == NULL && Image->width > 0 && Image->height > 0) {
	int i = Image->width * Image->height * sizeof(Image->bitmap[0]);
	Image->bitmap = malloc(i);
	if (Image->bitmap == NULL) {
	    error("Warning: Image %s: malloc(%d) failed: %s", Name, i, strerror(errno));
	    return;
	}
	for (i = 0; i < Image->height * Image->width; i++) {
	    RGBA empty = {.R = 0x00,.G = 0x00,.B = 0x00,.A = 0x00 };
	    Image->bitmap[i] = empty;
	}
    }


    /* finally really render it */
    inverted = P2N(&Image->inverted);
    if (P2N(&Image->visible)) {
	for (x = 0; x < gdImage->sx; x++) {
	    for (y = 0; y < gdImage->sy; y++) {
		int p = gdImageGetTrueColorPixel(gdImage, x, y);
		int a = gdTrueColorGetAlpha(p);
		int i = y * Image->width + x;
		Image->bitmap[i].R = gdTrueColorGetRed(p);
		Image->bitmap[i].G = gdTrueColorGetGreen(p);
		Image->bitmap[i].B = gdTrueColorGetBlue(p);
		/* GD's alpha is 0 (opaque) to 127 (tranparanet) */
		/* our alpha is 0 (transparent) to 255 (opaque) */
		Image->bitmap[i].A = (a == 127) ? 0 : 255 - 2 * a;
		if (inverted) {
		    Image->bitmap[i].R = 255 - Image->bitmap[i].R;
		    Image->bitmap[i].G = 255 - Image->bitmap[i].G;
		    Image->bitmap[i].B = 255 - Image->bitmap[i].B;
		}
	    }
	}
    }
}


static void widget_image_update(void *Self)
{
    WIDGET *W = (WIDGET *) Self;
    WIDGET_IMAGE *Image = W->data;

    /* process the parent only */
    if (W->parent == NULL) {

	/* evaluate properties */
	property_eval(&Image->file);
	property_eval(&Image->update);
	property_eval(&Image->reload);
	property_eval(&Image->visible);
	property_eval(&Image->inverted);

	/* render image into bitmap */
	widget_image_render(W->name, Image);

    }

    /* finally, draw it! */
    if (W->class->draw)
	W->class->draw(W);

    /* add a new one-shot timer */
    if (P2N(&Image->update) > 0) {
	timer_add(widget_image_update, Self, P2N(&Image->update), 1);
    }
}



int widget_image_init(WIDGET * Self)
{
    char *section;
    WIDGET_IMAGE *Image;

    /* re-use the parent if one exists */
    if (Self->parent == NULL) {

	/* prepare config section */
	/* strlen("Widget:")=7 */
	section = malloc(strlen(Self->name) + 8);
	strcpy(section, "Widget:");
	strcat(section, Self->name);

	Image = malloc(sizeof(WIDGET_IMAGE));
	memset(Image, 0, sizeof(WIDGET_IMAGE));

	/* initial size */
	Image->width = 0;
	Image->height = 0;
	Image->bitmap = NULL;

	/* load properties */
	property_load(section, "file", NULL, &Image->file);
	property_load(section, "update", "100", &Image->update);
	property_load(section, "reload", "0", &Image->reload);
	property_load(section, "visible", "1", &Image->visible);
	property_load(section, "inverted", "0", &Image->inverted);

	/* sanity checks */
	if (!property_valid(&Image->file)) {
	    error("Warning: widget %s has no file", section);
	}

	free(section);
	Self->data = Image;

    } else {

	/* re-use the parent */
	Self->data = Self->parent->data;

    }

    /* just do it! */
    widget_image_update(Self);

    return 0;
}


int widget_image_quit(WIDGET * Self)
{
    if (Self) {
	/* do not deallocate child widget! */
	if (Self->parent == NULL) {
	    if (Self->data) {
		WIDGET_IMAGE *Image = Self->data;
		if (Image->gdImage) {
		    gdImageDestroy(Image->gdImage);
		    Image->gdImage = NULL;
		}
		free(Image->bitmap);
		property_free(&Image->file);
		property_free(&Image->update);
		property_free(&Image->reload);
		property_free(&Image->visible);
		property_free(&Image->inverted);
		free(Self->data);
		Self->data = NULL;
	    }
	}
    }

    return 0;

}



WIDGET_CLASS Widget_Image = {
    .name = "image",
    .type = WIDGET_TYPE_XY,
    .init = widget_image_init,
    .draw = NULL,
    .quit = widget_image_quit,
};