Fix naming conventions.
[bertos.git] / drv / lcd_lm44_qt.cpp
1 /**
2  * \file
3  * <!--
4  * Copyright 2006 Develer S.r.l. (http://www.develer.com/)
5  * Copyright 2000,2001 Bernardo Innocenti <bernie@codewiz.org>
6  * This file is part of DevLib - See README.devlib for information.
7  * -->
8  *
9  * \version $Id$
10  *
11  * \author Bernardo Innocenti <bernie@develer.com>
12  *
13  * \brief Custom Qt widget for emulating a graphics LCD display (implementation)
14  */
15
16 /*#*
17  *#* $Log$
18  *#* Revision 1.1  2006/01/16 03:51:35  bernie
19  *#* Add LCD Qt emulator.
20  *#*
21  *#*/
22
23 #include <qpainter.h>
24 #include <qfont.h>
25 #include <qsizepolicy.h>
26 #include <qsize.h>
27 #include "EmulLCD.h"
28 #include "Emul.h"
29
30
31 // Display colors
32 #define LCD_FG_COLOR 0x0, 0x0, 0x0
33 #define LCD_BG_COLOR 0xBB, 0xCC, 0xBB
34
35
36 EmulLCD::EmulLCD(QWidget *parent, const char *name) :
37         QFrame(parent, name, WRepaintNoErase | WResizeNoErase),
38         lcd_font("courier", 18),
39         fg_color(LCD_FG_COLOR),
40         bg_color(LCD_BG_COLOR),
41         cr_row(0),
42         cr_col(0),
43         cgramaddr(-1),
44         show_cursor(true)
45 {
46         // initialize DDRAM
47         memcpy(ddram,
48                 "01234567890123456789"
49                 "abcdefghijhlmnopqrst"
50                 "ABCDEFGHIJKLMNOPQRST"
51                 "!@#$%^&*()_+|{}':?><",
52                 sizeof(ddram));
53
54         // setup font
55         lcd_font.setFixedPitch(true);
56         setFont(lcd_font);
57
58         // get exact font size
59         QFontMetrics fm(lcd_font);
60         font_width      = fm.width(QChar(' '));
61         font_height     = fm.height();
62
63         // set widget frame
64         setFrameStyle(QFrame::Panel | QFrame::Sunken);
65 //      setLineWidth(2);
66         frame_width = frameWidth();
67 }
68
69
70 EmulLCD::~EmulLCD()
71 {
72         // nop
73 }
74
75
76 QSizePolicy EmulLCD::sizePolicy() const
77 {
78         return QSizePolicy(QSizePolicy::Fixed, QSizePolicy::Fixed, false);
79 }
80
81
82 QSize EmulLCD::sizeHint() const
83 {
84         return QSize(
85                 font_width * COLS + frame_width * 2,
86                 font_height * ROWS + frame_width * 2);
87 }
88
89
90 void EmulLCD::drawContents(QPainter *p)
91 {
92         RedrawText(*p);
93 }
94
95
96 void EmulLCD::SetPainter(QPainter & p)
97 {
98         p.setBackgroundMode(OpaqueMode);
99         p.setPen(fg_color);
100         p.setBackgroundColor(bg_color);
101 }
102
103
104 void EmulLCD::RedrawText(QPainter & p)
105 {
106         int r, c;
107
108         SetPainter(p);
109
110         for (r = 0; r < ROWS; r++)
111                 for (c = 0; c < COLS; c++)
112                         PrintChar(p, r, c);
113 }
114
115
116 void EmulLCD::PrintChar(QPainter & p, int row, int col)
117 {
118         // Fetch char from DD RAM
119         unsigned char c = ddram[row][col];
120
121         // Map some Hitachi characters to ISO Latin1
122         switch(c)
123         {
124                 case 0xDF:
125                         c = 0xBA;       // "degrees" glyph
126                         break;
127
128                 case 0xE4:
129                         c = 0xB5;       // "micro" glyph
130                         break;
131
132                 default:                // all others
133                         break;
134         }
135
136         // Draw char on display
137         int x = col * font_width + frame_width;
138         int y = row * font_height + frame_width;
139         bool restore_colors = false;
140
141         if (show_cursor && (row == cr_row) && (col == cr_col))
142         {
143                 // Exchange FG/BG colors
144                 p.setPen(bg_color);
145                 p.setBackgroundColor(fg_color);
146                 restore_colors = true;
147         }
148
149         p.drawText(x, y, x + font_width, y + font_height, 0 /*tf*/,
150                 QString(QChar(c)), 1);
151
152         if (restore_colors)
153         {
154                 // Restore FG/BG colors
155                 p.setPen(fg_color);
156                 p.setBackgroundColor(bg_color);
157         }
158 }
159
160
161 void EmulLCD::MoveCursor(int r, int c)
162 {
163         // Save old cursor position
164         int old_row = cr_row;
165         int old_col = cr_col;
166         
167         // Move the cursor
168         cgramaddr = -1;
169         cr_row = r;
170         cr_col = c;
171
172         if (show_cursor && (old_col != cr_col || old_row != cr_row))
173         {
174                 QPainter p(this);
175                 SetPainter(p);
176
177                 // Draw new cursor
178                 PrintChar(p, cr_row, cr_col);
179
180                 // Erase old cursor
181                 PrintChar(p, old_row, old_col);
182         }
183 }
184
185
186 void EmulLCD::ShowCursor(bool show)
187 {
188         show_cursor = show;
189
190         // Draw (or erase) cursor
191         QPainter p(this);
192         SetPainter(p);
193         PrintChar(p, cr_row, cr_col);
194 }
195
196
197 void EmulLCD::AdvanceCursor()
198 {
199         // Move the cursor
200         if (cr_col == COLS - 1)
201         {
202                 if (cr_row == ROWS - 1)
203                         MoveCursor(0, 0);
204                 else
205                         MoveCursor(cr_row + 1, 0);
206         }
207         else
208                 MoveCursor(cr_row, cr_col + 1);
209 }
210
211
212 void EmulLCD::PutChar(unsigned char c)
213 {
214         if (cgramaddr != -1)
215         {
216                 // Write data in CGRAM
217                 cgram[cgramaddr] = c;
218
219                 // Auto increment CGRAM address
220                 cgramaddr = (cgramaddr + 1) & 0x3F;
221         }
222         else
223         {
224                 // Writing in DDRAM
225                 ddram[cr_row][cr_col] = c;
226
227                 // Update display
228                 {
229                         QPainter p(this);
230                         SetPainter(p);
231                         PrintChar(p, cr_row, cr_col);
232                 }
233                 AdvanceCursor();
234         }
235 }
236
237
238 char EmulLCD::GetChar()
239 {
240         char c = ddram[cr_row][cr_col];
241         AdvanceCursor();
242         return c;
243 }
244
245
246 void EmulLCD::Clear()
247 {
248         memset(ddram, ' ', sizeof(ddram));
249         cr_row = cr_col = 0;
250
251         QPainter p(this);
252         RedrawText(p);
253 }
254
255
256 void EmulLCD::SetCGRamAddr(unsigned char addr)
257 {
258         cgramaddr = addr & (sizeof(cgram) - 1);
259 }
260
261
262 // Hitachi LM044L register-level emulation
263
264 #define INI_DISPLAY             0x30
265 #define INI_OP_DISP             0x38    /* 8 bits, 2 lines, 5x7 dots */
266 #define ON_DISPLAY              0x0F    /* Switch on display */
267 #define OFF_DISPLAY             0x08    /* Switch off display */
268 #define CLR_DISPLAY             0x01    /* Clear display */
269 #define CURSOR_BLOCK    0x0D    /* Show cursor (block) */
270 #define CURSOR_LINE             0x0F    /* Show cursor (line) */
271 #define CURSOR_OFF              0x0C    /* Hide cursor */
272 #define MODE_DISPL              0x06
273 #define SHIFT_DISPLAY   0x18
274 #define MOVESHIFT_LEFT  0x00
275 #define MOVESHIFT_RIGHT 0x04
276 #define LCD_CGRAMADDR   (1<<6)
277 #define LCD_DDRAMADDR   (1<<7)
278
279
280 extern "C" void Emul_LCDWriteReg(unsigned char d)
281 {
282         static const unsigned char lcd_rowaddress[EmulLCD::ROWS] = { 0x80, 0xC0, 0x94, 0xD4 };
283
284         switch(d)
285         {
286                 case CLR_DISPLAY:
287                         emul->emulLCD->Clear();
288                         break;
289
290                 case CURSOR_BLOCK:
291                 case CURSOR_LINE:
292                         emul->emulLCD->ShowCursor(true);
293                         break;
294
295                 case CURSOR_OFF:
296                         emul->emulLCD->ShowCursor(false);
297                         break;
298
299                 default:
300                         // Set DDRAM address?
301                         if (d & LCD_DDRAMADDR)
302                         {
303                                 for (int i = 0; i < EmulLCD::ROWS; i++)
304                                 {
305                                         if ((d >= lcd_rowaddress[i]) && (d < lcd_rowaddress[i] + EmulLCD::COLS))
306                                         {
307                                                 emul->emulLCD->MoveCursor(i, d - lcd_rowaddress[i]);
308                                                 break;
309                                         }
310                                 }
311                         }
312                         else if (d & LCD_CGRAMADDR)
313                                 emul->emulLCD->SetCGRamAddr(d);
314                         break;
315         }
316 }
317
318
319 extern "C" unsigned char Emul_LCDReadReg(void)
320 {
321         return 0;       /* This LCD model is never busy ;-) */
322 }
323
324
325 extern "C" void Emul_LCDWriteData(unsigned char d)
326 {
327         emul->emulLCD->PutChar(d);
328 }
329
330
331 extern "C" unsigned char Emul_LCDReadData(void)
332 {
333         return emul->emulLCD->GetChar();
334 }
335
336 #include "EmulLCD.moc"
337