← Back to branch summary

~ari-tczew/ubuntu/lucid/skyeye/sru-lp-464175

« back to all changes in this revision

Viewing changes to device/lcd/skyeye_lcd_gtk.c

  • Committer: Bazaar Package Importer
  • Author(s): Yu Guanghui
  • Date: 2007-02-09 20:24:29 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20070209202429-jknfb98t9ggaoz02
Tags: 1.2.1-2
Disable DBCT again.

Show diffs side-by-side

added added

removed removed

Lines of Context:
device/lcd/skyeye_lcd_gtk.c
23
23
 
24
24
static int lcd_base;
25
25
 
26
 
/*chy change 2002-12-3*/
27
 
//#define NO_LCD
28
 
//koodailar add for mingw 2005.12.18 ----------------------------------------
29
 
#ifdef __MINGW32__
30
 
#include <gtk-2.0/gtk/gtk.h>
31
 
#include <gtk-2.0/gdk/gdk.h>            
32
 
#else
33
26
#include <gtk/gtk.h>
34
27
#include <gdk/gdk.h>            //added by ywc
35
 
#endif
36
 
// end ----------------------------------------------------------------------
37
28
 
38
29
#ifdef SKYEYE_LCD_TEST
39
30
typedef unsigned int ARMword;
40
31
typedef unsigned int ARMul_State;
41
32
#else
42
 
//koodailar add for mingw 2005.12.18 ----------------------------------------
43
 
#ifdef __MINGW32__
44
 
#include "arch/arm/common/armdefs.h"
45
 
#else
46
33
#include "armdefs.h"
47
 
#endif
48
 
// end ----------------------------------------------------------------------
49
34
#endif //SKYEYE_LCD_TEST
50
35
 
51
36
#include "skyeye_lcd.h"
60
45
 
61
46
 
62
47
static GdkColormap *point_colormap;
63
 
static int lcd_width, lcd_height, lcd_depth;
64
 
guchar *rgbbuf;
65
 
guint32 *fbSkyeyeADDR;
66
 
static struct GdkRgbCmap *colormap;
67
 
 
 
48
static int lcd_width, lcd_virtual_width, lcd_height, lcd_depth;
 
49
guchar *rgbbuf = NULL;
 
50
guint32 *fbSkyeyeADDR = NULL;
 
51
static GdkRgbCmap *colormap = NULL;
 
52
 
 
53
guint timeout_handle = 0;
 
54
 
 
55
// anthonylee 2007-01-29
 
56
// TODO: change all the codes to support multi-device.
 
57
static struct lcd_device *cur_lcd_dev = NULL;
68
58
 
69
59
//by ywc 2004-07-24
70
60
extern mem_bank_t *bank_ptr (ARMword addr);
71
61
 
 
62
 
 
63
// anthonylee 2007-01-29
 
64
static u32 lcd_lookup_color_for_gtk_rgbbuf(u32 color)
 
65
{
 
66
        u32 c = cur_lcd_dev->lcd_lookup_color(cur_lcd_dev, color);
 
67
 
 
68
        /* the gtk's 32 bits rgb buffer : X-B-G-R */
 
69
        return((c >> 16) | (c & 0xff00) | ((c & 0xff) << 16));
 
70
}
 
71
 
 
72
 
72
73
/* use rgbbuf */
73
 
 
74
 
expose_event (GtkWidget * widget, GdkEventExpose * event)
 
