Ticket #671: graphics_opengl.c.diff

File graphics_opengl.c.diff, 52.8 KB (added by tegzed, 12 years ago)

hopefully fixed menu flickering v2.0

  • graphics_opengl.c

    old new  
    11/**
    22 * Navit, a modular navigation system.
    3  * Copyright (C) 2005-2008 Navit Team
     3 * Copyright (C) 2005-2010 Navit Team
    44 *
    55 * This program is free software; you can redistribute it and/or
    66 * modify it under the terms of the GNU General Public License
     
    1717 * Boston, MA  02110-1301, USA.
    1818 */
    1919
    20 #include <math.h>
    2120#include <glib.h>
     21#include <unistd.h>
     22#include <math.h>
     23#include <stdio.h>
     24#include <FreeImage.h>
     25#include <time.h>
     26
     27#include "item.h"
     28#include "attr.h"
    2229#include "config.h"
    23 #include <GL/glc.h>
    2430#include "point.h"
    2531#include "graphics.h"
    2632#include "color.h"
    2733#include "plugin.h"
    28 
     34#include "event.h"
    2935#include "debug.h"
     36#include "callback.h"
     37#include "keys.h"
     38#include "window.h"
     39#include "navit/font/freetype/font_freetype.h"
     40#include <GL/glc.h>
    3041
    31 #include <GL/glut.h>
    32 
    33 
    34 void CALLBACK tessBeginCB(GLenum which);
    35 void CALLBACK tessEndCB();
    36 void CALLBACK tessErrorCB(GLenum errorCode);
    37 void CALLBACK tessVertexCB(const GLvoid *data);
    38 void CALLBACK tessVertexCB2(const GLvoid *data);
    39 void CALLBACK tessCombineCB(const GLdouble newVertex[3], const GLdouble *neighborVertex[4],
    40                             const GLfloat neighborWeight[4], GLdouble **outData);
    41        
    42 
    43 struct graphics_priv {
    44         int button_timeout;
    45         struct point p;
    46         int width;
    47         int height;
    48         int library_init;
    49         int visible;
    50         struct graphics_priv *parent;
    51         struct graphics_priv *overlays;
    52         struct graphics_priv *next;
    53         struct graphics_gc_priv *background_gc;
    54         enum draw_mode_num mode;
    55         void (*resize_callback)(void *data, int w, int h);
    56         void *resize_callback_data;
    57         void (*motion_callback)(void *data, struct point *p);
    58         void *motion_callback_data;
    59         void (*button_callback)(void *data, int press, int button, struct point *p);
    60         void *button_callback_data;
    61         GLuint DLid;
    62 };
    63 
    64 struct graphics_font_priv {
    65 #if 0
    66         FT_Face face;
     42#if defined(WINDOWS) || defined(WIN32)
     43#include <windows.h>
     44# define sleep(i) Sleep(i * 1000)
    6745#endif
    68 };
    6946
    70 struct graphics_gc_priv {
    71         struct graphics_priv *gr;
    72         float fr,fg,fb,fa;
    73         float br,bg,bb,ba;
    74         int linewidth;
    75 };
    76 
    77 struct graphics_image_priv {
    78         int w;
    79         int h;
    80 };
    81 
    82 static void
    83 graphics_destroy(struct graphics_priv *gr)
    84 {
    85 }
    86 
    87 int frame=0;
     47#ifdef __APPLE__
     48#include <GLUT/glut.h>
     49#else
     50#include <GL/glut.h>            /* glut.h includes gl.h and glu.h */
     51#endif
    8852
    89 // http://quesoglc.sourceforge.net/tutorial.php
     53#define SCREEN_WIDTH 700
     54#define SCREEN_HEIGHT 700
    9055
     56//#define MIRRORED_VIEW 1
    9157
    92 static void font_destroy(struct graphics_font_priv *font)
     58struct graphics_gc_priv
    9359{
    94         g_free(font);
    95         /* TODO: free font->face */
    96 }
    97 
    98 static struct graphics_font_methods font_methods = {
    99         font_destroy
     60  struct graphics_priv *gr;
     61  float fr, fg, fb, fa;
     62  float br, bg, bb, ba;
     63  int linewidth;
     64  unsigned char *dash_list;
     65  int dash_count;
     66  int dash_mask;
     67} graphics_gc_priv;
     68
     69struct graphics_priv
     70{
     71  int button_timeout;
     72  struct point p;
     73  int width;
     74  int height;
     75  int library_init;
     76  int visible;
     77  int overlay_enabled;
     78  int overlay_autodisabled;
     79  int wraparound;
     80  struct graphics_priv *parent;
     81  struct graphics_priv *overlays;
     82  struct graphics_priv *next;
     83  struct graphics_gc_priv *background_gc;
     84  enum draw_mode_num mode;
     85  void (*resize_callback) (void *data, int w, int h);
     86  void *resize_callback_data;
     87  void (*motion_callback) (void *data, struct point * p);
     88  void *motion_callback_data;
     89  void (*button_callback) (void *data, int press, int button,
     90                           struct point * p);
     91  void *button_callback_data;
     92  GLuint DLid;
     93  struct callback_list *cbl;
     94  struct font_freetype_methods freetype_methods;
     95  struct navit *nav;
     96  int timeout;
     97  int delay;
     98  struct window window;
     99  int dirty;                 //display needs to be redrawn (draw on root graphics or overlay is done)
     100  int force_redraw;                 //display needs to be redrawn (draw on root graphics or overlay is done)
     101  time_t last_refresh_time;  //last display refresh time
    100102};
    101103
    102 static struct graphics_font_priv *font_new(struct graphics_priv *gr, struct graphics_font_methods *meth, char *fontfamily, int size)
     104static struct graphics_priv *graphics_priv_root;
     105struct graphics_image_priv
    103106{
    104 #if 0
    105         char **filename=fontlist;
    106         struct graphics_font_priv *font=g_new(struct graphics_font_priv, 1);
    107 
    108         *meth=font_methods;
     107  int w;
     108  int h;
     109  int hot_x;
     110  int hot_y;
     111  unsigned char *data;
     112  char *path;
     113} graphics_image_priv;
     114
     115struct mouse_event_queue_element {
     116  int button;
     117  int state;
     118  int x;
     119  int y;
     120};
    109121
    110         if (!gr->library_init) {
    111                 FT_Init_FreeType( &gr->library );
    112                 gr->library_init=1;
    113         }
     122static const int mouse_event_queue_size = 100;
     123static int mouse_event_queue_begin_idx = 0;
     124static int mouse_event_queue_end_idx = 0;
     125static struct mouse_event_queue_element mouse_queue[100];
     126
     127
     128/*  prototypes */
     129void CALLBACK tessBeginCB (GLenum which);
     130void CALLBACK tessEndCB ();
     131void CALLBACK tessErrorCB (GLenum errorCode);
     132void CALLBACK tessVertexCB (const GLvoid * data);
     133void CALLBACK tessVertexCB2 (const GLvoid * data);
     134void CALLBACK tessCombineCB (const GLdouble newVertex[3],
     135                             const GLdouble * neighborVertex[4],
     136                             const GLfloat neighborWeight[4],
     137                             GLdouble ** outData);
     138
     139static struct graphics_priv *graphics_opengl_new_helper (struct
     140                                                         graphics_methods
     141                                                         *meth);
     142void display (void);
     143void resize_callback (int w, int h);
     144const char *getPrimitiveType (GLenum type);
    114145
    115         while (*filename) {     
    116                 if (!FT_New_Face( gr->library, *filename, 0, &font->face ))
    117                         break;
    118                 filename++;
    119         }
    120         if (! *filename) {
    121                 g_warning("Failed to load font, no labelling");
    122                 g_free(font);
    123                 return NULL;
    124         }
    125         FT_Set_Char_Size(font->face, 0, size, 300, 300);
    126         FT_Select_Charmap(font->face, FT_ENCODING_UNICODE);
    127         return font;
    128 #endif
    129         return NULL;
     146static void
     147graphics_destroy (struct graphics_priv *gr)
     148{
     149  g_free (gr);
     150  gr = NULL;
    130151}
    131152
    132153static void
    133 gc_destroy(struct graphics_gc_priv *gc)
     154gc_destroy (struct graphics_gc_priv *gc)
    134155{
    135         g_free(gc);
     156  g_free (gc);
     157  gc = NULL;
    136158}
    137159
    138160static void
    139 gc_set_linewidth(struct graphics_gc_priv *gc, int w)
     161gc_set_linewidth (struct graphics_gc_priv *gc, int w)
    140162{
    141         gc->linewidth=w;
     163  gc->linewidth = w;
    142164}
    143165
    144166static void
    145 gc_set_dashes(struct graphics_gc_priv *gc, int width, int offset, unsigned char *dash_list, int n)
     167gc_set_dashes (struct graphics_gc_priv *gc, int width, int offset,
     168               unsigned char *dash_list, int n)
    146169{
    147 #if 0
    148         gdk_gc_set_dashes(gc->gc, offset, (gint8 *)dash_list, n);
    149         gdk_gc_set_line_attributes(gc->gc, width, GDK_LINE_ON_OFF_DASH, GDK_CAP_ROUND, GDK_JOIN_ROUND);
    150 #endif
     170  const int cOpenglMaskBits = 16;
     171  gc->dash_count = n;
     172  int i;
     173  if (1 == n)
     174    {
     175      gc->dash_mask = 0;
     176      for (i = 0; i < cOpenglMaskBits; ++i)
     177        {
     178          gc->dash_mask <<= 1;
     179          gc->dash_mask |= (i / n) % 2;
     180        }
     181    }
     182  else if (1 < n)
     183    {
     184      unsigned char *curr = dash_list;
     185      int cnt = 0;              //dot counter
     186      int dcnt = 0;             //dash element counter
     187      int sum_dash = 0;
     188      gc->dash_mask = 0;
     189
     190      for (i = 0; i < n; ++i)
     191        {
     192          sum_dash += dash_list[i];
     193        }
     194
     195      //scale dashlist elements to max size
     196      if (sum_dash > cOpenglMaskBits)
     197        {
     198          int num_error[2] = { 0, 0 };  //count elements rounded to 0 for odd(drawn) and even(masked) for compensation
     199          double factor = (1.0 * cOpenglMaskBits) / sum_dash;
     200          for (i = 0; i < n; ++i)
     201            {                   //calculate dashlist max and largest common denomiator for scaling
     202              dash_list[i] *= factor;
     203              if (dash_list[i] == 0)
     204                {
     205                  ++dash_list[i];
     206                  ++num_error[i % 2];
     207                }
     208              else if (0 < num_error[i % 2] && 2 < dash_list[i])
     209                {
     210                  ++dash_list[i];
     211                  --num_error[i % 2];
     212                }
     213            }
     214        }
     215
     216      //calculate mask
     217      for (i = 0; i < cOpenglMaskBits; ++i)
     218        {
     219          gc->dash_mask <<= 1;
     220          gc->dash_mask |= 1 - dcnt % 2;
     221          ++cnt;
     222          if (cnt == *curr)
     223            {
     224              cnt = 0;
     225              ++curr;
     226              ++dcnt;
     227              if (dcnt == n)
     228                {
     229                  curr = dash_list;
     230                }
     231            }
     232        }
     233    }
    151234}
    152235
    153236
    154237static void
    155 gc_set_foreground(struct graphics_gc_priv *gc, struct color *c)
     238gc_set_foreground (struct graphics_gc_priv *gc, struct color *c)
    156239{
    157         gc->fr=c->r/65535.0;
    158         gc->fg=c->g/65535.0;
    159         gc->fb=c->b/65535.0;
    160         gc->fa=c->a/65535.0;
    161 //      printf("new alpha : %i\n",c->a);
     240  gc->fr = c->r / 65535.0;
     241  gc->fg = c->g / 65535.0;
     242  gc->fb = c->b / 65535.0;
     243  gc->fa = c->a / 65535.0;
    162244}
    163245
    164246static void
    165 gc_set_background(struct graphics_gc_priv *gc, struct color *c)
     247gc_set_background (struct graphics_gc_priv *gc, struct color *c)
    166248{
    167         gc->br=c->r/65535.0;
    168         gc->bg=c->g/65535.0;
    169         gc->bb=c->b/65535.0;
    170         gc->ba=c->a/65535.0;
     249  gc->br = c->r / 65535.0;
     250  gc->bg = c->g / 65535.0;
     251  gc->bb = c->b / 65535.0;
     252  gc->ba = c->a / 65535.0;
    171253}
    172254
    173255static struct graphics_gc_methods gc_methods = {
    174         gc_destroy,
    175         gc_set_linewidth,
    176         gc_set_dashes, 
    177         gc_set_foreground,     
    178         gc_set_background       
     256  gc_destroy,
     257  gc_set_linewidth,
     258  gc_set_dashes,
     259  gc_set_foreground,
     260  gc_set_background
    179261};
    180262
    181 static struct graphics_gc_priv *gc_new(struct graphics_priv *gr, struct graphics_gc_methods *meth)
     263static struct graphics_gc_priv *
     264gc_new (struct graphics_priv *gr, struct graphics_gc_methods *meth)
    182265{
    183         struct graphics_gc_priv *gc=g_new(struct graphics_gc_priv, 1);
     266  struct graphics_gc_priv *gc = g_new (struct graphics_gc_priv, 1);
    184267
    185         *meth=gc_methods;
    186         gc->gr=gr;
    187         gc->linewidth=1;
    188         return gc;
     268  *meth = gc_methods;
     269  gc->gr = gr;
     270  gc->linewidth = 1;
     271  return gc;
    189272}
    190273
    191 
    192274static struct graphics_image_priv *
    193 image_new(struct graphics_priv *gr, struct graphics_image_methods *meth, char *name, int *w, int *h)
     275image_new (struct graphics_priv *gr, struct graphics_image_methods *meth,
     276           char *path, int *w, int *h, struct point *hot, int rotation)
    194277{
    195 #if 0
    196         GdkPixbuf *pixbuf;
    197         struct graphics_image_priv *ret;
    198 
    199         pixbuf=gdk_pixbuf_new_from_file(name, NULL);
    200         if (! pixbuf)
    201                 return NULL;
    202         ret=g_new0(struct graphics_image_priv, 1);
    203         ret->pixbuf=pixbuf;
    204         ret->w=gdk_pixbuf_get_width(pixbuf);
    205         ret->h=gdk_pixbuf_get_height(pixbuf);
    206         *w=ret->w;
    207         *h=ret->h;
    208         return ret;
    209 #endif
    210         return NULL;
    211 }
     278  FIBITMAP *image;
     279  RGBQUAD aPixel;
     280  unsigned char *data;
     281  int width, height, i, j;
    212282
    213 static void
    214 draw_lines(struct graphics_priv *gr, struct graphics_gc_priv *gc, struct point *p, int count)
    215 {
    216          int i;
    217 /*
    218         if (gr->mode == draw_mode_begin || gr->mode == draw_mode_end)
    219                 gdk_draw_lines(gr->drawable, gc->gc, (GdkPoint *)p, count);
    220         if (gr->mode == draw_mode_end || gr->mode == draw_mode_cursor)
    221                 gdk_draw_lines(gr->widget->window, gc->gc, (GdkPoint *)p, count);
    222 */
    223         /*     
    224         if(gr->mode == draw_mode_begin){
    225                 printf("B");
    226         } else if (gr->mode == draw_mode_end){
    227                 printf("E");
    228         } else {
    229                 printf("x");
    230         }
    231 */     
    232 
    233         for (i = 0 ; i < count-1 ; i++) {
    234 
    235 //              glEnable( GL_POLYGON_SMOOTH );
    236 //              glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA );
    237 //              glEnable( GL_BLEND );
    238 
    239                 float dx=p[i+1].x-p[i].x;
    240                 float dy=p[i+1].y-p[i].y;
    241 
    242                 float cx=(p[i+1].x+p[i].x)/2;
    243                 float cy=(p[i+1].y+p[i].y)/2;
    244 //              printf("(%lx,%lx) -> (%lx,%lx) : (%lx,%lx)\n",p[i].x,p[i].y,p[i+1].x,p[i+1].y,dx,dy);
    245 
    246                 int w=round(sqrt(pow((dx),2)+pow((dy),2)));
    247 
    248                 float angle=atan (dy/dx) * 180 / M_PI;
    249 
    250                 glPushMatrix();
    251                 glTranslatef(cx,cy,1);
    252         //      glColor4f( 0,0,0,1);
    253         //      glRasterPos2f( 1,1 );
    254                 glRotatef(angle,0.0,0.0,1.0);
    255 
    256                 glColor4f( gc->fr, gc->fg, gc->fb, gc->fa);
    257 
    258                 int linewidth=gc->linewidth;
    259 
    260                 glBegin( GL_POLYGON );
    261                                 glVertex2f( -w/2,-linewidth/2 );
    262                                 glVertex2f( -w/2-4,0 );
    263                                 glVertex2f( -w/2,+linewidth/2 );
    264                                 glVertex2f( +w/2,+linewidth/2 );
    265                                 glVertex2f( +w/2+4,0 );
    266                                 glVertex2f( +w/2,-linewidth/2 );
    267                                 glVertex2f( -w/2,+linewidth/2 );
    268                 glEnd();
    269 
    270                
    271                 // FIXME Roads label can maybe be drawn here, avoid the display_label loop, when playing with Z axis position.
    272                 /*
    273                 if(attr==1){
    274                         glcRenderStyle(GLC_TEXTURE);
    275                         glColor3f(0., 0., 0.);
    276                         glScalef(12, 12, 0.);
    277                         glcRenderString(">>");
    278                 } else if(attr==-1){
    279                         glcRenderStyle(GLC_TEXTURE);
    280                         glColor3f(0., 0., 0.);
    281                         glScalef(12, 12, 0.);
    282                         glcRenderString("<<");
    283                 }
    284 
    285                 */
    286                 glPopMatrix();
     283  if (strlen (path) < 4)
     284    {
     285      return NULL;
     286    }
     287  char *ext_str = path + strlen (path) - 3;
     288  if (strstr (ext_str, "png") || strstr (path, "PNG"))
     289    {
     290      if ((image = FreeImage_Load (FIF_PNG, path, 0)) == NULL)
     291        {
     292          return NULL;
    287293        }
    288 //      glDisable( GL_BLEND );
    289 //      glDisable( GL_POLYGON_SMOOTH );
     294    }
     295  else if (strstr (ext_str, "xpm") || strstr (path, "XPM"))
     296    {
     297      if ((image = FreeImage_Load (FIF_XPM, path, 0)) == NULL)
     298        {
     299          return NULL;
     300        }
     301    }
     302  else if (strstr (ext_str, "svg") || strstr (path, "SVG"))
     303    {
     304      char path_new[256];
     305      snprintf (path_new, strlen (path) - 3, "%s", path);
     306      strcat (path_new, "_48_48.png");
     307
     308      if ((image = FreeImage_Load (FIF_PNG, path_new, 0)) == NULL)
     309        {
     310          return NULL;
     311        }
     312    }
     313  else
     314    {
     315      return NULL;
     316    }
     317  struct graphics_image_priv *gi;
     318  gi = g_new0 (struct graphics_image_priv, 1);
     319
     320  width = FreeImage_GetWidth (image);
     321  height = FreeImage_GetHeight (image);
     322
     323  data = (unsigned char *) malloc (width * height * 4);
     324
     325  RGBQUAD *palette = NULL;
     326  if (FreeImage_GetBPP (image) == 8)
     327    {
     328      palette = FreeImage_GetPalette (image);
     329    }
     330
     331  for (i = 0; i < height; i++)
     332    {
     333      for (j = 0; j < width; j++)
     334        {
     335          unsigned char idx;
     336          if (FreeImage_GetBPP (image) == 8)
     337            {
     338              FreeImage_GetPixelIndex (image, j, height - i - 1, &idx);
     339              data[4 * width * i + 4 * j + 0] = palette[idx].rgbRed;
     340              data[4 * width * i + 4 * j + 1] = palette[idx].rgbGreen;
     341              data[4 * width * i + 4 * j + 2] = palette[idx].rgbBlue;
     342              data[4 * width * i + 4 * j + 3] = 255;
     343            }
     344          else if (FreeImage_GetBPP (image) == 16
     345                   || FreeImage_GetBPP (image) == 24
     346                   || FreeImage_GetBPP (image) == 32)
     347            {
     348              FreeImage_GetPixelColor (image, j, height - i - 1, &aPixel);
     349              int transparent = (aPixel.rgbRed == 0 && aPixel.rgbBlue == 0
     350                                 && aPixel.rgbGreen == 0);
     351              data[4 * width * i + 4 * j + 0] =
     352                transparent ? 0 : (aPixel.rgbRed);
     353              data[4 * width * i + 4 * j + 1] = (aPixel.rgbGreen);
     354              data[4 * width * i + 4 * j + 2] =
     355                transparent ? 0 : (aPixel.rgbBlue);
     356              data[4 * width * i + 4 * j + 3] = transparent ? 0 : 255;
     357
     358            }
     359          else if (FreeImage_GetBPP (image) == 64)
     360            {
     361              //FreeImage_GetPixelColor does not handle 64bits/pixel images correctly
     362              return NULL;
     363            }
    290364
    291 /*
    292         if(label){
    293                 if((strlen(label)*6)<w){
    294                         SDL_print(label,cx, cy,-angle);
    295                 }
    296365        }
    297 */
    298 }
     366    }
    299367
     368  FreeImage_Unload (image);
    300369
    301 const char* getPrimitiveType(GLenum type)
     370  *w = width;
     371  *h = height;
     372  gi->w = width;
     373  gi->h = height;
     374  gi->hot_x = width / 2 - 1;
     375  gi->hot_y = height / 2 - 1;
     376  hot->x = width / 2 - 1;
     377  hot->y = height / 2 - 1;
     378  gi->data = data;
     379  gi->path = path;
     380  return gi;
     381}
     382
     383const char *
     384getPrimitiveType (GLenum type)
    302385{
    303     char *ret;
     386  char *ret = "";
    304387
    305     switch(type)
     388  switch (type)
    306389    {
    307390    case 0x0000:
    308         ret="GL_POINTS";
    309         break;
     391      ret = "GL_POINTS";
     392      break;
    310393    case 0x0001:
    311         ret="GL_LINES";
    312         break;
     394      ret = "GL_LINES";
     395      break;
    313396    case 0x0002:
    314         ret= "GL_LINE_LOOP";
    315         break;
     397      ret = "GL_LINE_LOOP";
     398      break;
    316399    case 0x0003:
    317         ret="GL_LINE_STRIP";
    318         break;
     400      ret = "GL_LINE_STRIP";
     401      break;
    319402    case 0x0004:
    320         ret="GL_TRIANGLES";
    321         break;
     403      ret = "GL_TRIANGLES";
     404      break;
    322405    case 0x0005:
    323         ret="GL_TRIANGLE_STRIP";
    324         break;
     406      ret = "GL_TRIANGLE_STRIP";
     407      break;
    325408    case 0x0006:
    326         ret="GL_TRIANGLE_FAN";
    327         break;
     409      ret = "GL_TRIANGLE_FAN";
     410      break;
    328411    case 0x0007:
    329         ret="GL_QUADS";
    330         break;
     412      ret = "GL_QUADS";
     413      break;
    331414    case 0x0008:
    332         ret="GL_QUAD_STRIP";
    333         break;
     415      ret = "GL_QUAD_STRIP";
     416      break;
    334417    case 0x0009:
    335         ret="GL_POLYGON";
    336         break;
     418      ret = "GL_POLYGON";
     419      break;
    337420    }
    338 return ret;
     421  return ret;
    339422}
    340423
    341 void CALLBACK tessBeginCB(GLenum which)
     424void CALLBACK
     425tessBeginCB (GLenum which)
    342426{
    343     glBegin(which);
     427  glBegin (which);
    344428
    345     dbg(1,"glBegin( %s );\n",getPrimitiveType(which));
     429  dbg (1, "glBegin( %s );\n", getPrimitiveType (which));
    346430}
    347431
    348432
    349433
    350 void CALLBACK tessEndCB()
     434void CALLBACK
     435tessEndCB ()
    351436{
    352     glEnd();
     437  glEnd ();
    353438
    354     dbg(1,"glEnd();\n");
     439  dbg (1, "glEnd();\n");
    355440}
    356441
    357442
    358443
    359 void CALLBACK tessVertexCB(const GLvoid *data)
     444void CALLBACK
     445tessVertexCB (const GLvoid * data)
    360446{
    361     // cast back to double type
    362     const GLdouble *ptr = (const GLdouble*)data;
     447  // cast back to double type
     448  const GLdouble *ptr = (const GLdouble *) data;
    363449
    364     glVertex3dv(ptr);
     450  glVertex3dv (ptr);
    365451
    366     dbg(1,"  glVertex3d();\n");
     452  dbg (1, "  glVertex3d();\n");
    367453}
    368454
     455static void
     456get_overlay_pos (struct graphics_priv *gr, struct point *point_out)
     457{
     458  if (gr->parent == NULL)
     459    {
     460      point_out->x = 0;
     461      point_out->y = 0;
     462      return;
     463    }
     464  point_out->x = gr->p.x;
     465  if (point_out->x < 0)
     466    {
     467      point_out->x += gr->parent->width;
     468    }
     469
     470  point_out->y = gr->p.y;
     471  if (point_out->y < 0)
     472    {
     473      point_out->y += gr->parent->height;
     474    }
     475}
    369476
    370477static void
    371 draw_polygon(struct graphics_priv *gr, struct graphics_gc_priv *gc, struct point *p, int count)
     478draw_lines (struct graphics_priv *gr, struct graphics_gc_priv *gc,
     479            struct point *p, int count)
    372480{
    373         int i;
     481  if (gr->parent && !gr->parent->overlay_enabled)
     482    {
     483      return;
     484    }
    374485
    375         GLUtesselator *tess = gluNewTess(); // create a tessellator
    376         if(!tess) return 0;  // failed to create tessellation object, return 0
     486  graphics_priv_root->dirty = 1;
    377487
    378         GLdouble quad1[count][3];
    379         for (i = 0 ; i < count ; i++) {
    380                 quad1[i][0]=(GLdouble)(p[i].x);
    381                 quad1[i][1]=(GLdouble)(p[i].y);
    382                 quad1[i][2]=0;
    383         }
     488  glColor4f (gc->fr, gc->fg, gc->fb, gc->fa);
     489  glLineWidth (gc->linewidth);
     490  if (!gr->parent && 0 < gc->dash_count)
     491    {
     492      glLineStipple (1, gc->dash_mask);
     493      glEnable (GL_LINE_STIPPLE);
     494    }
     495  glBegin (GL_LINE_STRIP);
     496  int i;
     497  for (i = 0; i < count; i++)
     498    {
     499      struct point p_eff;
     500      p_eff.x = p[i].x;
     501      p_eff.y = p[i].y;
     502      glVertex2f (p_eff.x, p_eff.y);
     503    }
     504  glEnd ();
     505  if (!gr->parent && 0 < gc->dash_count)
     506    {
     507      glDisable (GL_LINE_STIPPLE);
     508    }
     509}
    384510
    385511
    386         // register callback functions
    387         gluTessCallback(tess, GLU_TESS_BEGIN, (void (*)(void))tessBeginCB);
    388         gluTessCallback(tess, GLU_TESS_END, (void (*)(void))tessEndCB);
    389         //     gluTessCallback(tess, GLU_TESS_ERROR, (void (*)(void))tessErrorCB);
    390         gluTessCallback(tess, GLU_TESS_VERTEX, (void (*)(void))tessVertexCB);
    391        
    392         // tessellate and compile a concave quad into display list
    393         // gluTessVertex() takes 3 params: tess object, pointer to vertex coords,
    394         // and pointer to vertex data to be passed to vertex callback.
    395         // The second param is used only to perform tessellation, and the third
    396         // param is the actual vertex data to draw. It is usually same as the second
    397         // param, but It can be more than vertex coord, for example, color, normal
    398         // and UV coords which are needed for actual drawing.
    399         // Here, we are looking at only vertex coods, so the 2nd and 3rd params are
    400         // pointing same address.
    401         glColor4f( gc->fr, gc->fg, gc->fb, gc->fa);
    402         gluTessBeginPolygon(tess, 0);                   // with NULL data
    403                 gluTessBeginContour(tess);
    404                 for (i = 0 ; i < count ; i++) {
    405                 gluTessVertex(tess, quad1[i], quad1[i]);
    406                 }
    407                 gluTessEndContour(tess);
    408         gluTessEndPolygon(tess);
    409        
    410         gluDeleteTess(tess);        // delete after tessellation
     512static void
     513draw_polygon (struct graphics_priv *gr, struct graphics_gc_priv *gc,
     514              struct point *p, int count)
     515{
     516  if (gr->parent && !gr->parent->overlay_enabled)
     517    {
     518      return;
     519    }
    411520
     521  graphics_priv_root->dirty = 1;
     522
     523  int i;
     524  GLUtesselator *tess = gluNewTess ();  // create a tessellator
     525  if (!tess)
     526    return;                     // failed to create tessellation object, return 0
     527
     528  GLdouble quad1[count][3];
     529  for (i = 0; i < count; i++)
     530    {
     531      quad1[i][0] = (GLdouble) (p[i].x);
     532      quad1[i][1] = (GLdouble) (p[i].y);
     533      quad1[i][2] = 0;
     534    }
     535
     536
     537  // register callback functions
     538  gluTessCallback (tess, GLU_TESS_BEGIN, (void (*)(void)) tessBeginCB);
     539  gluTessCallback (tess, GLU_TESS_END, (void (*)(void)) tessEndCB);
     540  //     gluTessCallback(tess, GLU_TESS_ERROR, (void (*)(void))tessErrorCB);
     541  gluTessCallback (tess, GLU_TESS_VERTEX, (void (*)(void)) tessVertexCB);
     542
     543  // tessellate and compile a concave quad into display list
     544  // gluTessVertex() takes 3 params: tess object, pointer to vertex coords,
     545  // and pointer to vertex data to be passed to vertex callback.
     546  // The second param is used only to perform tessellation, and the third
     547  // param is the actual vertex data to draw. It is usually same as the second
     548  // param, but It can be more than vertex coord, for example, color, normal
     549  // and UV coords which are needed for actual drawing.
     550  // Here, we are looking at only vertex coods, so the 2nd and 3rd params are
     551  // pointing same address.
     552  glColor4f (gc->fr, gc->fg, gc->fb, gc->fa);
     553  gluTessBeginPolygon (tess, 0);        // with NULL data
     554  gluTessBeginContour (tess);
     555  for (i = 0; i < count; i++)
     556    {
     557      gluTessVertex (tess, quad1[i], quad1[i]);
     558    }
     559  gluTessEndContour (tess);
     560  gluTessEndPolygon (tess);
     561
     562  gluDeleteTess (tess);         // delete after tessellation
    412563}
    413564
    414565static void
    415 draw_rectangle(struct graphics_priv *gr, struct graphics_gc_priv *gc, struct point *p, int w, int h)
     566draw_rectangle (struct graphics_priv *gr, struct graphics_gc_priv *gc,
     567                struct point *p, int w, int h)
    416568{
    417 #if 0
    418         gdk_draw_rectangle(gr->drawable, gc->gc, TRUE, p->x, p->y, w, h);
    419 #endif
     569  if (gr->parent && !gr->parent->overlay_enabled)
     570    {
     571      return;
     572    }
     573
     574  graphics_priv_root->dirty = 1;
     575
     576  struct point p_eff;
     577  p_eff.x = p->x;
     578  p_eff.y = p->y;
     579
     580  glColor4f (gc->fr, gc->fg, gc->fb, gc->fa);
     581  glBegin (GL_POLYGON);
     582  glVertex2f (p_eff.x, p_eff.y);
     583  glVertex2f (p_eff.x + w, p_eff.y);
     584  glVertex2f (p_eff.x + w, p_eff.y + h);
     585  glVertex2f (p_eff.x, p_eff.y + h);
     586  glEnd ();
    420587}
    421588
    422589static void
    423 draw_circle(struct graphics_priv *gr, struct graphics_gc_priv *gc, struct point *p, int r)
     590draw_circle (struct graphics_priv *gr, struct graphics_gc_priv *gc,
     591             struct point *p, int r)
    424592{
    425 #if 0
    426         if (gr->mode == draw_mode_begin || gr->mode == draw_mode_end)
    427                 gdk_draw_arc(gr->drawable, gc->gc, FALSE, p->x-r/2, p->y-r/2, r, r, 0, 64*360);
    428         if (gr->mode == draw_mode_end || gr->mode == draw_mode_cursor)
    429                 gdk_draw_arc(gr->widget->window, gc->gc, FALSE, p->x-r/2, p->y-r/2, r, r, 0, 64*360);
     593
     594  if (gr->parent && !gr->parent->overlay_enabled)
     595    {
     596      return;
     597    }
     598
     599  graphics_priv_root->dirty = 1;
     600
     601  /* FIXME: does not quite match gtk */
     602  /* hack for osd compass.. why is this needed!? */
     603  if (gr->parent)
     604    {
     605      r = r / 2;
     606    }
     607
     608  struct point p_eff;
     609  p_eff.x = p->x;
     610  p_eff.y = p->y;
     611
     612  GLint circle_points = 7 + r / 5;
     613  glColor4f (gc->fr, gc->fg, gc->fb, gc->fa);
     614  glLineWidth (gc->linewidth * 2);
     615  glBegin (GL_LINE_LOOP);
     616  int i;
     617  for (i = 0; i < circle_points; ++i)
     618    {
     619      double angle = 2 * M_PI * i / circle_points;
     620      glVertex2f (r * cos (angle) + p_eff.x, r * sin (angle) + p_eff.y);
     621    }
     622  glEnd ();
     623}
     624
     625static void
     626display_text_draw (struct font_freetype_text *text, struct graphics_priv *gr,
     627                   struct graphics_gc_priv *fg, struct graphics_gc_priv *bg,
     628                   int color, struct point *p)
     629{
     630  int i, x, y, stride;
     631  struct font_freetype_glyph *g, **gp;
     632  unsigned char *shadow, *glyph;
     633  struct color transparent = { 0x0000, 0x0000, 0x0000, 0x0000 };
     634  struct color black =
     635    { fg->fr * 65535, fg->fg * 65535, fg->fb * 65535, fg->fa * 65535 };
     636  struct color white = { 0xffff, 0xffff, 0xffff, 0xffff };
     637
     638  if (bg)
     639    {
     640      if(COLOR_IS_WHITE(black) && COLOR_IS_BLACK(white)) {
     641        black.r = 65535;
     642        black.g = 65535;
     643        black.b = 65535;
     644        black.a = 65535;
     645
     646        white.r = 0;
     647        white.g = 0;
     648        white.b = 0;
     649        white.a = 65535;
     650       }
     651      else if(COLOR_IS_BLACK(black) && COLOR_IS_WHITE(white)) {
     652        white.r = 65535;
     653        white.g = 65535;
     654        white.b = 65535;
     655        white.a = 65535;
     656
     657        black.r = 0;
     658        black.g = 0;
     659        black.b = 0;
     660        black.a = 65535;
     661      }
     662      else {
     663        white.r = bg->fr;
     664        white.g = bg->fg;
     665        white.b = bg->fb;
     666        white.a = bg->fa;
     667      }
     668    }
     669  else {
     670    white.r = 0;
     671    white.g = 0;
     672    white.b = 0;
     673    white.a = 0;
     674  }
     675
     676  gp = text->glyph;
     677  i = text->glyph_count;
     678  x = p->x << 6;
     679  y = p->y << 6;
     680  while (i-- > 0)
     681    {
     682      g = *gp++;
     683      if (g->w && g->h && bg)
     684        {
     685          stride = (g->w + 2) * 4;
     686          if (color)
     687            {
     688              shadow = g_malloc (stride * (g->h + 2));
     689              gr->freetype_methods.get_shadow (g, shadow, 32, stride, &white,
     690                                               &transparent);
     691#ifdef MIRRORED_VIEW
     692              glPixelZoom (-1.0, -1.0); //mirrored mode
     693#else
     694              glPixelZoom (1.0, -1.0);
     695#endif
     696              glRasterPos2d ((x + g->x) >> 6, (y + g->y) >> 6);
     697              glDrawPixels (g->w + 2, g->h + 2, GL_BGRA, GL_UNSIGNED_BYTE,
     698                            shadow);
     699              g_free (shadow);
     700            }
     701        }
     702      x += g->dx;
     703      y += g->dy;
     704    }
     705
     706  x = p->x << 6;
     707  y = p->y << 6;
     708  gp = text->glyph;
     709  i = text->glyph_count;
     710  while (i-- > 0)
     711    {
     712      g = *gp++;
     713      if (g->w && g->h)
     714        {
     715          if (color)
     716            {
     717              stride = g->w;
     718              if (bg)
     719                {
     720                  glyph = g_malloc (stride * g->h * 4);
     721                  gr->freetype_methods.get_glyph (g, glyph, 32, stride * 4,
     722                                                  &black, &white, &transparent);
     723#ifdef MIRRORED_VIEW
     724              glPixelZoom (-1.0, -1.0); //mirrored mode
     725#else
     726              glPixelZoom (1.0, -1.0);
     727#endif
     728              glRasterPos2d ((x + g->x) >> 6, (y + g->y) >> 6);
     729              glDrawPixels (g->w, g->h, GL_BGRA, GL_UNSIGNED_BYTE, glyph);
     730
     731                  g_free (glyph);
     732                }
     733              stride *= 4;
     734              glyph = g_malloc (stride * g->h);
     735              gr->freetype_methods.get_glyph (g, glyph, 32, stride, &black,
     736                                              &white, &transparent);
     737
     738#ifdef MIRRORED_VIEW
     739              glPixelZoom (-1.0, -1.0); //mirrored mode
     740#else
     741              glPixelZoom (1.0, -1.0);
    430742#endif
     743              glRasterPos2d ((x + g->x) >> 6, (y + g->y) >> 6);
     744              glDrawPixels (g->w, g->h, GL_BGRA, GL_UNSIGNED_BYTE, glyph);
     745              g_free (glyph);
     746            }
     747        }
     748      x += g->dx;
     749      y += g->dy;
     750    }
    431751}
    432752
     753static void
     754draw_text (struct graphics_priv *gr, struct graphics_gc_priv *fg,
     755           struct graphics_gc_priv *bg, struct graphics_font_priv *font,
     756           char *text, struct point *p, int dx, int dy)
     757{
     758  if (gr->parent && !gr->parent->overlay_enabled)
     759    {
     760      return;
     761    }
    433762
     763  struct font_freetype_text *t;
     764  int color = 1;
    434765
    435 void SDL_print(char * label,int x, int y, double angle)
     766  if (!font)
     767    {
     768      dbg (0, "no font, returning\n");
     769      return;
     770    }
     771
     772  graphics_priv_root->dirty = 1;
     773
     774  t =
     775    gr->freetype_methods.text_new (text, (struct font_freetype_font *) font,
     776                                   dx, dy);
     777
     778  struct point p_eff;
     779  p_eff.x = p->x;
     780  p_eff.y = p->y;
     781
     782  display_text_draw (t, gr, fg, bg, color, &p_eff);
     783  gr->freetype_methods.text_destroy (t);
     784}
     785
     786
     787static void
     788draw_image (struct graphics_priv *gr, struct graphics_gc_priv *fg,
     789            struct point *p, struct graphics_image_priv *img)
    436790{
    437         glPushMatrix();
    438         glcRenderStyle(GLC_TEXTURE);
    439         glColor4f(0,0,0,1);
    440         glTranslatef(x, y, 1);
    441         glRotatef(180,1,0,0);
    442         glRotatef(angle,0,0,1);
     791  if (gr->parent && !gr->parent->overlay_enabled)
     792    {
     793      return;
     794    }
    443795
    444         glScalef(14, 14, 14);
    445         // FIXME : add some error checking : glcGetError()
    446         glcRenderString(label);
    447         glPopMatrix();
     796  if (!img || !img->data)
     797    {
     798      return;
     799    }
     800
     801  graphics_priv_root->dirty = 1;
     802
     803  struct point p_eff;
     804  p_eff.x = p->x + img->hot_x;
     805  p_eff.y = p->y + img->hot_y;
     806
     807  glEnable (GL_BLEND);
     808  glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     809
     810  glRasterPos2d (p_eff.x - img->hot_x, p_eff.y - img->hot_y);
     811  glDrawPixels (img->w, img->h, GL_RGBA, GL_UNSIGNED_BYTE, img->data);
    448812
    449813}
    450814
    451815static void
    452 draw_text(struct graphics_priv *gr, struct graphics_gc_priv *fg, struct graphics_gc_priv *bg, struct graphics_font_priv *font, char *text, struct point *p, int dx, int dy)
     816draw_image_warp (struct graphics_priv *gr, struct graphics_gc_priv *fg,
     817                 struct point *p, int count, char *data)
    453818{
    454 //      dbg(0,"%s : %i,%i, %f\n",text,dx,dy,(180*atan2(dx,dy)/3.14));
    455         SDL_print(text,p->x,p->y,(180*atan2(dx,dy)/3.14)-90);
    456819}
    457820
    458821static void
    459 draw_image(struct graphics_priv *gr, struct graphics_gc_priv *fg, struct point *p, struct graphics_image_priv *img)
     822draw_restore (struct graphics_priv *gr, struct point *p, int w, int h)
    460823{
    461 #if 0
    462         gdk_draw_pixbuf(gr->drawable, fg->gc, img->pixbuf, 0, 0, p->x, p->y,
    463                     img->w, img->h, GDK_RGB_DITHER_NONE, 0, 0);
    464 #endif
     824  //printf ("darw_restore %X  %d %d %d %d\n", gr, p->x, p->y, w, h);
    465825}
    466826
    467 #ifdef HAVE_IMLIB2
    468827static void
    469 draw_image_warp(struct graphics_priv *gr, struct graphics_gc_priv *fg, struct point *p, int count, char *data)
     828draw_drag (struct graphics_priv *gr, struct point *p)
    470829{
    471 #if 0
    472         void *image;
    473         int w,h;
    474         printf("draw_image_warp data=%s\n", data);
    475         image = imlib_load_image(data);
    476         imlib_context_set_display(gdk_x11_drawable_get_xdisplay(gr->widget->window));
    477         imlib_context_set_colormap(gdk_x11_colormap_get_xcolormap(gtk_widget_get_colormap(gr->widget)));
    478         imlib_context_set_visual(gdk_x11_visual_get_xvisual(gtk_widget_get_visual(gr->widget)));
    479         imlib_context_set_drawable(gdk_x11_drawable_get_xid(gr->drawable));
    480         imlib_context_set_image(image);
    481         w = imlib_image_get_width();
    482         h = imlib_image_get_height();
    483         if (count == 3) {
    484                 imlib_render_image_on_drawable_skewed(0, 0, w, h, p[0].x, p[0].y, p[1].x-p[0].x, p[1].y-p[0].y, p[2].x-p[0].x, p[2].y-p[0].y);
    485         }
    486         if (count == 2) {
    487                 imlib_render_image_on_drawable_skewed(0, 0, w, h, p[0].x, p[0].y, p[1].x-p[0].x, 0, 0, p[1].y-p[0].y);
    488         }
    489 #endif
     830
     831  if (p)
     832    {
     833      gr->p.x = p->x;
     834      gr->p.y = p->y;
     835    }
    490836}
    491 #endif
    492837
    493838static void
    494 overlay_draw(struct graphics_priv *parent, struct graphics_priv *overlay, int window)
     839background_gc (struct graphics_priv *gr, struct graphics_gc_priv *gc)
    495840{
    496 #if 0
    497         GdkPixbuf *pixbuf,*pixbuf2;
    498         GtkWidget *widget=parent->widget;
    499         guchar *pixels1, *pixels2, *p1, *p2;
    500         int x,y;
    501         int rowstride1,rowstride2;
    502         int n_channels1,n_channels2;
    503 
    504         if (! parent->drawable)
    505                 return;
    506 
    507         pixbuf=gdk_pixbuf_get_from_drawable(NULL, overlay->drawable, NULL, 0, 0, 0, 0, overlay->width, overlay->height);
    508         pixbuf2=gdk_pixbuf_new(gdk_pixbuf_get_colorspace(pixbuf), TRUE, gdk_pixbuf_get_bits_per_sample(pixbuf),
    509                                 gdk_pixbuf_get_width(pixbuf), gdk_pixbuf_get_height(pixbuf));
    510 
    511         rowstride1 = gdk_pixbuf_get_rowstride (pixbuf);
    512         rowstride2 = gdk_pixbuf_get_rowstride (pixbuf2);
    513         pixels1=gdk_pixbuf_get_pixels (pixbuf);
    514         pixels2=gdk_pixbuf_get_pixels (pixbuf2);       
    515         n_channels1 = gdk_pixbuf_get_n_channels (pixbuf);
    516         n_channels2 = gdk_pixbuf_get_n_channels (pixbuf2);
    517         for (y = 0 ; y < overlay->height ; y++) {
    518                 for (x = 0 ; x < overlay->width ; x++) {
    519                         p1 = pixels1 + y * rowstride1 + x * n_channels1;
    520                         p2 = pixels2 + y * rowstride2 + x * n_channels2;
    521                         p2[0]=p1[0];
    522                         p2[1]=p1[1];
    523                         p2[2]=p1[2];
    524                         p2[3]=127;
    525                 }
     841  gr->background_gc = gc;
     842}
     843
     844static void handle_mouse_queue()
     845{
     846  static locked = 0;
     847  if(!locked) {
     848    locked = 1;
     849  }
     850  else {
     851    return;
     852  }
     853
     854  if(mouse_event_queue_begin_idx < mouse_event_queue_end_idx) {
     855    //printf("CLICK %d %d %d %d\n", mouse_queue[mouse_event_queue_begin_idx].button,mouse_queue[mouse_event_queue_begin_idx].state,mouse_queue[mouse_event_queue_begin_idx].x,mouse_queue[mouse_event_queue_begin_idx].y);
     856    if (mouse_queue[mouse_event_queue_begin_idx].button == GLUT_LEFT_BUTTON && mouse_queue[mouse_event_queue_begin_idx].state == GLUT_UP)
     857      {
     858        struct point p;
     859        p.x = mouse_queue[mouse_event_queue_begin_idx%mouse_event_queue_size].x;
     860        p.y = mouse_queue[mouse_event_queue_begin_idx%mouse_event_queue_size].y;
     861        graphics_priv_root->force_redraw = 1;
     862        callback_list_call_attr_3 (graphics_priv_root->cbl, attr_button,
     863                                 (void *) 0, 1, (void *) &p);
     864      }
     865    else if (mouse_queue[mouse_event_queue_begin_idx].button == GLUT_LEFT_BUTTON && mouse_queue[mouse_event_queue_begin_idx].state == GLUT_DOWN)
     866      {
     867        struct point p;
     868        p.x = mouse_queue[mouse_event_queue_begin_idx%mouse_event_queue_size].x;
     869        p.y = mouse_queue[mouse_event_queue_begin_idx%mouse_event_queue_size].y;
     870        graphics_priv_root->force_redraw = 1;
     871        callback_list_call_attr_3 (graphics_priv_root->cbl, attr_button,
     872                                 (void *) 1, 1, (void *) &p);
     873      }
     874    ++mouse_event_queue_begin_idx;
     875  }
     876  locked = 0;
     877}
     878
     879
     880/*draws root graphics and its overlays*/
     881static int
     882redraw_screen (struct graphics_priv *gr)
     883{
     884
     885  time_t curr_time = time(0);
     886  graphics_priv_root->dirty = 0;
     887
     888  glCallList (gr->DLid);
     889  //display overlays display list
     890  struct graphics_priv *overlay;
     891  overlay = gr->overlays;
     892  while (gr->overlay_enabled && overlay)
     893    {
     894      glPushMatrix ();
     895      struct point p_eff;
     896      get_overlay_pos (overlay, &p_eff);
     897      glTranslatef (p_eff.x, p_eff.y, 1);
     898      glCallList (overlay->DLid);
     899      glPopMatrix ();
     900      overlay = overlay->next;
     901    }
     902  glutSwapBuffers ();
     903
     904  return TRUE;
     905}
     906
     907
     908/*filters call to redraw in overlay enabled(map) mode*/
     909static void
     910redraw_filter (struct graphics_priv *gr)
     911{
     912  if(gr->overlay_enabled && gr->dirty) {
     913    redraw_screen(gr);
     914  }
     915}
     916
     917
     918
     919static void
     920draw_mode (struct graphics_priv *gr, enum draw_mode_num mode)
     921{
     922  if (gr->parent)
     923    {                           //overlay
     924      if (mode == draw_mode_begin)
     925        {
     926          glNewList (gr->DLid, GL_COMPILE);
    526927        }
    527         if (window)
    528                 gdk_draw_pixmap(parent->drawable, widget->style->fg_gc[GTK_WIDGET_STATE(widget)], overlay->background, 0, 0, overlay->p.x, overlay->p.y, overlay->width, overlay->height);
    529         else
    530                 gdk_draw_pixmap(overlay->background, widget->style->fg_gc[GTK_WIDGET_STATE(widget)], parent->drawable, overlay->p.x, overlay->p.y, 0, 0, overlay->width, overlay->height);
    531         gdk_draw_pixbuf(parent->drawable, widget->style->fg_gc[GTK_WIDGET_STATE(widget)], pixbuf2, 0, 0, overlay->p.x, overlay->p.y, overlay->width, overlay->height, GDK_RGB_DITHER_NONE, 0, 0);
    532         if (window)
    533                 gdk_draw_pixmap(widget->window, widget->style->fg_gc[GTK_WIDGET_STATE(widget)], parent->drawable, overlay->p.x, overlay->p.y, overlay->p.x, overlay->p.y, overlay->width, overlay->height);
    534 #if 0
    535         gdk_draw_pixmap(gr->gra->drawable,
    536                         gr->gra->widget->style->fg_gc[GTK_WIDGET_STATE(gr->gra->widget)],
    537                         img->gra->drawable,
    538                         0, 0, p->x, p->y, img->gra->width, img->gra->height);
    539 #endif
    540 #endif
     928
     929      if (mode == draw_mode_end || mode == draw_mode_end_lazy)
     930        {
     931          glEndList ();
     932          //redraw_screen (gr->parent);
     933        }
     934    }
     935  else
     936    {                           //root graphics
     937      if (mode == draw_mode_begin)
     938        {
     939          glNewList (gr->DLid, GL_COMPILE);
     940        }
     941
     942      if (mode == draw_mode_end)
     943        {
     944          glEndList ();
     945          gr->force_redraw = 1;
     946          if(!gr->overlay_enabled || gr->force_redraw ) {
     947            redraw_screen (gr);
     948          }
     949        }
     950    }
     951  gr->mode = mode;
     952}
     953
     954static struct graphics_priv *overlay_new (struct graphics_priv *gr,
     955                                          struct graphics_methods *meth,
     956                                          struct point *p, int w, int h,
     957                                          int alpha, int wraparound);
     958
     959static int
     960graphics_opengl_fullscreen (struct window *w, int on)
     961{
     962  return 1;
    541963}
    542964
    543965static void
    544 draw_restore(struct graphics_priv *gr, struct point *p, int w, int h)
     966graphics_opengl_disable_suspend (struct window *w)
    545967{
    546 #if 0
    547         GtkWidget *widget=gr->widget;
    548         gdk_draw_pixmap(widget->window,
    549                         widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
    550                         gr->drawable,
    551                         p->x, p->y, p->x, p->y, w, h);
    552 #endif
     968}
     969
     970
     971static void *
     972get_data (struct graphics_priv *this, char *type)
     973{
     974  /*TODO initialize gtkglext context then type=="gtk_widget" */
     975
     976
     977  if (strcmp (type, "window") == 0)
     978    {
     979      struct window *win;
     980      win = g_new (struct window, 1);
     981      win->priv = this;
     982      win->fullscreen = graphics_opengl_fullscreen;
     983      win->disable_suspend = graphics_opengl_disable_suspend;
     984      return win;
     985    }
     986  else
     987    {
     988      return &this->DLid;
     989    }
     990
    553991
    554992}
    555993
    556994static void
    557 background_gc(struct graphics_priv *gr, struct graphics_gc_priv *gc)
     995image_free (struct graphics_priv *gr, struct graphics_image_priv *priv)
    558996{
    559         gr->background_gc=gc;
     997  g_free(priv->data);
     998  priv->data = NULL;
     999  g_free(priv);
     1000  priv = NULL;
    5601001}
    5611002
    5621003static void
    563 draw_mode(struct graphics_priv *gr, enum draw_mode_num mode)
     1004overlay_disable (struct graphics_priv *gr, int disable)
    5641005{
    565         if (gr->DLid) {
    566                 if (mode == draw_mode_begin)
    567                         glNewList(gr->DLid,GL_COMPILE);
    568                 if (mode == draw_mode_end)
    569                         glEndList();
    570         }
    571 
    572 #if 0
    573         struct graphics_priv *overlay;
    574         GtkWidget *widget=gr->widget;
    575 
    576         if (mode == draw_mode_begin) {
    577                 if (! gr->parent && gr->background_gc)
    578                         gdk_draw_rectangle(gr->drawable, gr->background_gc->gc, TRUE, 0, 0, gr->width, gr->height);
    579         }
    580         if (mode == draw_mode_end && gr->mode == draw_mode_begin) {
    581                 if (gr->parent) {
    582                         overlay_draw(gr->parent, gr, 1);
    583                 } else {
    584                         overlay=gr->overlays;
    585                         while (overlay) {
    586                                 overlay_draw(gr, overlay, 0);
    587                                 overlay=overlay->next;
    588                         }
    589                         gdk_draw_pixmap(widget->window,
    590                                 widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
    591                                 gr->drawable,
    592                                 0, 0, 0, 0, gr->width, gr->height);
    593                 }
     1006  gr->overlay_enabled = !disable;
     1007}
     1008
     1009static void
     1010overlay_resize (struct graphics_priv *gr, struct point *p, int w, int h,
     1011                int alpha, int wraparound)
     1012{
     1013  int changed = 0;
     1014  int w2, h2;
     1015
     1016  if (w == 0)
     1017    {
     1018      w2 = 1;
     1019    }
     1020  else
     1021    {
     1022      w2 = w;
     1023    }
     1024
     1025  if (h == 0)
     1026    {
     1027      h2 = 1;
     1028    }
     1029  else
     1030    {
     1031      h2 = h;
     1032    }
     1033
     1034  gr->p = *p;
     1035  if (gr->width != w2)
     1036    {
     1037      gr->width = w2;
     1038      changed = 1;
     1039    }
     1040
     1041  if (gr->height != h2)
     1042    {
     1043      gr->height = h2;
     1044      changed = 1;
     1045    }
     1046
     1047  gr->wraparound = wraparound;
     1048
     1049  if (changed)
     1050    {
     1051      if ((w == 0) || (h == 0))
     1052        {
     1053          gr->overlay_autodisabled = 1;
    5941054        }
    595         gr->mode=mode;
    596 #endif
     1055      else
     1056        {
     1057          gr->overlay_autodisabled = 0;
     1058        }
     1059
     1060      callback_list_call_attr_2 (gr->cbl, attr_resize,
     1061                                 GINT_TO_POINTER (gr->width),
     1062                                 GINT_TO_POINTER (gr->height));
     1063    }
    5971064}
    5981065
    599 #if 0
    600 /* Events */
     1066static struct graphics_methods graphics_methods = {
     1067  graphics_destroy,
     1068  draw_mode,
     1069  draw_lines,
     1070  draw_polygon,
     1071  draw_rectangle,
     1072  draw_circle,
     1073  draw_text,
     1074  draw_image,
     1075  draw_image_warp,
     1076  draw_restore,
     1077  draw_drag,
     1078  NULL,
     1079  gc_new,
     1080  background_gc,
     1081  overlay_new,
     1082  image_new,
     1083  get_data,
     1084  image_free,
     1085  NULL,
     1086  overlay_disable,
     1087  overlay_resize,
     1088};
     1089
     1090static struct graphics_priv *
     1091graphics_opengl_new_helper (struct graphics_methods *meth)
     1092{
     1093  struct font_priv *(*font_freetype_new) (void *meth);
     1094  font_freetype_new = plugin_get_font_type ("freetype");
     1095
     1096  if (!font_freetype_new)
     1097    {
     1098      return NULL;
     1099    }
     1100
     1101  struct graphics_priv *this = g_new0 (struct graphics_priv, 1);
    6011102
    602 static gint
    603 configure(GtkWidget * widget, GdkEventConfigure * event, gpointer user_data)
     1103  font_freetype_new (&this->freetype_methods);
     1104  *meth = graphics_methods;
     1105
     1106  meth->font_new =
     1107    (struct graphics_font_priv *
     1108     (*)(struct graphics_priv *, struct graphics_font_methods *, char *, int,
     1109         int)) this->freetype_methods.font_new;
     1110  meth->get_text_bbox = this->freetype_methods.get_text_bbox;
     1111
     1112  return this;
     1113}
     1114
     1115static struct graphics_priv *
     1116overlay_new (struct graphics_priv *gr, struct graphics_methods *meth,
     1117             struct point *p, int w, int h, int alpha, int wraparound)
    6041118{
    605         struct graphics_priv *gra=user_data;
    606         if (! gra->visible)
    607                 return TRUE;
    608         if (gra->drawable != NULL) {
    609                 gdk_pixmap_unref(gra->drawable);
    610         }
    611         gra->width=widget->allocation.width;
    612         gra->height=widget->allocation.height;
    613         gra->drawable = gdk_pixmap_new(widget->window, gra->width, gra->height, -1);
    614         if (gra->resize_callback)
    615                 (*gra->resize_callback)(gra->resize_callback_data, gra->width, gra->height);
    616         return TRUE;
    617 }
    618 
    619 static gint
    620 expose(GtkWidget * widget, GdkEventExpose * event, gpointer user_data)
    621 {
    622         struct graphics_priv *gra=user_data;
    623 
    624         gra->visible=1;
    625         if (! gra->drawable)
    626                 configure(widget, NULL, user_data);
    627         gdk_draw_pixmap(widget->window, widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
    628                         gra->drawable, event->area.x, event->area.y,
    629                         event->area.x, event->area.y,
    630                         event->area.width, event->area.height);
    631 
    632         return FALSE;
    633 }
    634 
    635 #if 0
    636 static gint
    637 button_timeout(gpointer user_data)
    638 {
    639 #if 0
    640         struct container *co=user_data;
    641         int x=co->gra->gra->button_event.x;
    642         int y=co->gra->gra->button_event.y;
    643         int button=co->gra->gra->button_event.button;
     1119  int w2, h2;
     1120  struct graphics_priv *this = graphics_opengl_new_helper (meth);
     1121  this->p = *p;
     1122  this->width = w;
     1123  this->height = h;
     1124  this->parent = gr;
     1125
     1126  /* If either height or width is 0, we set it to 1 to avoid warnings, and
     1127   * disable the overlay. */
     1128  if (h == 0)
     1129    {
     1130      h2 = 1;
     1131    }
     1132  else
     1133    {
     1134      h2 = h;
     1135    }
     1136
     1137  if (w == 0)
     1138    {
     1139      w2 = 1;
     1140    }
     1141  else
     1142    {
     1143      w2 = w;
     1144    }
    6441145
    645         co->gra->gra->button_timeout=0;
    646         popup(co, x, y, button);
     1146  if ((w == 0) || (h == 0))
     1147    {
     1148      this->overlay_autodisabled = 1;
     1149    }
     1150  else
     1151    {
     1152      this->overlay_autodisabled = 0;
     1153    }
     1154  this->overlay_enabled = 1;
     1155  this->overlay_autodisabled = 0;
     1156
     1157  this->next = gr->overlays;
     1158  gr->overlays = this;
     1159  this->DLid = glGenLists (1);
     1160  return this;
     1161}
    6471162
    648         return FALSE;
     1163
     1164static void
     1165click_notify (int button, int state, int x, int y)
     1166{
     1167  //printf("mouse_queue_add %d\n",mouse_event_queue_end_idx);
     1168  mouse_queue[mouse_event_queue_end_idx%mouse_event_queue_size].button = button;
     1169  mouse_queue[mouse_event_queue_end_idx%mouse_event_queue_size].state = state;
     1170#ifdef MIRRORED_VIEW
     1171  mouse_queue[mouse_event_queue_end_idx%mouse_event_queue_size].x = graphics_priv_root->width-x;
     1172#else
     1173  mouse_queue[mouse_event_queue_end_idx%mouse_event_queue_size].x = x;
    6491174#endif
     1175  mouse_queue[mouse_event_queue_end_idx%mouse_event_queue_size].y = y;
     1176  ++mouse_event_queue_end_idx;
    6501177}
     1178
     1179static void
     1180motion_notify (int x, int y)
     1181{
     1182  struct point p;
     1183#ifdef MIRRORED_VIEW
     1184  p.x = graphics_priv_root->width-x;
     1185#else
     1186  p.x = x;
    6511187#endif
     1188  p.y = y;
     1189  callback_list_call_attr_1 (graphics_priv_root->cbl, attr_motion,
     1190                             (void *) &p);
     1191  return;
     1192}
    6521193
    653 static gint
    654 button_press(GtkWidget * widget, GdkEventButton * event, gpointer user_data)
     1194static gboolean
     1195graphics_opengl_idle (void *data)
    6551196{
    656         struct graphics_priv *this=user_data;
    657         struct point p;
     1197  static int opengl_init_ok = 0;
     1198  if (!opengl_init_ok)
     1199    {
     1200      callback_list_call_attr_2 (graphics_priv_root->cbl, attr_resize,
     1201                                 GINT_TO_POINTER (graphics_priv_root->width),
     1202                                 GINT_TO_POINTER
     1203                                 (graphics_priv_root->height));
     1204      opengl_init_ok = 1;
     1205    }
     1206  else
     1207    {
     1208      glutMainLoopEvent ();
     1209      handle_mouse_queue();
     1210      if(graphics_priv_root->force_redraw) {
     1211        //redraw_screen(graphics_priv_root);
     1212      }
     1213    }
     1214  return TRUE;
     1215}
    6581216
    659         p.x=event->x;
    660         p.y=event->y;
    661         if (this->button_callback)
    662                 (*this->button_callback)(this->button_callback_data, 1, event->button, &p);
    663         return FALSE;
    664 }
    665 
    666 static gint
    667 button_release(GtkWidget * widget, GdkEventButton * event, gpointer user_data)
    668 {
    669         struct graphics_priv *this=user_data;
    670         struct point p;
    671 
    672         p.x=event->x;
    673         p.y=event->y;
    674         if (this->button_callback)
    675                 (*this->button_callback)(this->button_callback_data, 0, event->button, &p);
    676         return FALSE;
    677 }
    678 
    679 static gint
    680 scroll(GtkWidget * widget, GdkEventScroll * event, gpointer user_data)
    681 {
    682         struct graphics_priv *this=user_data;
    683         struct point p;
    684         int button;
    685 
    686         p.x=event->x;
    687         p.y=event->y;
    688         if (this->button_callback) {
    689                 switch (event->direction) {
    690                 case GDK_SCROLL_UP:
    691                         button=4;
    692                         break;
    693                 case GDK_SCROLL_DOWN:
    694                         button=5;
    695                         break;
    696                 default:
    697                         button=-1;
    698                         break;
    699                 }
    700                 if (button != -1) {
    701                         (*this->button_callback)(this->button_callback_data, 1, button, &p);
    702                         (*this->button_callback)(this->button_callback_data, 0, button, &p);
    703                 }
    704         }
    705         return FALSE;
     1217static void
     1218ProcessNormalKeys (unsigned char key_in, int x, int y)
     1219{
     1220  int key = 0;
     1221  char keybuf[2];
     1222
     1223  switch (key_in)
     1224    {
     1225    case 13:
     1226      key = NAVIT_KEY_RETURN;
     1227      break;
     1228    default:
     1229      key = key_in;
     1230      break;
     1231    }
     1232  keybuf[0] = key;
     1233  keybuf[1] = '\0';
     1234  graphics_priv_root->force_redraw = 1;
     1235  callback_list_call_attr_1 (graphics_priv_root->cbl, attr_keypress,
     1236                             (void *) keybuf);
    7061237}
    7071238
    708 static gint
    709 motion_notify(GtkWidget * widget, GdkEventMotion * event, gpointer user_data)
     1239static void
     1240ProcessSpecialKeys (int key_in, int x, int y)
    7101241{
    711         struct graphics_priv *this=user_data;
    712         struct point p;
     1242  int key = 0;
     1243  char keybuf[2];
    7131244
    714         p.x=event->x;
    715         p.y=event->y;
    716         if (this->motion_callback)
    717                 (*this->motion_callback)(this->motion_callback_data, &p);
    718         return FALSE;
     1245  switch (key_in)
     1246    {
     1247    case 102:
     1248      key = NAVIT_KEY_RIGHT;
     1249      break;
     1250    case 100:
     1251      key = NAVIT_KEY_LEFT;
     1252      break;
     1253    case 103:
     1254      key = NAVIT_KEY_DOWN;
     1255      break;
     1256    case 101:
     1257      key = NAVIT_KEY_UP;
     1258      break;
     1259    case 104:
     1260      key = NAVIT_KEY_ZOOM_OUT;
     1261      break;
     1262    case 105:
     1263      key = NAVIT_KEY_ZOOM_IN;
     1264      break;
     1265    default:
     1266      break;
     1267    }                           //switch
     1268
     1269  graphics_priv_root->force_redraw = 1;
     1270  keybuf[0] = key;
     1271  keybuf[1] = '\0';
     1272  callback_list_call_attr_1 (graphics_priv_root->cbl, attr_keypress,
     1273                             (void *) keybuf);
    7191274}
    7201275
     1276void
     1277resize_callback (int w, int h)
     1278{
     1279  glViewport (0, 0, w, h);
     1280  glMatrixMode (GL_PROJECTION);
     1281  glLoadIdentity ();
     1282#ifdef MIRRORED_VIEW
     1283  gluOrtho2D ( w, 0, h, 0.0); //mirrored mode
     1284#else
     1285  gluOrtho2D ( 0, w, h, 0.0);
    7211286#endif
    7221287
     1288  graphics_priv_root->width = w;
     1289  graphics_priv_root->height = h;
     1290
     1291  callback_list_call_attr_2 (graphics_priv_root->cbl, attr_resize,
     1292                             GINT_TO_POINTER (w), GINT_TO_POINTER (h));
     1293}
     1294
     1295void
     1296display (void)
     1297{
     1298  graphics_priv_root->force_redraw = 1;
     1299  redraw_screen(graphics_priv_root);
     1300  resize_callback (graphics_priv_root->width, graphics_priv_root->height);
     1301}
     1302
    7231303
    7241304static struct graphics_priv *
    725 overlay_new(struct graphics_priv *gr, struct graphics_methods *meth, struct point *p, int w, int h)
     1305graphics_opengl_new (struct navit *nav, struct graphics_methods *meth,
     1306                     struct attr **attrs, struct callback_list *cbl)
    7261307{
    727 #if 0
    728         struct graphics_priv *this=graphics_gtk_drawing_area_new_helper(meth);
    729         this->drawable=gdk_pixmap_new(gr->widget->window, w, h, -1);
    730         this->colormap=gr->colormap;
    731         this->widget=gr->widget;
    732         this->p=*p;
    733         this->width=w;
    734         this->height=h;
    735         this->parent=gr;
    736         this->background=gdk_pixmap_new(gr->widget->window, w, h, -1);
    737         this->next=gr->overlays;
    738         gr->overlays=this;
    739         return this;
    740 #endif
    741         return NULL;
     1308  struct attr *attr;
     1309
     1310  if (!event_request_system ("glib", "graphics_opengl_new"))
     1311    return NULL;
     1312
     1313  struct graphics_priv *this = graphics_opengl_new_helper (meth);
     1314  graphics_priv_root = this;
     1315
     1316  this->nav = nav;
     1317  this->parent = NULL;
     1318  this->overlay_enabled = 1;
     1319
     1320  this->width = SCREEN_WIDTH;
     1321  if ((attr = attr_search (attrs, NULL, attr_w)))
     1322    this->width = attr->u.num;
     1323  this->height = SCREEN_HEIGHT;
     1324  if ((attr = attr_search (attrs, NULL, attr_h)))
     1325    this->height = attr->u.num;
     1326  this->timeout = 100;
     1327  if ((attr = attr_search (attrs, NULL, attr_timeout)))
     1328    this->timeout = attr->u.num;
     1329  this->delay = 0;
     1330  if ((attr = attr_search (attrs, NULL, attr_delay)))
     1331    this->delay = attr->u.num;
     1332  this->cbl = cbl;
     1333
     1334  char *cmdline = "";
     1335  int argc = 0;
     1336  glutInit (&argc, &cmdline);
     1337  glutInitDisplayMode (GLUT_DOUBLE | GLUT_RGBA);
     1338
     1339  glutInitWindowSize (this->width, this->height);
     1340  glutInitWindowPosition (0, 0);
     1341  glutCreateWindow ("Navit opengl window");
     1342
     1343  glutDisplayFunc (display);
     1344  glutReshapeFunc (resize_callback);
     1345  resize_callback (this->width, this->height);
     1346
     1347  graphics_priv_root->cbl = cbl;
     1348  graphics_priv_root->width = this->width;
     1349  graphics_priv_root->height = this->height;
     1350
     1351  glutMotionFunc (motion_notify);
     1352  glutPassiveMotionFunc (motion_notify);
     1353  glutMouseFunc (click_notify);
     1354  glutKeyboardFunc (ProcessNormalKeys);
     1355  glutSpecialFunc (ProcessSpecialKeys);
     1356
     1357  this->DLid = glGenLists (1);
     1358
     1359  g_timeout_add (G_PRIORITY_DEFAULT + 10, graphics_opengl_idle, NULL);
     1360  /*this will only refresh screen in map(overlay enabled) mode*/
     1361  g_timeout_add (G_PRIORITY_DEFAULT + 1000, redraw_filter, this);
     1362
     1363  return this;
    7421364}
    7431365
    744 static void *
    745 get_data(struct graphics_priv *this, char *type)
     1366
     1367static void
     1368event_opengl_main_loop_run (void)
    7461369{
    747         if (strcmp(type,"opengl_displaylist"))
    748                 return NULL;
    749 #if 0
    750         dbg(1,"Creating the DL from driver\n");
    751         this->DLid = glGenLists(1);
    752 #endif
    753         return &this->DLid;
     1370  dbg (0, "enter\n");
    7541371}
    7551372
    7561373static void
    757 register_resize_callback(struct graphics_priv *this, void (*callback)(void *data, int w, int h), void *data)
     1374event_opengl_main_loop_quit (void)
     1375{
     1376  dbg (0, "enter\n");
     1377}
     1378
     1379static struct event_watch *
     1380event_opengl_add_watch (void *h, enum event_watch_cond cond,
     1381                        struct callback *cb)
    7581382{
    759         this->resize_callback=callback;
    760         this->resize_callback_data=data;
     1383  dbg (0, "enter\n");
     1384  return NULL;
    7611385}
    7621386
    7631387static void
    764 register_motion_callback(struct graphics_priv *this, void (*callback)(void *data, struct point *p), void *data)
     1388event_opengl_remove_watch (struct event_watch *ev)
    7651389{
    766         this->motion_callback=callback;
    767         this->motion_callback_data=data;
     1390  dbg (0, "enter\n");
     1391}
     1392
     1393
     1394static struct event_timeout *
     1395event_opengl_add_timeout (int timeout, int multi, struct callback *cb)
     1396{
     1397  dbg (0, "enter\n");
     1398  return NULL;
    7681399}
    7691400
    7701401static void
    771 register_button_callback(struct graphics_priv *this, void (*callback)(void *data, int press, int button, struct point *p), void *data)
     1402event_opengl_remove_timeout (struct event_timeout *to)
    7721403{
    773         this->button_callback=callback;
    774         this->button_callback_data=data;
     1404  dbg (0, "enter\n");
    7751405}
    7761406
    777 static struct graphics_methods graphics_methods = {
    778         graphics_destroy,
    779         draw_mode,
    780         draw_lines,
    781         draw_polygon,
    782         draw_rectangle,
    783         draw_circle,
    784         draw_text,
    785         draw_image,
    786 #ifdef HAVE_IMLIB2
    787         draw_image_warp,
    788 #else
    789         NULL,
    790 #endif
    791         draw_restore,
    792         font_new,
    793         gc_new,
    794         background_gc,
    795         overlay_new,
    796         image_new,
    797         get_data,
    798         register_resize_callback,
    799         register_button_callback,
    800         register_motion_callback,
    801         NULL,   // image_free
     1407
     1408static struct event_idle *
     1409event_opengl_add_idle (int priority, struct callback *cb)
     1410{
     1411  dbg (0, "enter\n");
     1412  return NULL;
     1413}
     1414
     1415static void
     1416event_opengl_remove_idle (struct event_idle *ev)
     1417{
     1418  dbg (0, "enter\n");
     1419}
     1420
     1421static void
     1422event_opengl_call_callback (struct callback_list *cb)
     1423{
     1424  dbg (0, "enter\n");
     1425}
     1426
     1427static struct event_methods event_opengl_methods = {
     1428  event_opengl_main_loop_run,
     1429  event_opengl_main_loop_quit,
     1430  event_opengl_add_watch,
     1431  event_opengl_remove_watch,
     1432  event_opengl_add_timeout,
     1433  event_opengl_remove_timeout,
     1434  event_opengl_add_idle,
     1435  event_opengl_remove_idle,
     1436  event_opengl_call_callback,
    8021437};
    8031438
    804 static struct graphics_priv *
    805 graphics_opengl_new(struct navit *nav, struct graphics_methods *meth, struct attr **attrs)
     1439static struct event_priv *
     1440event_opengl_new (struct event_methods *meth)
    8061441{
    807         struct graphics_priv *this=g_new0(struct graphics_priv,1);
    808         *meth=graphics_methods;
    809        
    810 //      GtkWidget *draw;
    811 
    812 //      draw=gtk_drawnig_area_new();
    813        
    814 
    815         // Initialize the fonts
    816         int ctx = 0;
    817         int font = 0;
    818         ctx = glcGenContext();
    819         glcContext(ctx);
    820         font = glcNewFontFromFamily(glcGenFontID(), "Verdana");
    821         glcFont(font);
    822         glcStringType(GLC_UTF8_QSO);
    823 //      glcFontFace(font, "Italic");
    824 
    825 
    826 /*
    827         this->widget=draw;
    828        
    829         this->colormap=gdk_colormap_new(gdk_visual_get_system(),FALSE);
    830         gtk_widget_set_events(draw, GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_POINTER_MOTION_MASK|GDK_KEY_PRESS_MASK);
    831         g_signal_connect(G_OBJECT(draw), "expose_event", G_CALLBACK(expose), this);
    832         g_signal_connect(G_OBJECT(draw), "configure_event", G_CALLBACK(configure), this);
    833 #if 0
    834         g_signal_connect(G_OBJECT(draw), "realize_event", G_CALLBACK(realize), co);
    835 #endif
    836         g_signal_connect(G_OBJECT(draw), "button_press_event", G_CALLBACK(button_press), this);
    837         g_signal_connect(G_OBJECT(draw), "button_release_event", G_CALLBACK(button_release), this);
    838         g_signal_connect(G_OBJECT(draw), "scroll_event", G_CALLBACK(scroll), this);
    839         g_signal_connect(G_OBJECT(draw), "motion_notify_event", G_CALLBACK(motion_notify), this);
    840         */
    841         return this;
     1442  *meth = event_opengl_methods;
     1443  return NULL;
    8421444}
    8431445
    8441446void
    845 plugin_init(void)
     1447plugin_init (void)
    8461448{
    847         plugin_register_graphics_type("opengl", graphics_opengl_new);
     1449  plugin_register_graphics_type ("opengl", graphics_opengl_new);
     1450  plugin_register_event_type ("opengl", event_opengl_new);
    8481451}