74
gint expose_event (GtkWidget * widget, GdkEventExpose * event)
75
75
{
76
 
        int i, x, y, pix, pixnum, bit;
 
76
        int i, j, x, y, pix, bit;
77
77
 
78
78
        int wordnum;            //for lcd_depth==16 ,  1 word contain 2 pixel
79
79
        guint32 fbdata;         // |R1,G1,B1,R0,G0,B0|
83
83
        guchar fbdata8_1;       // |R1,B0|    
84
84
        guchar fbdata8_2;       // |B1,G1|    
85
85
 
86
 
        wordnum = lcd_width * lcd_height * lcd_depth / 32;
87
 
 
88
 
        tribytenum = lcd_width * lcd_height * lcd_depth / 24;
89
 
 
90
 
        pixnum = lcd_width * lcd_height;
91
 
        switch (lcd_depth) {
 
86
        wordnum = lcd_virtual_width * lcd_height * lcd_depth / 32;
 
87
        tribytenum = lcd_virtual_width * lcd_height * lcd_depth / 24;
 
88
 
 
89
        // anthonylee 2007-01-29 : for lcd_lookup_color
 
90
        if(cur_lcd_dev->lcd_lookup_color != NULL)
 
91
        {
 
92
                int count = lcd_width * lcd_height;
 
93
                u32 *tmp = (u32*)rgbbuf;
 
94
 
 
95
                const u8 *buf = (const u8*)fbSkyeyeADDR;
 
96
                int flag = 0, i = 0;
 
97
                u32 c;
 
98
 
 
99
                if(tmp == NULL || buf == NULL) return TRUE;
 
100
 
 
101
                // TODO: to be region-updating
 
102
                while(count-- > 0) switch(lcd_depth)
 
103
                {
 
104
                        case 1:
 
105
                                *tmp++ = lcd_lookup_color_for_gtk_rgbbuf((u32)((*buf >> (8 - (flag + 1))) & 0x1));
 
106
                                if(++flag > 7) {buf++; flag = 0;}
 
107
                                if(++i == lcd_width) {buf += cur_lcd_dev->lcd_line_offset / 8; i = 0;}
 
108
                                break;
 
109
 
 
110
                        case 2:
 
111
                                *tmp++ = lcd_lookup_color_for_gtk_rgbbuf((u32)((*buf >> (8 - ((flag + 1) << 1))) & 0x3));
 
112
                                if(++flag > 3) {buf++; flag = 0;}
 
113
                                if(++i == lcd_width) {buf += cur_lcd_dev->lcd_line_offset / 4; i = 0;}
 
114
                                break;
 
115
 
 
116
                        case 4:
 
117
                                *tmp++ = lcd_lookup_color_for_gtk_rgbbuf((u32)(((*buf) >> (flag == 0 ? 4 : 0)) & 0xf));
 
118
                                if(++flag > 1) {buf++; flag = 0;}
 
119
                                if(++i == lcd_width) {buf += cur_lcd_dev->lcd_line_offset / 2; i = 0;}
 
120
                                break;
 
121
 
 
122
                        case 8:
 
123
                                *tmp++ = lcd_lookup_color_for_gtk_rgbbuf((u32)(*buf));
 
124
                                buf++;
 
125
                                if(++i == lcd_width) {buf += cur_lcd_dev->lcd_line_offset; i = 0;}
 
126
                                break;
 
127
 
 
128
                        case 16:
 
129
                                *tmp++ = lcd_lookup_color_for_gtk_rgbbuf((u32)(*((u16*)buf)));
 
130
                                buf += 2;
 
131
                                if(++i == lcd_width) {buf += cur_lcd_dev->lcd_line_offset * 2; i = 0;}
 
132
                                break;
 
133
 
 
134
                        case 32:
 
135
                                *tmp++ = lcd_lookup_color_for_gtk_rgbbuf(*((u32*)buf));
 
136
                                buf += 4;
 
137
                                if(++i == lcd_width) {buf += cur_lcd_dev->lcd_line_offset * 4; i = 0;}
 
138
                                break;
 
139
 
 
140
                        default:
 
141
                                return TRUE;
 
142
                }
 
143
 
 
144
                gdk_draw_rgb_32_image (widget->window,
 
145
                                       widget->style->fg_gc[GTK_STATE_NORMAL],
 
146
                                       0, 0, lcd_width, lcd_height,
 
147
                                       GDK_RGB_DITHER_NORMAL, rgbbuf,
 
148
                                       lcd_width * 4);
 
149
        }
 
150
        else switch (lcd_depth) {
92
151
        case 1:
93
 
        case 2:
 
152
//      case 2:
94
153
        case 4:
95
 
                // should add code for scan the fb data to buf
 
154
                // anthonylee 2007-01-28
 
155
                for (j = 0; j < lcd_height; j++)
 
156
                {
 
157
                        guchar *buf = (guchar*)fbSkyeyeADDR + j * lcd_virtual_width * lcd_depth / 8;
 
158
 
 
159
                        for (i = 0; i < lcd_width;)
 
160
                        {
 
161
                                int k;
 
162
                                guchar c = *buf++;
 
163
                                guchar *tmp = (guchar*)rgbbuf + j * lcd_virtual_width + i;
 
164
 
 
165
                                for(k = 0; k < 8 / lcd_depth; k++, i++, tmp++)
 
166
                                        *tmp = (c >> (8 - ((k + 1) << (lcd_depth - 1)))) & ((1 << lcd_depth) - 1);
 
167
                        }
 
168
                }
96
169
                gdk_draw_indexed_image (widget->window,
97
 
                                        widget->style->
98
 
                                        fg_gc[GTK_STATE_NORMAL], 0, 0,
 
170
                                        widget->style->fg_gc[GTK_STATE_NORMAL], 0, 0,
99
171
                                        lcd_width, lcd_height,
100
172
                                        GDK_RGB_DITHER_NORMAL, rgbbuf,
101
 
                                        lcd_width, colormap);
 
173
                                        lcd_virtual_width, colormap);
102
174
                break;
103
175
        case 8:
104
176
                gdk_draw_indexed_image (widget->window,
105
 
                                        widget->style->
106
 
                                        fg_gc[GTK_STATE_NORMAL], 0, 0,
 
177
                                        widget->style->fg_gc[GTK_STATE_NORMAL], 0, 0,
107
178
                                        lcd_width, lcd_height,
108
179
                                        GDK_RGB_DITHER_NORMAL, rgbbuf,
109
 
                                        lcd_width, colormap);
 
180
                                        lcd_virtual_width, colormap);
110
181
                //gdk_draw_gray_image (widget->window,
111
182
                //                      widget->style->fg_gc[GTK_STATE_NORMAL],
112
183
                //                      0 , 0,lcd_width ,lcd_height,
130
201
                                    widget->style->fg_gc[GTK_STATE_NORMAL],
131
202
                                    0, 0, lcd_width, lcd_height,
132
203
                                    GDK_RGB_DITHER_MAX, rgbbuf,
133
 
                                    lcd_width * 3);
 
204
                                    lcd_virtual_width * 3);
134
205
 
135
206
                break;
136
207
        case 16:
156
227
                                    widget->style->fg_gc[GTK_STATE_NORMAL],
157
228
                                    0, 0, lcd_width, lcd_height,
158
229
                                    GDK_RGB_DITHER_MAX, rgbbuf,
159
 
                                    lcd_width * 3);
 
230
                                    lcd_virtual_width * 3);
160
231
                break;
161
232
        case 24:
162
233
                gdk_draw_rgb_image (widget->window,
163
234
                                    widget->style->fg_gc[GTK_STATE_NORMAL],
164
235
                                    0, 0, lcd_width, lcd_height,
165
236
                                    GDK_RGB_DITHER_NORMAL, rgbbuf,
166
 
                                    lcd_width * 3);
 
237
                                    lcd_virtual_width * 3);
167
238
                break;
168
239
        case 32:
169
240
                gdk_draw_rgb_32_image (widget->window,
170
241
                                       widget->style->fg_gc[GTK_STATE_NORMAL],
171
242
                                       0, 0, lcd_width, lcd_height,
172
243
                                       GDK_RGB_DITHER_NORMAL, rgbbuf,
173
 
                                       lcd_width * 4);
 
244
                                       lcd_virtual_width * 4);
174
245
                break;
175
246
        default:
176
247
                break;
180
251
}
181
252
 
182
253
//********** touch srceen event callback funtion by ywc ************
183
 
unsigned int Pen_buffer[8];
 
254
extern unsigned int Pen_buffer[8];
184
255
static void
185
256
skPenEvent (int *buffer, int eventType, int stateType, int x, int y)
186
257
{
234
305
gint
235
306
redraw (gpointer pointer)
236
307
{
 
308
#if 0
237
309
        GdkRectangle update_rect;
238
310
        update_rect.x = 0;
239
311
        update_rect.y = 0;
247
319
        }
248
320
        else
249
321
                return FALSE;
 
322
#else
 
323
        // anthonylee 2007-01-28
 
324
        gtk_widget_queue_draw((GtkWidget*)pointer);
 
325
        return TRUE;
 
326
#endif
250
327
}
251
328
 
252
329
int
281
358
                0xffff00, 0xffffff
282
359
        };
283
360
 
284
 
        int width = lcd_dev->width;
285
 
        int height = lcd_dev->height;
286
 
        int depth = lcd_dev->depth;
287
361
        ARMul_State *state = (ARMul_State *) lcd_dev->state;
288
362
 
289
363
        if (!once) {
292
366
                gdk_rgb_init ();
293
367
        }
294
368
 
295
 
        lcd_width = width;
296
 
        lcd_height = height;
297
 
        lcd_depth = depth;
298
 
 
299
 
        lcd_dev->lcd_addr_end = lcd_dev->lcd_addr_begin +
300
 
                (width * height * depth / 8) - 1;
 
369
        cur_lcd_dev = lcd_dev;
 
370
 
 
371
        lcd_width = lcd_dev->width;
 
372
        lcd_virtual_width = lcd_dev->width + (int)lcd_dev->lcd_line_offset;
 
373
        lcd_height = lcd_dev->height;
 
374
        lcd_depth = lcd_dev->depth;
 
375
 
 
376
        if(lcd_dev->lcd_addr_end <= lcd_dev->lcd_addr_begin)
 
377
                lcd_dev->lcd_addr_end = lcd_dev->lcd_addr_begin + (lcd_virtual_width * lcd_height * lcd_depth / 8) - 1;
301
378
        lcd_base = lcd_dev->lcd_addr_begin;
302
379
 
303
380
        // by ywc 2004-07-24 scan the framebuffer directly and don't use the buf
312
389
                                              state->mem_bank->
313
390
                                              mem_banks)][(lcd_base -
314
391
                                                           mbp->addr) / 4];
315
 
        switch (lcd_depth) {
 
392
 
 
393
        // anthonylee 2007-01-29 : for lcd_lookup_color
 
394
        if(lcd_dev->lcd_lookup_color != NULL)
 
395
                rgbbuf = malloc (lcd_width * lcd_height * 4);
 
396
        else switch (lcd_depth) {
316
397
        case 1:
317
398
        case 2:
318
399
        case 4:
319
 
                rgbbuf = malloc (lcd_width * lcd_height);
 
400
                rgbbuf = malloc (lcd_virtual_width * lcd_height);
320
401
                break;
321
402
        case 12:
322
403
        case 16:
323
 
                rgbbuf = malloc (lcd_width * lcd_height * 3);
 
404
                rgbbuf = malloc (lcd_virtual_width * lcd_height * 3);
324
405
                break;
325
406
        case 8:
326
407
        case 24:
328
409
                rgbbuf = (guchar *) fbSkyeyeADDR;
329
410
                break;
330
411
        default:
 
412
                //anthonylee 2007-01-29
 
413
                rgbbuf = NULL;
331
414
                break;
332
415
        }
333
 
        printf ("\nSKYEYE:  lcd_addr_begin 0x%x,lcd_addr_end 0x%x, width %d, height %d, depth %d\n", (lcd_dev->lcd_addr_begin), (lcd_dev->lcd_addr_end), width, height, depth);
 
416
 
 
417
        printf ("\nSKYEYE:  lcd_addr_begin 0x%x,lcd_addr_end 0x%x, width %d, height %d, depth %d\n", (lcd_dev->lcd_addr_begin), (lcd_dev->lcd_addr_end), lcd_dev->width, lcd_dev->height, lcd_dev->depth);
334
418
 
335
419
        window = gtk_window_new (GTK_WINDOW_TOPLEVEL);  //create top level window
336
420
 
338
422
        //sprintf(mode,"%s%dx%dx%d",title,lcd_width,lcd_height,lcd_depth);
339
423
        sprintf (mode, "%dx%dx%d %s", lcd_width, lcd_height, lcd_depth,
340
424
                 title);
341
 
        gtk_window_set_title (window, mode);    //added by ywc
342
 
 
343
 
        gtk_widget_set_usize (window, width, height);
344
 
 
345
 
        gtk_widget_set_events (window, GDK_EXPOSURE_MASK);
 
425
        gtk_window_set_title (GTK_WINDOW (window), mode);       //added by ywc
 
426
 
 
427
        gtk_widget_set_usize (GTK_WIDGET (window), lcd_width, lcd_height);
 
428
 
 
429
        gtk_widget_set_events (GTK_WIDGET (window), GDK_EXPOSURE_MASK);
346
430
 
347
431
        TouchScreen = gtk_event_box_new ();
348
432
        gtk_container_add (GTK_CONTAINER (window), TouchScreen);
349
 
        gtk_widget_set_events (GTK_OBJECT (TouchScreen), GDK_ENTER_NOTIFY_MASK
 
433
        gtk_widget_set_events (GTK_WIDGET (TouchScreen), GDK_ENTER_NOTIFY_MASK
350
434
                               | GDK_LEAVE_NOTIFY_MASK
351
435
                               | GDK_BUTTON_PRESS_MASK
352
436
                               | GDK_BUTTON_RELEASE_MASK |
374
458
 
375
459
        gtk_widget_show (LCD);
376
460
 
377
 
        gtk_widget_show_all (window);
 
461
        gtk_widget_show_all (GTK_WIDGET(window));
378
462
 
379
463
        point_colormap = gdk_window_get_colormap (LCD->window);
380
464
 
388
472
                        ((i & 0x00000003) << 6);
389
473
 
390
474
        }
391
 
        switch (lcd_depth) {
 
475
 
 
476
        // anthonylee 2007-01-29 : for lcd_lookup_color
 
477
        if(lcd_dev->lcd_lookup_color == NULL) switch (lcd_depth) {
392
478
        case 1:
393
 
                colormap = gdk_rgb_cmap_new (colors1b, (1 << depth));
 
479
                colormap = gdk_rgb_cmap_new (colors1b, (1 << lcd_depth));
394
480
                break;
395
481
        case 2:
396
482
                break;
397
483
        case 4:
398
 
                colormap = gdk_rgb_cmap_new (colors4b, (1 << depth));
 
484
                colormap = gdk_rgb_cmap_new (colors4b, (1 << lcd_depth));
399
485
                break;
400
486
        case 8:
401
 
                colormap = gdk_rgb_cmap_new (colors8b, (1 << depth));
 
487
                colormap = gdk_rgb_cmap_new (colors8b, (1 << lcd_depth));
402
488
                break;
403
489
        case 12:
404
490
        case 16:
408
494
                break;
409
495
        }
410
496
 
411
 
//      gtk_timeout_add(500,redraw,window);
412
 
        gtk_timeout_add (200, redraw, window);
413
 
//      gtk_timeout_add(1000,redraw,window);
 
497
//      timeout_handle = gtk_timeout_add(500,redraw,window);
 
498
        timeout_handle = gtk_timeout_add (200, redraw, window);
 
499
//      timeout_handle = gtk_timeout_add(1000,redraw,window);
414
500
}
415
501
 
416
502
 
422
508
 
423
509
        //chy 2004-03-11
424
510
        //ywc 2004-09-09 for free dynamic memory
425
 
        if (depth == 1 || depth == 2 || depth == 4 || depth == 12
426
 
            || depth == 16) {
427
 
                free (rgbbuf);
 
511
        //anthonylee 2007-01-29
 
512
        if(rgbbuf != NULL && rgbbuf != (guchar*)fbSkyeyeADDR) free(rgbbuf);
 
513
        rgbbuf = NULL;
 
514
 
 
515
        //anthonylee 2007-01-28
 
516
        if(timeout_handle != 0)
 
517
        {
 
518
                gtk_timeout_remove(timeout_handle);
 
519
                timeout_handle = 0;
428
520
        }
 
521
 
429
522
        if (window) {
430
523
                gtk_widget_destroy (window);
431
524
                window = NULL;
432
525
        }
 
526
 
433
527
        //zy 2004-04-02
434
528
        if (colormap) {
435
529
                gdk_rgb_cmap_free (colormap);
436
530
                colormap = NULL;
437
531
        }
 
532
 
 
533
        //anthonylee 2007-01-28
 
534
        lcd_dev->lcd_addr_end = lcd_dev->lcd_addr_begin = 0;
 
535
        cur_lcd_dev = NULL;
438
536
}
439
537
 
440
538
int
441
 
gtk_lcd_read (struct lcd_device *lcd_dev)
 
539
gtk_lcd_read (struct lcd_device *lcd_dev, void *buf, size_t count)
442
540
{
443
541
        return 0;
444
542
}
445
543
 
446
544
int
447
 
gtk_lcd_write (struct lcd_device *lcd_dev)
 
545
gtk_lcd_write (struct lcd_device *lcd_dev, void *buf, size_t count)
448
546
{
449
547
        return 0;
450
548
}