src/xwidget.c

   1 #include <config.h>
   2 #ifdef HAVE_XWIDGETS
   3
   4 #include <signal.h>
   5
   6 #include <stdio.h>
   7 #include <setjmp.h>
   8 #ifdef HAVE_X_WINDOWS
   9
  10 #include "lisp.h"
  11 #include "blockinput.h"
  12 #include "syssignal.h"
  13
  14 #include "xterm.h"
  15 #include <X11/cursorfont.h>
  16
  17 #ifndef makedev
  18 #include <sys/types.h>
  19 #endif /* makedev */
  20
  21 #ifdef BSD_SYSTEM
  22 #include <sys/ioctl.h>
  23 #endif /* ! defined (BSD_SYSTEM) */
  24
  25 #include "systime.h"
  26
  27 #ifndef INCLUDED_FCNTL
  28 #include <fcntl.h>
  29 #endif
  30 #include <ctype.h>
  31 #include <errno.h>
  32 #include <setjmp.h>
  33 #include <sys/stat.h>
  34
  35 #include "charset.h"
  36 #include "character.h"
  37 #include "coding.h"
  38 #include "ccl.h"
  39 #include "frame.h"
  40 #include "dispextern.h"
  41 #include "fontset.h"
  42 #include "termhooks.h"
  43 #include "termopts.h"
  44 #include "termchar.h"
  45 #include "emacs-icon.h"
  46 #include "disptab.h"
  47 #include "buffer.h"
  48 #include "window.h"
  49 #include "keyboard.h"
  50 #include "intervals.h"
  51 #include "process.h"
  52 #include "atimer.h"
  53 #include "keymap.h"
  54
  55
  56 #ifdef USE_X_TOOLKIT
  57 #include <X11/Shell.h>
  58 #endif
  59 #include <X11/extensions/Xcomposite.h>
  60 #include <X11/extensions/Xrender.h>
  61 #include <cairo.h>
  62 #ifdef HAVE_SYS_TIME_H
  63 #include <sys/time.h>
  64 #endif
  65 #ifdef HAVE_UNISTD_H
  66 #include <unistd.h>
  67 #endif
  68
  69 #include "gtkutil.h"
  70 #include "font.h"
  71 #endif  /* HAVE_X_WINDOWS */
  72
  73 #include <gtk/gtk.h>
  74 #include <gdk/gdk.h>
  75
  76 #ifdef HAVE_GTK3
  77 //for gtk3; sockets and plugs
  78 #include <gtk/gtkx.h>
  79 #include "emacsgtkfixed.h"
  80 #endif
  81
  82 #include <wchar.h>
  83
  84 #ifdef HAVE_WEBKIT_OSR
  85 #include <webkit/webkitwebview.h>
  86 #include <webkit/webkitwebplugindatabase.h>
  87 #include <webkit/webkitwebplugin.h>
  88 #include <webkit/webkitglobals.h>
  89 #include <webkit/webkitwebnavigationaction.h>
  90 #include <webkit/webkitdownload.h>
  91 #include <webkit/webkitwebpolicydecision.h>
  92 #endif
  93
  94 //for GIR
  95 #include <girepository.h>
  96
  97 #include "xwidget.h"
  98
  99 //TODO embryo of lisp allocators for xwidgets
 100 //TODO xwidget* should be Lisp_xwidget*
 101 struct xwidget*
 102 allocate_xwidget (void)
 103 {
 104   return ALLOCATE_PSEUDOVECTOR (struct xwidget, height, PVEC_XWIDGET);
 105 }
 106
 107 //TODO xwidget_view* should be Lisp_xwidget_view*
 108 struct xwidget_view*
 109 allocate_xwidget_view (void)
 110 {
 111   return ALLOCATE_PSEUDOVECTOR (struct xwidget_view, redisplayed, PVEC_XWIDGET_VIEW);
 112 }
 113 #define XSETXWIDGET(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_XWIDGET))
 114 #define XSETXWIDGET_VIEW(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_XWIDGET_VIEW))
 115
 116 Lisp_Object Qxwidget;
 117 Lisp_Object QCxwidget;
 118 Lisp_Object QCtitle;
 119 Lisp_Object Qxwidget_set_keyboard_grab;
 120 Lisp_Object Qxwidget_embed_steal_window;
 121 Lisp_Object Qxwidget_info;
 122 Lisp_Object Qxwidget_resize;
 123 Lisp_Object Qxwidget_send_keyboard_event;
 124 Lisp_Object QCxwgir_class;
 125 Lisp_Object Qbutton, Qtoggle, Qslider, Qsocket, Qsocket_osr, Qcairo, Qxwgir,
 126   Qwebkit_osr, QCplist;
 127 Lisp_Object Qxwidgetp, Qxwidget_view_p;
 128
 129
 130 extern Lisp_Object  QCtype;
 131 extern Lisp_Object QCwidth, QCheight;
 132
 133 struct xwidget_view* xwidget_view_lookup(struct xwidget* xw,     struct window *w);
 134 Lisp_Object xwidget_spec_value ( Lisp_Object spec, Lisp_Object  key,  int *found);
 135 gboolean offscreen_damage_event (GtkWidget *widget, GdkEvent *event, gpointer data);
 136 void     webkit_osr_document_load_finished_callback (WebKitWebView  *webkitwebview,
 137                                                      WebKitWebFrame *arg1,
 138                                                      gpointer        user_data);
 139 gboolean     webkit_osr_download_callback (WebKitWebView  *webkitwebview,
 140                                        WebKitDownload *arg1,
 141                                        gpointer        data);
 142
 143 gboolean  webkit_osr_mime_type_policy_typedecision_requested_callback(WebKitWebView           *webView,
 144                                                                       WebKitWebFrame          *frame,
 145                                                                       WebKitNetworkRequest    *request,
 146                                                                       gchar                   *mimetype,
 147                                                                       WebKitWebPolicyDecision *policy_decision,
 148                                                                       gpointer                 user_data);
 149
 150 gboolean webkit_osr_new_window_policy_decision_requested_callback(WebKitWebView             *webView,
 151                                                                   WebKitWebFrame            *frame,
 152                                                                   WebKitNetworkRequest      *request,
 153                                                                   WebKitWebNavigationAction *navigation_action,
 154                                                                   WebKitWebPolicyDecision   *policy_decision,
 155                                                                   gpointer                   user_data);
 156
 157
 158 gboolean webkit_osr_navigation_policy_decision_requested_callback(WebKitWebView             *webView,
 159                                                         WebKitWebFrame            *frame,
 160                                                         WebKitNetworkRequest      *request,
 161                                                         WebKitWebNavigationAction *navigation_action,
 162                                                         WebKitWebPolicyDecision   *policy_decision,
 163                                                                   gpointer                   user_data);
 164
 165 GtkWidget* xwgir_create(char* class, char* namespace);
 166 static void
 167 send_xembed_ready_event (struct xwidget* xw, int xembedid);
 168 DEFUN ("make-xwidget", Fmake_xwidget, Smake_xwidget, 7, 8, 0,
 169          doc: /* Make an xwidget from BEG to END of TYPE.
 170
 171 If BUFFER is nil it uses the current buffer. If BUFFER is a string and
 172 no such buffer exists, it is created.
 173
 174 TYPE is a symbol which can take one of the following values:
 175 - Button
 176 - ToggleButton
 177 - slider
 178 - socket
 179 - socket-osr
 180 - cairo
 181 */
 182          )
 183   (Lisp_Object beg, Lisp_Object end,
 184    Lisp_Object type,
 185    Lisp_Object title,
 186    Lisp_Object width, Lisp_Object height,
 187    Lisp_Object data,
 188    Lisp_Object buffer)
 189 {
 190   //should work a bit like "make-button"(make-button BEG END &rest PROPERTIES)
 191   // arg "type" and fwd should be keyword args eventually
 192   //(make-xwidget 3 3 'button "oei" 31 31 nil)
 193   //(xwidget-info (car xwidget-list))
 194   struct xwidget* xw = allocate_xwidget();
 195   Lisp_Object val;
 196   xw->type = type;
 197   xw->title = title;
 198   if (NILP (buffer))
 199       buffer = Fcurrent_buffer(); // no need to gcpro because Fcurrent_buffer doesn't call Feval/eval_sub.
 200   else
 201       buffer = Fget_buffer_create (buffer);
 202   xw->buffer = buffer;
 203
 204   xw->height = XFASTINT(height);
 205   xw->width = XFASTINT(width);
 206   xw->kill_without_query = 0;
 207   XSETXWIDGET (val, xw); // set the vectorlike_header of VAL with the correct value
 208   Vxwidget_list = Fcons (val, Vxwidget_list);
 209   xw->widgetwindow_osr = NULL;
 210   xw->widget_osr = NULL;
 211   xw->plist = Qnil;
 212
 213
 214 #ifdef HAVE_WEBKIT_OSR
 215   /* DIY mvc. widget is rendered offscreen,
 216      later bitmap copied to the views.
 217    */
 218   if (EQ(xw->type, Qwebkit_osr)||
 219       EQ(xw->type, Qsocket_osr)||
 220       (!NILP (Fget(xw->type, QCxwgir_class)))) {
 221       block_input();
 222       xw->widgetwindow_osr = gtk_offscreen_window_new ();
 223       gtk_window_resize(GTK_WINDOW(xw->widgetwindow_osr), xw->width, xw->height);
 224
 225       if (EQ(xw->type, Qwebkit_osr))
 226           xw->widget_osr = webkit_web_view_new();
 227       if(EQ(xw->type, Qsocket_osr))
 228           xw->widget_osr = gtk_socket_new();
 229       if(!NILP (Fget(xw->type, QCxwgir_class)))
 230           xw->widget_osr = xwgir_create(SDATA(Fcar(Fcdr(Fget(xw->type, QCxwgir_class)))),
 231                                         SDATA(Fcar(Fget(xw->type, QCxwgir_class))));
 232
 233       gtk_widget_set_size_request (GTK_WIDGET (xw->widget_osr), xw->width, xw->height);
 234       gtk_container_add (GTK_CONTAINER (xw->widgetwindow_osr), xw->widget_osr);
 235
 236       gtk_widget_show (xw->widget_osr);
 237       gtk_widget_show (xw->widgetwindow_osr);
 238
 239       /* store some xwidget data in the gtk widgets for convenient retrieval in the event handlers. */
 240       g_object_set_data (G_OBJECT (xw->widget_osr), XG_XWIDGET, (gpointer) (xw));
 241       g_object_set_data (G_OBJECT (xw->widgetwindow_osr), XG_XWIDGET, (gpointer) (xw));
 242
 243       /* signals */
 244       if (EQ(xw->type, Qwebkit_osr)) {
 245           g_signal_connect (G_OBJECT (xw->widget_osr),
 246                             "document-load-finished",
 247                             G_CALLBACK (webkit_osr_document_load_finished_callback),
 248                             xw);
 249
 250           g_signal_connect (G_OBJECT (xw->widget_osr),
 251                             "download-requested",
 252                             G_CALLBACK (webkit_osr_download_callback),
 253                             xw);
 254
 255           g_signal_connect (G_OBJECT (xw->widget_osr),
 256                             "mime-type-policy-decision-requested",
 257                             G_CALLBACK (webkit_osr_mime_type_policy_typedecision_requested_callback),
 258                             xw);
 259
 260           g_signal_connect (G_OBJECT (xw->widget_osr),
 261                             "new-window-policy-decision-requested",
 262                             G_CALLBACK (webkit_osr_new_window_policy_decision_requested_callback),
 263                             xw);
 264
 265           g_signal_connect (G_OBJECT (xw->widget_osr),
 266                             "navigation-policy-decision-requested",
 267                             G_CALLBACK (webkit_osr_navigation_policy_decision_requested_callback),
 268                             xw);
 269       }
 270
 271       if (EQ(xw->type, Qsocket_osr)) {
 272           send_xembed_ready_event (xw, gtk_socket_get_id (GTK_SOCKET (xw->widget_osr)));
 273           //gtk_widget_realize(xw->widget);
 274       }
 275
 276
 277       unblock_input();
 278
 279   }
 280 #endif  /* HAVE_WEBKIT_OSR */
 281
 282   return val;
 283 }
 284
 285 DEFUN ("get-buffer-xwidgets", Fget_buffer_xwidgets, Sget_buffer_xwidgets, 1, 1, 0,
 286        doc: /* Return the xwidgets associated with BUFFER.
 287 BUFFER may be a buffer or the name of one.
 288        */
 289        )
 290      (Lisp_Object buffer)
 291 {
 292     Lisp_Object xw, tail, xw_list;
 293
 294     if (NILP (buffer)) return Qnil;
 295     buffer = Fget_buffer (buffer);
 296     if (NILP (buffer)) return Qnil;
 297
 298     xw_list = Qnil;
 299
 300     for (tail = Vxwidget_list; CONSP (tail); tail = XCDR (tail))
 301         {
 302             xw = XCAR (tail);
 303             if (XWIDGETP (xw) && EQ (Fxwidget_buffer (xw), buffer))
 304                 xw_list = Fcons (xw, xw_list);
 305         }
 306     return xw_list;
 307 }
 308
 309 int
 310 xwidget_hidden(struct xwidget_view *xv)
 311 {
 312   return  xv->hidden;
 313 }
 314
 315
 316 static void
 317 buttonclick_handler (GtkWidget * widget, gpointer data)
 318 {
 319   Lisp_Object xwidget_view, xwidget;
 320   XSETXWIDGET_VIEW (xwidget_view, (struct xwidget_view *) data);
 321   xwidget = Fxwidget_view_model (xwidget_view);
 322
 323   struct input_event event;
 324   Lisp_Object frame = Fwindow_frame (Fxwidget_view_window (xwidget_view));
 325   struct frame *f = XFRAME (frame);
 326   printf ("button clicked xw:%d '%s'\n", XXWIDGET (xwidget), XXWIDGET (xwidget)->title);
 327
 328   EVENT_INIT (event);
 329   event.kind = XWIDGET_EVENT;
 330
 331   event.frame_or_window = frame;
 332
 333   event.arg = Qnil;
 334   event.arg = Fcons (xwidget, event.arg);
 335   event.arg = Fcons (intern ("buttonclick"), event.arg);
 336
 337   kbd_buffer_store_event (&event);
 338 }
 339
 340
 341 static void
 342 send_xembed_ready_event (struct xwidget* xw, int xembedid)
 343 {
 344   Lisp_Object xw_lo;
 345   XSETXWIDGET(xw_lo, xw);
 346   struct input_event event;
 347   EVENT_INIT (event);
 348   event.kind = XWIDGET_EVENT;
 349   event.frame_or_window = Qnil; //frame; //how to get the frame here? //TODO i store it in the xwidget now
 350
 351   event.arg = Qnil;
 352   event.arg = Fcons (make_number (xembedid), event.arg);
 353   event.arg = Fcons (xw_lo, event.arg);
 354   event.arg = Fcons (intern ("xembed-ready"), event.arg);
 355
 356
 357   kbd_buffer_store_event (&event);
 358
 359 }
 360
 361 void
 362 xwidget_show_view (struct xwidget_view *xv)
 363 {
 364   xv->hidden = 0;
 365   gtk_widget_show(xv->widgetwindow);
 366   gtk_fixed_move (GTK_FIXED (xv->emacswindow), xv->widgetwindow,  xv->x  + xv->clip_left, xv->y + xv->clip_top); //TODO refactor
 367 }
 368
 369
 370 /* hide an xvidget view */
 371 void
 372 xwidget_hide_view (struct xwidget_view *xv)
 373 {
 374   xv->hidden = 1;
 375   //gtk_widget_hide(xw->widgetwindow);
 376   gtk_fixed_move (GTK_FIXED (xv->emacswindow), xv->widgetwindow,
 377                   10000, 10000);
 378 }
 379
 380
 381 void
 382 xwidget_plug_added(GtkSocket *socket,
 383                    gpointer   user_data)
 384 {
 385   //hmm this doesnt seem to get called for foreign windows
 386   printf("xwidget_plug_added\n");
 387 }
 388
 389 gboolean
 390 xwidget_plug_removed(GtkSocket *socket,
 391                      gpointer   user_data)
 392 {
 393   printf("xwidget_plug_removed\n");
 394   return TRUE; /* dont run the default handler because that kills the socket and we want to reuse it*/
 395 }
 396
 397
 398 void
 399 xwidget_slider_changed (GtkRange *range,
 400                         gpointer  user_data)
 401 {
 402   //slider value changed. change value of siblings
 403   //correspondingly. but remember that changing value will again
 404   //trigger signal
 405
 406   //TODO MVC view storage wont be an array futureish so the loop needs to change eventually
 407   //TODO MVC it would be nice if this code could be reusable but, alas, C is not a functional language
 408   //issues are:
 409   // - the type of the controllers value (double, boolean etc)
 410   // - the getter and setter (but they can be func pointers)
 411   // a behemoth macro is always an option.
 412   double v=gtk_range_get_value(range);
 413   struct xwidget_view* xvp = g_object_get_data (G_OBJECT (range), XG_XWIDGET_VIEW);
 414   struct xwidget_view* xv;
 415
 416   printf("slider changed val:%f\n", v);
 417
 418   for (Lisp_Object tail = Vxwidget_view_list; CONSP (tail); tail = XCDR (tail))
 419     {
 420       if (XWIDGET_VIEW_P (XCAR (tail))) {
 421         xv = XXWIDGET_VIEW (XCAR (tail));
 422         if (EQ (xvp->model, xv->model)) {
 423           //block sibling views signal handlers
 424           g_signal_handler_block(xv->widget, xv->handler_id);
 425
 426           //set values of sibling views and unblock
 427           gtk_range_set_value(GTK_RANGE(xv->widget), v);
 428           g_signal_handler_unblock(xv->widget,xv->handler_id);
 429         }
 430       }
 431     }
 432 }
 433
 434
 435 /* when the off-screen webkit master view changes this signal is called.
 436    it copies the bitmap from the off-screen webkit instance */
 437 gboolean
 438 offscreen_damage_event (GtkWidget *widget, GdkEvent *event, gpointer data)
 439 {
 440   //TODO this is wrong! should just queu a redraw of onscreen widget
 441   gtk_widget_queue_draw (GTK_WIDGET (data));
 442   return FALSE;
 443 }
 444
 445 void
 446 store_xwidget_event_string(struct xwidget* xw, char* eventname, const char* eventstr)
 447 {
 448   //refactor attempt
 449   struct input_event event;
 450   Lisp_Object xwl;
 451   XSETXWIDGET(xwl,xw);
 452   EVENT_INIT (event);
 453   event.kind = XWIDGET_EVENT;
 454   event.frame_or_window = Qnil; //frame; //how to get the frame here? //TODO i store it in the xwidget now
 455
 456   event.arg = Qnil;
 457   event.arg = Fcons (build_string(eventstr), event.arg);  //string so dont intern
 458   event.arg = Fcons (xwl, event.arg); //TODO
 459   event.arg = Fcons (intern (eventname), event.arg);//interning should be ok
 460   kbd_buffer_store_event (&event);
 461
 462 }
 463
 464 //TODO deprecated, use load-status
 465 void
 466 webkit_osr_document_load_finished_callback (WebKitWebView  *webkitwebview,
 467                                                      WebKitWebFrame *arg1,
 468                                                      gpointer        data)
 469 {
 470   //TODO this event sending code should be refactored
 471   //  struct xwidget *xw = (struct xwidget *) data;
 472   struct xwidget* xw = (struct xwidget*) g_object_get_data (G_OBJECT (webkitwebview), XG_XWIDGET);
 473   printf("webkit finished loading\n");
 474
 475   store_xwidget_event_string(xw,
 476                              "document-load-finished", "");
 477 }
 478
 479 gboolean
 480 webkit_osr_download_callback (WebKitWebView  *webkitwebview,
 481                                        WebKitDownload *arg1,
 482                                        gpointer        data)
 483 {
 484   //TODO this event sending code should be refactored
 485   struct input_event event;
 486   //  struct xwidget *xw = (struct xwidget *) data;
 487   struct xwidget* xw = (struct xwidget*) g_object_get_data (G_OBJECT (webkitwebview), XG_XWIDGET);
 488   printf("download requested %s\n", webkit_download_get_uri (arg1));
 489
 490
 491   printf("webkit finished loading\n");
 492
 493   store_xwidget_event_string(xw, "download-requested", webkit_download_get_uri (arg1));
 494
 495   return FALSE;
 496 }
 497
 498 gboolean
 499 webkit_osr_mime_type_policy_typedecision_requested_callback(WebKitWebView           *webView,
 500                                                             WebKitWebFrame          *frame,
 501                                                             WebKitNetworkRequest    *request,
 502                                                             gchar                   *mimetype,
 503                                                             WebKitWebPolicyDecision *policy_decision,
 504                                                             gpointer                 user_data)
 505 {
 506   printf("mime policy requested\n");
 507   // this function makes webkit send a download signal for all unknown mime types
 508   // TODO defer the decision to lisp, so that its possible to make Emacs handle text mime for instance
 509   if(!webkit_web_view_can_show_mime_type(webView, mimetype)){
 510     webkit_web_policy_decision_download (policy_decision);
 511     return TRUE;
 512   }else{
 513     return FALSE;
 514   }
 515 }
 516
 517
 518 gboolean
 519 webkit_osr_new_window_policy_decision_requested_callback(WebKitWebView             *webView,
 520                                                          WebKitWebFrame            *frame,
 521                                                          WebKitNetworkRequest      *request,
 522                                                          WebKitWebNavigationAction *navigation_action,
 523                                                          WebKitWebPolicyDecision   *policy_decision,
 524                                                          gpointer                   user_data)
 525 {
 526   struct xwidget* xw = (struct xwidget*) g_object_get_data (G_OBJECT (webView), XG_XWIDGET);
 527   printf("webkit_osr_new_window_policy_decision_requested_callback %s\n",
 528          webkit_web_navigation_action_get_original_uri (navigation_action));
 529
 530   store_xwidget_event_string(xw,  "new-window-policy-decision-requested", webkit_web_navigation_action_get_original_uri (navigation_action)
 531                             );
 532   return FALSE;
 533 }
 534
 535 gboolean
 536 webkit_osr_navigation_policy_decision_requested_callback(WebKitWebView             *webView,
 537                                                          WebKitWebFrame            *frame,
 538                                                          WebKitNetworkRequest      *request,
 539                                                          WebKitWebNavigationAction *navigation_action,
 540                                                          WebKitWebPolicyDecision   *policy_decision,
 541                                                          gpointer                   user_data)
 542 {
 543   struct xwidget* xw = (struct xwidget*) g_object_get_data (G_OBJECT (webView), XG_XWIDGET);
 544   printf("webkit_osr_navigation_policy_decision_requested_callback %s\n",
 545          webkit_web_navigation_action_get_original_uri (navigation_action));
 546   store_xwidget_event_string(xw,  "navigation-policy-decision-requested", webkit_web_navigation_action_get_original_uri (navigation_action)
 547                             );
 548   return FALSE;
 549 }
 550
 551 //for gtk3 offscreen rendered widgets
 552 gboolean
 553 xwidget_osr_draw_callback (GtkWidget *widget, cairo_t *cr, gpointer data)
 554 {
 555   struct xwidget* xw = (struct xwidget*) g_object_get_data (G_OBJECT (widget), XG_XWIDGET);
 556   struct xwidget_view* xv = (struct xwidget_view*) g_object_get_data (G_OBJECT (widget), XG_XWIDGET_VIEW);
 557
 558   cairo_rectangle(cr, 0,0, xv->clip_right, xv->clip_bottom);//xw->width, xw->height);
 559   cairo_clip(cr);
 560
 561   gtk_widget_draw (xw->widget_osr, cr);
 562
 563   return FALSE;
 564 }
 565
 566 GtkWidget* xwgir_create_debug;
 567
 568
 569
 570 gboolean
 571 xwidget_osr_event_forward (GtkWidget *widget,
 572                            GdkEvent  *event,
 573                            gpointer   user_data)
 574 {
 575   /* copy events that arrive at the outer widget to the offscreen widget */
 576   struct xwidget* xw = (struct xwidget*) g_object_get_data (G_OBJECT (widget), XG_XWIDGET);
 577   GdkEvent* eventcopy =  gdk_event_copy(event);
 578   //GdkEvent* eventcopy =  gdk_event_new(GDK_BUTTON_PRESS);
 579
 580
 581   //((GdkEventAny*)eventcopy)->window = gtk_widget_get_window(xw->widget_osr);
 582   //eventcopy->any.window = gtk_widget_get_window(GTK_WIDGET (xw->widgetwindow_osr));
 583   //((GdkEventAny*)eventcopy)->window = gtk_widget_get_window(xwgir_create_debug);
 584   eventcopy->any.window = gtk_widget_get_window(xw->widget_osr);//gtk_widget_get_window(xwgir_create_debug);
 585   //eventcopy->any.window = gtk_button_get_event_window(GTK_BUTTON(xw->widget_osr));//gtk_widget_get_window(xwgir_create_debug);
 586   //eventcopy->button.x=200; eventcopy->button.y=200;
 587   //event->button.button = GDK_BUTTON_PRIMARY; //debug
 588
 589   //eventcopy->any.window = xw->widgetwindow_osr;//gtk_widget_get_window(xwgir_create_debug);
 590   /* eventcopy->any.send_event = TRUE; */
 591   /* eventcopy->button.time = GDK_CURRENT_TIME; */
 592   /* eventcopy->button.device =   event->button.device; */
 593
 594
 595   printf("xwidget_osr_event_forward redirect event to window:%d\n",   ((GdkEventAny*)eventcopy)->window);
 596   printf("A type:%d x:%f y:%f \n",   event->type, event->button.x, event->button.y);
 597   printf("B type:%d x:%f y:%f \n",   eventcopy->type, eventcopy->button.x, eventcopy->button.y);
 598     //gtk_button_get_event_window(xwgir_create_debug);
 599   gtk_main_do_event(eventcopy); //TODO this will leak events. they should be deallocated later, perhaps in xwgir_event_callback
 600   //printf("gtk_widget_event:%d\n",gtk_widget_event(xw->widget_osr, eventcopy));
 601   //gdk_event_put(eventcopy);
 602   //gdk_event_queue_append(eventcopy);
 603   //gdk_event_free(eventcopy);
 604   return TRUE; //dont propagate this event furter
 605   //return FALSE; //dont propagate this event furter
 606 }
 607
 608 GIRepository *girepository ;
 609
 610 DEFUN ("xwgir-require-namespace", Fxwgir_require_namespace, Sxwgir_require_namespace, 2,2,0,
 611        doc: /*require a namespace. must be done for all namespaces we want to use, before using other xwgir functions.*/)
 612   (Lisp_Object lnamespace, Lisp_Object lnamespace_version)
 613 {
 614   char* namespace = SDATA(lnamespace);
 615   char* namespace_version = SDATA(lnamespace_version);
 616   GError *error = NULL;
 617
 618   girepository = g_irepository_get_default();
 619   g_irepository_require(girepository, namespace, namespace_version, 0, &error);
 620   if (error) {
 621     g_error("ERROR: %s\n", error->message);
 622     return Qnil;
 623   }
 624   return Qt;
 625 }
 626
 627 GtkWidget* xwgir_create(char* class, char* namespace){
 628   //TODO this is more or less the same as xwgir-call-method, so should be refactored
 629   //create a gtk widget, given its name
 630   //find the constructor
 631   //call it
 632   //also figure out how to pass args
 633
 634   GError *error = NULL;
 635   GIArgument return_value;
 636
 637   GIObjectInfo* obj_info = g_irepository_find_by_name(girepository, namespace, class);
 638   GIFunctionInfo* f_info = g_object_info_find_method (obj_info, "new");
 639   g_function_info_invoke(f_info,
 640                          NULL, 0,
 641                          NULL, 0,
 642                          &return_value,
 643                          NULL);
 644   xwgir_create_debug = return_value.v_pointer;
 645   return return_value.v_pointer;
 646
 647 }
 648
 649 int
 650 xwgir_convert_lisp_to_gir_arg(GIArgument* giarg,
 651                               GIArgInfo* arginfo,
 652                               Lisp_Object lisparg )
 653 {
 654
 655   GITypeTag   tag;
 656   gboolean    is_pointer;
 657   gboolean    is_enum;
 658   tag =  g_type_info_get_tag (g_arg_info_get_type (arginfo));
 659
 660   switch (tag)
 661     {
 662     case GI_TYPE_TAG_BOOLEAN:
 663       giarg->v_boolean = XFASTINT(lisparg);
 664       break;
 665     case GI_TYPE_TAG_INT8:
 666       giarg->v_int8 = XFASTINT(lisparg);
 667       break;
 668     case GI_TYPE_TAG_UINT8:
 669       giarg->v_uint8 = XFASTINT(lisparg);
 670       break;
 671     case GI_TYPE_TAG_INT16:
 672       giarg->v_int16 = XFASTINT(lisparg);
 673       break;
 674     case GI_TYPE_TAG_UINT16:
 675       giarg->v_uint16 = XFASTINT(lisparg);
 676       break;
 677     case GI_TYPE_TAG_INT32:
 678       giarg->v_int32 = XFASTINT(lisparg);
 679       break;
 680     case GI_TYPE_TAG_UINT32:
 681       giarg->v_uint32 = XFASTINT(lisparg);
 682       break;
 683
 684     case GI_TYPE_TAG_INT64:
 685       giarg->v_int64 = XFASTINT(lisparg);
 686       break;
 687     case GI_TYPE_TAG_UINT64:
 688       giarg->v_uint64 = XFASTINT(lisparg);
 689       break;
 690
 691
 692     case GI_TYPE_TAG_FLOAT:
 693       giarg->v_float = XFLOAT_DATA(lisparg);
 694       break;
 695
 696     case GI_TYPE_TAG_DOUBLE:
 697       giarg->v_double = XFLOAT_DATA(lisparg);
 698       break;
 699
 700     case GI_TYPE_TAG_UTF8:
 701     case GI_TYPE_TAG_FILENAME:
 702       //giarg->v_string = SDATA(lisparg);
 703       giarg->v_pointer = SDATA(lisparg);
 704       break;
 705
 706     case GI_TYPE_TAG_ARRAY:
 707     case GI_TYPE_TAG_GLIST:
 708     case GI_TYPE_TAG_GSLIST:
 709     case GI_TYPE_TAG_GHASH:
 710     case GI_TYPE_TAG_ERROR:
 711     case GI_TYPE_TAG_INTERFACE:
 712     case GI_TYPE_TAG_VOID:
 713     case GI_TYPE_TAG_UNICHAR:
 714     case GI_TYPE_TAG_GTYPE:
 715       //?? i dont know how to handle these yet TODO
 716       printf("failed in my lisp to gir arg conversion duties. sob!\n");
 717       return -1;
 718       break;
 719     }
 720   return 0;
 721 }
 722
 723 #if 0
 724 void
 725 refactor_attempt(){
 726   //this methhod should be called from xwgir-xwidget-call-method and from xwgir xwidget construction
 727   char* class = SDATA(Fcar(Fcdr(Fget(xw->type, QCxwgir_class))));
 728
 729   GIObjectInfo* obj_info = g_irepository_find_by_name(girepository, namespace, class);
 730   GIFunctionInfo* f_info = g_object_info_find_method (obj_info, SDATA(method));
 731
 732   //loop over args, convert from lisp to primitive type, given arg introspection data
 733   //TODO g_callable_info_get_n_args(f_info) should match
 734   int argscount = XFASTINT(Flength(arguments));
 735   if(argscount !=  g_callable_info_get_n_args(f_info)){
 736     printf("xwgir call method arg count doesn match! \n");
 737     return Qnil;
 738   }
 739   int i;
 740   for (i = 1; i < argscount + 1; ++i)
 741     {
 742       xwgir_convert_lisp_to_gir_arg(&in_args[i], g_callable_info_get_arg(f_info, i - 1), Fnth(i - 1, arguments));
 743     }
 744
 745   in_args[0].v_pointer = widget;
 746   if(g_function_info_invoke(f_info,
 747                             in_args, argscount + 1,
 748                             NULL, 0,
 749                             &return_value,
 750                             &error)) {
 751     //g_error("ERROR: %s\n", error->message);
 752     printf("invokation error\n");
 753      return Qnil;
 754    }
 755   return Qt;
 756 }
 757 #endif  /* 0 */
 758
 759 DEFUN ("xwgir-xwidget-call-method", Fxwgir_xwidget_call_method,  Sxwgir_xwidget_call_method,       3, 3, 0,
 760        doc:     /* call xwidget object method.*/)
 761   (Lisp_Object xwidget, Lisp_Object method, Lisp_Object arguments)
 762 {
 763   CHECK_XWIDGET (xwidget);
 764   GError *error = NULL;
 765   GIArgument return_value;
 766   GIArgument in_args[20];
 767
 768
 769   struct xwidget* xw;
 770   if (NILP (xwidget)) { printf("ERROR xwidget nil\n"); return Qnil; };
 771   xw = XXWIDGET(xwidget);
 772   if(NULL == xw) printf("ERROR xw is 0\n");
 773   char* namespace = SDATA(Fcar(Fget(xw->type, QCxwgir_class)));
 774   //we need the concrete widget, which happens in 2 ways depending on OSR or not TODO
 775   GtkWidget* widget = NULL;
 776   if(NULL == xw->widget_osr) {
 777     widget = xwidget_view_lookup (xw, XWINDOW(FRAME_SELECTED_WINDOW (SELECTED_FRAME ()))) -> widget;
 778   } else {
 779     widget = xw->widget_osr;
 780   }
 781
 782   //char* class = SDATA(SYMBOL_NAME(xw->type)); //this works but is unflexible
 783   //figure out the class from the widget instead
 784   /* printf("type class: %s %s\n", G_OBJECT_TYPE_NAME(widget), G_OBJECT_CLASS_NAME(G_OBJECT_GET_CLASS(widget))); */
 785   /* char* class = G_OBJECT_TYPE_NAME(widget); //gives "GtkButton"(I want "Button") */
 786   /* class += strlen(namespace);  //TODO check for corresponding api method. but this seems to work. */
 787
 788   char* class = SDATA(Fcar(Fcdr(Fget(xw->type, QCxwgir_class))));
 789
 790   GIObjectInfo* obj_info = g_irepository_find_by_name(girepository, namespace, class);
 791   GIFunctionInfo* f_info = g_object_info_find_method (obj_info, SDATA(method));
 792
 793   //loop over args, convert from lisp to primitive type, given arg introspection data
 794   //TODO g_callable_info_get_n_args(f_info) should match
 795   int argscount = XFASTINT(Flength(arguments));
 796   if(argscount !=  g_callable_info_get_n_args(f_info)){
 797     printf("xwgir call method arg count doesn match! \n");
 798     return Qnil;
 799   }
 800   int i;
 801   Lisp_Object n;
 802   for (i = 1; i < argscount + 1; ++i)
 803     {
 804         XSETFASTINT (n, i - 1);
 805         xwgir_convert_lisp_to_gir_arg(&in_args[i], g_callable_info_get_arg(f_info, i - 1), Fnth(n, arguments));
 806     }
 807
 808   in_args[0].v_pointer = widget;
 809   if(g_function_info_invoke(f_info,
 810                             in_args, argscount + 1,
 811                             NULL, 0,
 812                             &return_value,
 813                             &error)) {
 814     //g_error("ERROR: %s\n", error->message);
 815     printf("invokation error\n");
 816      return Qnil;
 817    }
 818   return Qt;
 819 }
 820
 821  void
 822 to_child (GtkWidget *bin,
 823           double         widget_x,
 824           double         widget_y,
 825           double        *x_out,
 826           double        *y_out)
 827 {
 828   *x_out = widget_x;
 829   *y_out = widget_y;
 830 }
 831
 832
 833 GdkWindow *
 834 offscreen_pick_embedded_child (GdkWindow *window,
 835                                double x,
 836                                double y,
 837                                gpointer *data)
 838 {
 839   //in this simple case we assume the window contains a single widget. easy.
 840   //but then we get the problem that the widget cant be embedded in several windows
 841   return gtk_widget_get_window (GTK_WIDGET (data));
 842 }
 843
 844 void
 845 offscreen_to_embedder (GdkWindow *window,
 846                        gdouble offscreen_x,
 847                        gdouble offscreen_y,
 848                        gpointer embedder_x,
 849                        gpointer embedder_y,
 850                        gpointer data)
 851 {
 852   * (gdouble *) embedder_x = offscreen_x;
 853   * (gdouble *) embedder_y = offscreen_y;
 854 }
 855
 856 void
 857 offscreen_from_embedder (GdkWindow *window,
 858                          gdouble embedder_x,
 859                          gdouble embedder_y,
 860                          gpointer offscreen_x,
 861                          gpointer offscreen_y,
 862                          gpointer user_data)
 863 {
 864   * (gdouble *) offscreen_x = embedder_x;
 865   * (gdouble *) offscreen_y = embedder_y;
 866 }
 867
 868 gboolean
 869 xwidget_osr_event_set_embedder (GtkWidget *widget,
 870                                 GdkEvent *event,
 871                                 gpointer data)
 872 {
 873   struct xwidget_view *xv = (struct xwidget_view *) data;
 874   struct xwidget *xww = XXWIDGET (xv->model);
 875   printf("gdk_offscreen_window_set_embedder %d %d\n",
 876          GDK_IS_WINDOW(gtk_widget_get_window (xww->widget_osr)),
 877          GDK_IS_WINDOW(gtk_widget_get_window (GTK_WIDGET (xv->widget))));
 878   gdk_offscreen_window_set_embedder (gtk_widget_get_window (xww->widgetwindow_osr),
 879                                      gtk_widget_get_window (xv->widget));
 880 }
 881
 882
 883 /* initializes and does initial placement of an xwidget view on screen */
 884 struct xwidget_view*
 885 xwidget_init_view (struct xwidget *xww,
 886                    struct glyph_string *s,
 887                    int x, int y)
 888 {
 889   struct xwidget_view *xv = allocate_xwidget_view();
 890   Lisp_Object val;
 891   GdkColor color;
 892
 893   XSETXWIDGET_VIEW (val, xv)  ;
 894   Vxwidget_view_list = Fcons (val, Vxwidget_view_list);
 895
 896   XSETWINDOW(xv->w, s->w);
 897   XSETXWIDGET(xv->model, xww);
 898
 899   //widget creation
 900   if(EQ(xww->type, Qbutton))
 901     {
 902       xv->widget = gtk_button_new_with_label (XSTRING(xww->title)->data);
 903       g_signal_connect (G_OBJECT (xv->widget), "clicked",
 904                         G_CALLBACK (buttonclick_handler), xv); // the view rather than the model
 905     } else if (EQ(xww->type, Qtoggle)) {
 906     xv->widget = gtk_toggle_button_new_with_label (XSTRING(xww->title)->data);
 907     //xv->widget = gtk_entry_new ();//temp hack to experiment with key propagation TODO entry widget is useful for testing
 908   } else if (EQ(xww->type, Qsocket)) {
 909     xv->widget = gtk_socket_new ();
 910     g_signal_connect_after(xv->widget, "plug-added", G_CALLBACK(xwidget_plug_added), "plug added");
 911     g_signal_connect_after(xv->widget, "plug-removed", G_CALLBACK(xwidget_plug_removed), "plug removed");
 912     //TODO these doesnt help
 913     gtk_widget_add_events(xv->widget, GDK_KEY_PRESS);
 914     gtk_widget_add_events(xv->widget, GDK_KEY_RELEASE);
 915   } else if (EQ(xww->type, Qslider)) {
 916     xv->widget =
 917       //gtk_hscale_new (GTK_ADJUSTMENT(gtk_adjustment_new (0.0, 0.0, 100.0, 1.0, 10.0, 10.0)));
 918       gtk_hscale_new_with_range ( 0.0, 100.0, 10.0);
 919     gtk_scale_set_draw_value (GTK_SCALE (xv->widget), FALSE);   //i think its emacs role to show text and stuff, so disable the widgets own text
 920     xv->handler_id = g_signal_connect_after(xv->widget, "value-changed", G_CALLBACK(xwidget_slider_changed), "slider changed");
 921   } else if (EQ(xww->type, Qcairo)) {
 922     //Cairo view
 923     //uhm cairo is differentish in gtk 3.
 924     //gdk_cairo_create (gtk_widget_get_window (FRAME_GTK_WIDGET (s->f)));
 925     xv->widget = gtk_drawing_area_new();
 926     g_signal_connect (G_OBJECT (    xv->widget), "draw",
 927                       G_CALLBACK (xwidget_osr_draw_callback), NULL);
 928
 929   } else if (EQ(xww->type, Qwebkit_osr)||
 930              EQ(xww->type, Qsocket_osr)||
 931              (!NILP (Fget(xww->type, QCxwgir_class))))//xwgir widgets are OSR
 932   {
 933     printf("osr init:%s\n",SDATA(SYMBOL_NAME(xww->type)));
 934     xv->widget = gtk_drawing_area_new();
 935     gtk_widget_set_app_paintable ( xv->widget, TRUE); //because expose event handling
 936     gtk_widget_add_events(xv->widget, GDK_ALL_EVENTS_MASK);
 937
 938     /* Draw the view on damage-event */
 939     g_signal_connect (G_OBJECT (xww->widgetwindow_osr), "damage-event",
 940                       G_CALLBACK (offscreen_damage_event), xv->widget);
 941
 942     if (EQ(xww->type, Qwebkit_osr)){
 943       /* ///xwgir debug */
 944       /* //forward events. this isnt compatible with the set_embedded strategy */
 945       g_signal_connect (G_OBJECT (    xv->widget), "button-press-event",
 946                         G_CALLBACK (xwidget_osr_event_forward), NULL);
 947       g_signal_connect (G_OBJECT (    xv->widget), "button-release-event",
 948                         G_CALLBACK (xwidget_osr_event_forward), NULL);
 949       g_signal_connect (G_OBJECT (    xv->widget), "motion-notify-event",
 950                         G_CALLBACK (xwidget_osr_event_forward), NULL);
 951     }else{
 952       //xwgir debug , orthogonal to forwarding
 953       g_signal_connect (G_OBJECT (xv->widget), "enter-notify-event",
 954                         G_CALLBACK (xwidget_osr_event_set_embedder), xv);
 955     }
 956
 957     //draw
 958     g_signal_connect (G_OBJECT (xv->widget), "draw",
 959                       G_CALLBACK (xwidget_osr_draw_callback), NULL);
 960
 961   }
 962   //else return NULL;
 963
 964   //widget realization
 965   //make container widget 1st, and put the actual widget inside the container
 966   //later, drawing should crop container window if necessary to handle case where xwidget
 967   //is partially obscured by other emacs windows
 968   //other containers than gtk_fixed where explored, but gtk_fixed had the most predictable behaviour so far.
 969   xv->emacswindow = FRAME_GTK_WIDGET (s->f);
 970   xv->widgetwindow = gtk_fixed_new ();
 971   gtk_widget_set_has_window(xv->widgetwindow, TRUE);
 972   gtk_container_add (GTK_CONTAINER (xv->widgetwindow), xv->widget);
 973
 974   //store some xwidget data in the gtk widgets
 975   g_object_set_data (G_OBJECT (xv->widget), XG_FRAME_DATA, (gpointer) (s->f)); //the emacs frame
 976   g_object_set_data (G_OBJECT (xv->widget), XG_XWIDGET, (gpointer) (xww)); //the xwidget
 977   g_object_set_data (G_OBJECT (xv->widget), XG_XWIDGET_VIEW, (gpointer) (xv)); //the xwidget
 978   g_object_set_data (G_OBJECT (xv->widgetwindow), XG_XWIDGET, (gpointer) (xww)); //the xwidget window
 979   g_object_set_data (G_OBJECT (xv->widgetwindow), XG_XWIDGET_VIEW, (gpointer) (xv)); //the xwidget window
 980
 981
 982   gtk_widget_set_size_request (GTK_WIDGET (xv->widget), xww->width, xww->height);
 983   gtk_widget_set_size_request (xv->widgetwindow, xww->width, xww->height);
 984   gtk_fixed_put (GTK_FIXED (FRAME_GTK_WIDGET (s->f)), xv->widgetwindow, x, y);
 985   xv->x = x;  xv->y = y;
 986   gtk_widget_show_all (xv->widgetwindow);
 987
 988
 989
 990   //widgettype specific initialization only possible after realization
 991   if (EQ(xww->type, Qsocket)) {
 992     printf ("xwid:%d socket id:%x %d\n",
 993             xww,
 994             gtk_socket_get_id (GTK_SOCKET (xv->widget)),
 995             gtk_socket_get_id (GTK_SOCKET (xv->widget)));
 996     send_xembed_ready_event (xww,
 997                              gtk_socket_get_id (GTK_SOCKET (xv->widget)));
 998     //gtk_widget_realize(xw->widget);
 999   }
1000
1001   //////////////////////////////////////////////////////////////
1002   // xwgir debug
1003   if (//EQ(xww->type, Qwebkit_osr)|| //TODO should be able to choose compile time which method to use with webkit
1004       EQ(xww->type, Qsocket_osr)||
1005       (!NILP (Fget(xww->type, QCxwgir_class))))//xwgir widgets are OSR
1006     {
1007       printf("gdk_offscreen_window_set_embedder %d %d\n",
1008              GDK_IS_WINDOW(gtk_widget_get_window (xww->widget_osr)),
1009              GDK_IS_WINDOW(gtk_widget_get_window (GTK_WIDGET (xv->widget))));
1010       // set_embedder needs to be called after xv->widget realization
1011       gdk_offscreen_window_set_embedder (gtk_widget_get_window (xww->widgetwindow_osr),
1012                                          gtk_widget_get_window (xv->widget));
1013       g_signal_connect (gtk_widget_get_window (xv->widget), "pick-embedded-child",
1014                         G_CALLBACK (offscreen_pick_embedded_child), xww->widgetwindow_osr);
1015
1016       g_signal_connect (gtk_widget_get_window (xww->widgetwindow_osr), "from-embedder",
1017                         G_CALLBACK (offscreen_from_embedder), NULL);
1018       g_signal_connect (gtk_widget_get_window (xww->widgetwindow_osr), "to-embedder",
1019                         G_CALLBACK (offscreen_to_embedder), NULL);
1020     }
1021   ////////////////////////////////////////
1022
1023   return xv;
1024 }
1025
1026
1027 void
1028 x_draw_xwidget_glyph_string (struct glyph_string *s)
1029 {
1030   /*
1031     this method is called by the redisplay engine and places the xwidget on screen.
1032     moving and clipping is done here. also view init.
1033
1034   */
1035   int box_line_hwidth = eabs (s->face->box_line_width);
1036   int box_line_vwidth = max (s->face->box_line_width, 0);
1037   int height = s->height;
1038   struct xwidget *xww = s->xwidget;
1039   struct xwidget_view *xv = xwidget_view_lookup(xww, s->w);
1040   int clip_right; int clip_bottom; int clip_top; int clip_left;
1041
1042   int x = s->x;
1043   int y = s->y + (s->height / 2) - (xww->height / 2);
1044   int moved=0;
1045
1046   /* We do it here in the display loop because there is no other
1047      time to know things like window placement etc.
1048   */
1049   printf ("xv init for xw %d\n", xww);
1050   xv = xwidget_init_view (xww, s, x, y);
1051
1052   //calculate clipping, which is used for all manner of onscreen xwidget views
1053   //each widget border can get clipped by other emacs objects so there are four clipping variables
1054   clip_right = min (xww->width, WINDOW_RIGHT_EDGE_X (s->w) - x - WINDOW_RIGHT_SCROLL_BAR_AREA_WIDTH(s->w) - WINDOW_RIGHT_FRINGE_WIDTH(s->w));
1055   clip_left = max (0, WINDOW_LEFT_EDGE_X (s->w) - x + WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH(s->w) + WINDOW_LEFT_FRINGE_WIDTH(s->w));
1056
1057   clip_bottom = min (xww->height, WINDOW_BOTTOM_EDGE_Y (s->w) - WINDOW_MODE_LINE_HEIGHT (s->w) - y);
1058   clip_top = max(0, WINDOW_TOP_EDGE_Y(s->w) -y );
1059
1060   //we are conserned with movement of the onscreen area. the area might sit still when the widget actually moves
1061   //this happens when an emacs window border moves across a widget window
1062   //so, if any corner of the outer widget clippng window moves, that counts as movement here, even
1063   //if it looks like no movement happens because the widget sits still inside the clipping area.
1064   //the widget can also move inside the clipping area, which happens later
1065   moved = (xv->x  + xv->clip_left != x+clip_left)
1066     || ((xv->y + xv->clip_top)!= (y+clip_top));
1067   if(moved)    printf ("lxwidget moved: id:%d (%d,%d)->(%d,%d) y+clip_top:%d\n", xww, xv->x, xv->y, x, y, y + clip_top);
1068   else
1069     printf ("lxwidget DIDNT move: id:%d (%d,%d)->(%d,%d) y+clip_top:%d\n", xww, xv->x, xv->y, x, y, y + clip_top);
1070   xv->x = x;
1071   xv->y = y;
1072   if (moved)    //has it moved?
1073     {
1074       if (1)//!xwidget_hidden(xv))      //hidden equals not being seen during redisplay
1075         {
1076           //TODO should be possible to use xwidget_show_view here
1077           gtk_fixed_move (GTK_FIXED (FRAME_GTK_WIDGET (s->f)),
1078                           xv->widgetwindow,
1079                           x + clip_left, y + clip_top);
1080         }
1081     }
1082   //clip the widget window if some parts happen to be outside drawable area
1083   //an emacs window is not a gtk window, a gtk window covers the entire frame
1084   //cliping might have changed even if we havent actualy moved, we try figure out when we need to reclip for real
1085   if((xv->clip_right != clip_right)
1086      || (xv->clip_bottom != clip_bottom)
1087      || (xv->clip_top != clip_top)
1088      || (xv->clip_left != clip_left)){
1089     gtk_widget_set_size_request (xv->widgetwindow,  clip_right + clip_left, clip_bottom + clip_top);
1090     gtk_fixed_move(GTK_FIXED(xv->widgetwindow), xv->widget, -clip_left, -clip_top);
1091     printf("reclip %d %d -> %d %d  clip_top:%d clip_left:%d\n",xv->clip_right, xv->clip_bottom,  clip_right, clip_bottom, clip_top , clip_left);
1092
1093
1094     xv->clip_right = clip_right; xv->clip_bottom = clip_bottom; xv->clip_top = clip_top;xv->clip_left = clip_left;
1095   }
1096   //if emacs wants to repaint the area where the widget lives, queue a redraw
1097   //TODO it seems its possible to get out of sync with emacs redraws so emacs bg sometimes shows up instead of xwidget
1098   //its just a visual glitch though
1099   if (!xwidget_hidden(xv)){
1100     gtk_widget_queue_draw (xv->widgetwindow);
1101     gtk_widget_queue_draw (xv->widget);
1102   }
1103 }
1104
1105
1106 #ifdef HAVE_WEBKIT_OSR
1107
1108 //FUGLY macro that checks WEBKIT_IS_WEB_VIEW(xw->widget_osr) first
1109 #define WEBKIT_FN_INIT()                        \
1110   struct xwidget* xw; \
1111   CHECK_XWIDGET (xwidget); \
1112  if(NILP (xwidget)) {printf("ERROR xwidget nil\n"); return Qnil;};    \
1113   xw = XXWIDGET(xwidget);                                                    \
1114   if(NULL == xw) printf("ERROR xw is 0\n");                               \
1115   if((NULL == xw->widget_osr) || !WEBKIT_IS_WEB_VIEW(xw->widget_osr)){  \
1116     printf("ERROR xw->widget_osr does not hold a webkit instance\n");\
1117     return Qnil;\
1118   };
1119
1120
1121 DEFUN ("xwidget-webkit-goto-uri", Fxwidget_webkit_goto_uri,  Sxwidget_webkit_goto_uri,
1122        2, 2, 0,
1123        doc:     /* webkit goto uri.*/)
1124   (Lisp_Object xwidget, Lisp_Object uri)
1125 {
1126   WEBKIT_FN_INIT();
1127   webkit_web_view_load_uri ( WEBKIT_WEB_VIEW(xw->widget_osr), SDATA(uri));
1128   return Qnil;
1129 }
1130
1131
1132 DEFUN ("xwidget-webkit-execute-script", Fxwidget_webkit_execute_script,  Sxwidget_webkit_execute_script,
1133        2, 2, 0,
1134        doc:     /* webkit exec js.*/)
1135   (Lisp_Object xwidget, Lisp_Object script)
1136 {
1137   WEBKIT_FN_INIT();
1138   webkit_web_view_execute_script( WEBKIT_WEB_VIEW(xw->widget_osr), SDATA(script));
1139   return Qnil;
1140 }
1141
1142 DEFUN ("xwidget-webkit-get-title", Fxwidget_webkit_get_title,  Sxwidget_webkit_get_title,
1143        1, 1, 0,
1144        doc:     /* webkit get title. can be used to work around exec method lacks return val*/)
1145   (Lisp_Object xwidget)
1146 {
1147   //TODO support multibyte strings
1148   WEBKIT_FN_INIT();
1149   const gchar* str=webkit_web_view_get_title( WEBKIT_WEB_VIEW(xw->widget_osr));
1150   //return make_string_from_bytes(str, wcslen((const wchar_t *)str), strlen(str));
1151   if(str == 0){
1152     //TODO maybe return Qnil instead. I suppose webkit returns nullpointer when doc is not properly loaded or something
1153     printf("xwidget-webkit-get-title null webkit title\n");
1154     return build_string("");
1155   }
1156   return build_string(str);
1157 }
1158
1159 //TODO missnamed
1160 DEFUN("xwidget-disable-plugin-for-mime", Fxwidget_disable_plugin_for_mime , Sxwidget_disable_plugin_for_mime,
1161       1,1,0, doc: /* */)
1162   (Lisp_Object mime)
1163 {
1164   WebKitWebPlugin *wp = webkit_web_plugin_database_get_plugin_for_mimetype
1165     (webkit_get_web_plugin_database(),  SDATA(mime));
1166   if(wp == NULL) return Qnil;
1167   if(webkit_web_plugin_get_enabled (wp)){
1168     webkit_web_plugin_set_enabled  (wp, FALSE);
1169     return Qt;
1170   }
1171   return Qnil;
1172 }
1173
1174
1175 void
1176 xwidget_webkit_dom_dump(WebKitDOMNode* parent)
1177 {
1178   WebKitDOMNodeList* list;
1179   int i;
1180   int length;
1181   WebKitDOMNode* attribute;
1182   WebKitDOMNamedNodeMap* attrs;
1183   WebKitDOMNode* child;
1184   printf("node:%d type:%d name:%s content:%s\n",
1185          parent,
1186          webkit_dom_node_get_node_type(parent),//1 element 3 text 8 comment 2 attribute
1187          webkit_dom_node_get_local_name(parent),
1188          webkit_dom_node_get_text_content(parent));
1189
1190   if(webkit_dom_node_has_attributes(parent)){
1191     attrs = webkit_dom_node_get_attributes(parent);
1192
1193     length = webkit_dom_named_node_map_get_length(attrs);
1194     for (int i = 0; i < length; i++) {
1195       attribute = webkit_dom_named_node_map_item(attrs,i);
1196       printf(" attr node:%d type:%d name:%s content:%s\n",
1197              attribute,
1198              webkit_dom_node_get_node_type(attribute),//1 element 3 text 8 comment
1199              webkit_dom_node_get_local_name(attribute),
1200              webkit_dom_node_get_text_content(attribute));
1201     }
1202   }
1203   list = webkit_dom_node_get_child_nodes(parent);
1204   length = webkit_dom_node_list_get_length(list);
1205
1206   for (int i = 0; i < length; i++) {
1207     child = webkit_dom_node_list_item(list, i);
1208     //if(webkit_dom_node_has_child_nodes(child))
1209     xwidget_webkit_dom_dump(child);
1210   }
1211 }
1212
1213
1214 DEFUN ("xwidget-webkit-dom-dump", Fxwidget_webkit_dom_dump,  Sxwidget_webkit_dom_dump,
1215        1, 1, 0,
1216        doc:     /* webkit dom dump*/)
1217   (Lisp_Object xwidget)
1218 {
1219   WEBKIT_FN_INIT();
1220   xwidget_webkit_dom_dump(WEBKIT_DOM_NODE(webkit_web_view_get_dom_document( WEBKIT_WEB_VIEW(xw->widget_osr))));
1221   return Qnil;
1222 }
1223
1224
1225
1226 #endif  /* HAVE_WEBKIT_OSR */
1227
1228
1229
1230
1231
1232 DEFUN ("xwidget-resize", Fxwidget_resize, Sxwidget_resize, 3, 3, 0, doc:
1233        /* resize xwidgets*/)
1234   (Lisp_Object xwidget, Lisp_Object new_width, Lisp_Object new_height)
1235 {
1236   CHECK_XWIDGET (xwidget);
1237   struct xwidget* xw = XXWIDGET(xwidget);
1238   struct xwidget_view *xv;
1239   int  w, h;
1240
1241   CHECK_NUMBER (new_width);
1242   CHECK_NUMBER (new_height);
1243   w = XFASTINT (new_width);
1244   h = XFASTINT (new_height);
1245
1246
1247   printf("resize xwidget %d (%d,%d)->(%d,%d)\n",xw, xw->width,xw->height,w,h);
1248   xw->width=w;
1249   xw->height=h;
1250   //if theres a osr resize it 1st
1251   if(xw->widget_osr){
1252     printf("resize xwidget_osr\n");
1253     //gtk_container_set_resize_mode ( GTK_WINDOW(xw->widgetwindow_osr), GTK_RESIZE_QUEUE);
1254     //gtk_container_set_resize_mode ( GTK_WINDOW(xw->widget_osr), GTK_RESIZE_QUEUE);
1255
1256
1257     //gtk_layout_set_size (GTK_LAYOUT (xw->widgetwindow_osr), xw->width, xw->height);
1258     gtk_widget_set_size_request (GTK_WIDGET (xw->widget_osr), xw->width, xw->height); //minimum size
1259     //gtk_window_resize(    GTK_WINDOW(xw->widget_osr), xw->width, xw->height);
1260     gtk_window_resize(    GTK_WINDOW(xw->widgetwindow_osr), xw->width, xw->height);
1261     //gtk_container_resize_children ( GTK_WINDOW(xw->widgetwindow_osr));
1262     gtk_container_resize_children (GTK_CONTAINER(xw->widgetwindow_osr));
1263
1264   }
1265
1266   for (Lisp_Object tail = Vxwidget_view_list; CONSP (tail); tail = XCDR (tail)) //TODO MVC refactor lazy linear search
1267     {
1268       if (XWIDGET_VIEW_P (XCAR (tail))) {
1269         xv = XXWIDGET_VIEW (XCAR (tail));
1270         if(XXWIDGET (xv->model) == xw) {
1271           gtk_layout_set_size (GTK_LAYOUT (xv->widgetwindow), xw->width, xw->height);
1272           gtk_widget_set_size_request (GTK_WIDGET (xv->widget), xw->width, xw->height);
1273         }
1274       }
1275     }
1276
1277   return Qnil;
1278 }
1279
1280 DEFUN ("xwidget-size-request", Fxwidget_size_request, Sxwidget_size_request, 1, 1, 0, doc:
1281        /* desired size (TODO crashes if arg not osr widget)*/)
1282   (Lisp_Object xwidget)
1283 {
1284   CHECK_XWIDGET (xwidget);
1285   GtkRequisition requisition;
1286   Lisp_Object rv;
1287   gtk_widget_size_request(XXWIDGET(xwidget)->widget_osr, &requisition);
1288   rv = Qnil;
1289   rv = Fcons (make_number(requisition.height), rv);
1290   rv = Fcons (make_number(requisition.width), rv);
1291   return rv;
1292
1293 }
1294
1295 DEFUN ("xwidgetp", Fxwidgetp, Sxwidgetp, 1, 1, 0,
1296        doc: /* Return t if OBJECT is a xwidget.  */)
1297   (Lisp_Object object)
1298 {
1299   return XWIDGETP (object) ? Qt : Qnil;
1300 }
1301
1302 DEFUN ("xwidget-view-p", Fxwidget_view_p, Sxwidget_view_p, 1, 1, 0,
1303        doc: /* Return t if OBJECT is a xwidget-view.  */)
1304   (Lisp_Object object)
1305 {
1306   return XWIDGET_VIEW_P (object) ? Qt : Qnil;
1307 }
1308
1309 DEFUN ("xwidget-info", Fxwidget_info , Sxwidget_info, 1,1,0, doc: /* get xwidget props */)
1310   (Lisp_Object xwidget)
1311 {
1312   CHECK_XWIDGET (xwidget);
1313   Lisp_Object info, n;
1314   struct xwidget* xw = XXWIDGET(xwidget);
1315
1316   info = Fmake_vector (make_number (4), Qnil);
1317   ASET (info, 0, xw->type);
1318   ASET (info, 1, xw->title);
1319   XSETFASTINT(n, xw->width);
1320   ASET (info, 2, n);
1321   XSETFASTINT(n, xw->height);
1322   ASET (info, 3, n);
1323
1324   return info;
1325 }
1326
1327 DEFUN ("xwidget-view-info", Fxwidget_view_info , Sxwidget_view_info, 1, 1, 0, doc: /* get xwidget view props */)
1328   (Lisp_Object xwidget_view)
1329 {
1330   CHECK_XWIDGET_VIEW (xwidget_view);
1331   struct xwidget_view *xv = XXWIDGET_VIEW (xwidget_view);
1332   Lisp_Object info;
1333
1334   info = Fmake_vector (make_number (6), Qnil);
1335   ASET (info, 0,  make_number(xv->x));
1336   ASET (info, 1,  make_number(xv->y));
1337   ASET (info, 2,  make_number(xv->clip_right));
1338   ASET (info, 3,  make_number(xv->clip_bottom));
1339   ASET (info, 4,  make_number(xv->clip_top));
1340   ASET (info, 5,  make_number(xv->clip_left));
1341
1342   return info;
1343 }
1344
1345 DEFUN ("xwidget-view-model", Fxwidget_view_model, Sxwidget_view_model,
1346        1, 1, 0,
1347        doc: /* get xwidget view model */)
1348   (Lisp_Object xwidget_view)
1349 {
1350   CHECK_XWIDGET_VIEW (xwidget_view);
1351   return XXWIDGET_VIEW (xwidget_view)->model;
1352 }
1353
1354 DEFUN ("xwidget-view-window", Fxwidget_view_window, Sxwidget_view_window,
1355        1, 1, 0,
1356        doc: /* get xwidget view window */)
1357   (Lisp_Object xwidget_view)
1358 {
1359   CHECK_XWIDGET_VIEW (xwidget_view);
1360   return XXWIDGET_VIEW (xwidget_view)->w;
1361 }
1362
1363 DEFUN ("xwidget-send-keyboard-event", Fxwidget_send_keyboard_event, Sxwidget_send_keyboard_event, 2, 2, 0, doc:/* synthesize a kbd event for a xwidget. */
1364        )
1365   (Lisp_Object  xwidget, Lisp_Object keydescriptor)
1366 {
1367   //TODO this code crashes for offscreen widgets and ive tried many different strategies
1368   //int keyval = 0x058; //X
1369   int keyval = XFASTINT(keydescriptor); //X
1370   char *keystring = "";
1371   GdkKeymapKey* keys;
1372   gint n_keys;
1373   GdkDeviceManager* manager;
1374   struct xwidget *xw;
1375   GtkWidget* widget;
1376   GdkEventKey* ev;
1377   Lisp_Object window;
1378   //popup_activated_flag = 1; //TODO just a hack
1379   gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), keyval, &keys, &n_keys);
1380
1381   xw = XXWIDGET(xwidget);
1382
1383   ev = (GdkEventKey*)gdk_event_new(GDK_KEY_PRESS);
1384
1385
1386   //todo what about windowless widgets?
1387
1388   window = FRAME_SELECTED_WINDOW (SELECTED_FRAME ());
1389
1390
1391   //TODO maybe we also need to special case sockets by picking up the plug rather than the socket
1392   if(xw->widget_osr)
1393     widget = xw->widget_osr;
1394   else
1395     widget = xwidget_view_lookup(xw, XWINDOW(window))->widget;
1396
1397   ev->window = gtk_widget_get_window(widget);
1398   gtk_widget_grab_focus(widget);
1399   ev->send_event = FALSE;
1400
1401   ev->hardware_keycode = keys[0].keycode;
1402   ev->group = keys[0].group;
1403
1404   ev->keyval = keyval;
1405   ev->time = GDK_CURRENT_TIME;
1406
1407   //ev->device = gdk_device_get_core_pointer();
1408   manager = gdk_display_get_device_manager(gdk_window_get_display(ev->window));
1409   gdk_event_set_device ((GdkEvent*)ev,   gdk_device_manager_get_client_pointer(manager));
1410   gdk_event_put((GdkEvent*)ev);
1411   //g_signal_emit_by_name(ev->window,"key-press-event", ev);
1412
1413   ev->type = GDK_KEY_RELEASE;
1414   gdk_event_put((GdkEvent*)ev);
1415   //g_signal_emit_by_name(ev->window,"key-release-event", ev);
1416   //gtk_main_do_event(ev);
1417
1418   //TODO
1419   //if I delete the event the receiving component eventually crashes.
1420   //it ough TDTRT since event_put is supposed to copy the event
1421   //so probably this leaks events now
1422   //gdk_event_free((GdkEvent*)ev);
1423
1424   return Qnil;
1425 }
1426
1427 DEFUN ("delete-xwidget-view", Fdelete_xwidget_view, Sdelete_xwidget_view,
1428        1, 1, 0,
1429        doc: /* Delete the XWIDGET-VIEW. */)
1430   (Lisp_Object xwidget_view)
1431 {
1432   CHECK_XWIDGET_VIEW (xwidget_view);
1433   struct xwidget_view *xv = XXWIDGET_VIEW (xwidget_view);
1434   gtk_widget_destroy(xv->widgetwindow);
1435   Vxwidget_view_list = Fdelq (xwidget_view, Vxwidget_view_list);
1436 }
1437
1438 DEFUN ("xwidget-view-lookup", Fxwidget_view_lookup, Sxwidget_view_lookup,
1439        1, 2, 0,
1440        doc: /* Return the xwidget-view associated to XWIDGET in
1441 WINDOW if specified, otherwise it uses the selected window. */)
1442   (Lisp_Object xwidget, Lisp_Object window)
1443 {
1444   CHECK_XWIDGET (xwidget);
1445
1446   if (NILP (window))
1447     window = Fselected_window();
1448   CHECK_WINDOW (window);
1449
1450   for (Lisp_Object tail = Vxwidget_view_list; CONSP (tail); tail = XCDR (tail))
1451     {
1452       Lisp_Object xwidget_view = XCAR (tail);
1453       if (EQ (Fxwidget_view_model (xwidget_view), xwidget)
1454           && EQ (Fxwidget_view_window (xwidget_view), window))
1455         return xwidget_view;
1456     }
1457
1458   return Qnil;
1459 }
1460
1461 DEFUN ("set-frame-visible", Fset_frame_visible, Sset_frame_visible,
1462        2, 2, 0,
1463        doc: /* HACKY */)
1464   (Lisp_Object frame, Lisp_Object flag)
1465 {
1466   CHECK_FRAME (frame);
1467   struct frame *f = XFRAME (frame);
1468   SET_FRAME_VISIBLE (f, !NILP (flag));
1469   return flag;
1470 }
1471
1472 DEFUN ("xwidget-plist", Fxwidget_plist, Sxwidget_plist,
1473        1, 1, 0,
1474        doc: /* Return the plist of XWIDGET.  */)
1475   (register Lisp_Object xwidget)
1476 {
1477   CHECK_XWIDGET (xwidget);
1478   return XXWIDGET (xwidget)->plist;
1479 }
1480
1481 DEFUN ("xwidget-buffer", Fxwidget_buffer, Sxwidget_buffer,
1482        1, 1, 0,
1483        doc: /* Return the buffer of XWIDGET.  */)
1484   (register Lisp_Object xwidget)
1485 {
1486   CHECK_XWIDGET (xwidget);
1487   return XXWIDGET (xwidget)->buffer;
1488 }
1489
1490 DEFUN ("set-xwidget-plist", Fset_xwidget_plist, Sset_xwidget_plist,
1491        2, 2, 0,
1492        doc: /* Replace the plist of XWIDGET with PLIST.  Returns PLIST.  */)
1493   (register Lisp_Object xwidget, Lisp_Object plist)
1494 {
1495   CHECK_XWIDGET (xwidget);
1496   CHECK_LIST (plist);
1497
1498   XXWIDGET (xwidget)->plist = plist;
1499   return plist;
1500 }
1501
1502 DEFUN ("set-xwidget-query-on-exit-flag",
1503        Fset_xwidget_query_on_exit_flag, Sset_xwidget_query_on_exit_flag,
1504        2, 2, 0,
1505        doc: /* Specify if query is needed for XWIDGET when Emacs is
1506 exited.  If the second argument FLAG is non-nil, Emacs will query the
1507 user before exiting or killing a buffer if XWIDGET is running.  This
1508 function returns FLAG. */)
1509   (Lisp_Object xwidget, Lisp_Object flag)
1510 {
1511   CHECK_XWIDGET (xwidget);
1512   XXWIDGET (xwidget)->kill_without_query = NILP (flag);
1513   return flag;
1514 }
1515
1516 DEFUN ("xwidget-query-on-exit-flag",
1517        Fxwidget_query_on_exit_flag, Sxwidget_query_on_exit_flag,
1518        1, 1, 0,
1519        doc: /* Return the current value of query-on-exit flag for XWIDGET. */)
1520   (Lisp_Object xwidget)
1521 {
1522   CHECK_XWIDGET (xwidget);
1523   return (XXWIDGET (xwidget)->kill_without_query ? Qnil : Qt);
1524 }
1525
1526 void
1527 syms_of_xwidget (void)
1528 {
1529   int i;
1530
1531   defsubr (&Smake_xwidget);
1532   defsubr (&Sxwidgetp);
1533   DEFSYM (Qxwidgetp, "xwidgetp");
1534   defsubr (&Sxwidget_view_p);
1535   DEFSYM (Qxwidget_view_p, "xwidget-view-p");
1536   defsubr (&Sxwidget_info);
1537   defsubr (&Sxwidget_view_info);
1538   defsubr (&Sxwidget_resize);
1539   defsubr (&Sget_buffer_xwidgets);
1540   defsubr (&Sxwidget_view_model);
1541   defsubr (&Sxwidget_view_window);
1542   defsubr (&Sxwidget_view_lookup);
1543   defsubr (&Sxwidget_query_on_exit_flag);
1544   defsubr (&Sset_xwidget_query_on_exit_flag);
1545   defsubr (&Sset_frame_visible);
1546
1547 #ifdef HAVE_WEBKIT_OSR
1548   defsubr (&Sxwidget_webkit_goto_uri);
1549   defsubr (&Sxwidget_webkit_execute_script);
1550   defsubr (&Sxwidget_webkit_get_title);
1551   DEFSYM (Qwebkit_osr ,"webkit-osr");
1552 #endif
1553
1554   defsubr (&Sxwgir_xwidget_call_method  );
1555   defsubr (&Sxwgir_require_namespace);
1556   defsubr (&Sxwidget_size_request  );
1557   defsubr (&Sdelete_xwidget_view);
1558   defsubr (&Sxwidget_disable_plugin_for_mime);
1559
1560   defsubr (&Sxwidget_send_keyboard_event);
1561   defsubr (&Sxwidget_webkit_dom_dump);
1562   defsubr (&Sxwidget_plist);
1563   defsubr (&Sxwidget_buffer);
1564   defsubr (&Sset_xwidget_plist);
1565
1566   DEFSYM (Qxwidget, "xwidget");
1567
1568   DEFSYM (QCxwidget, ":xwidget");
1569   DEFSYM (QCxwgir_class, ":xwgir-class");
1570   DEFSYM (QCtitle, ":title");
1571
1572   /* Do not forget to update the docstring of make-xwidget if you add
1573      new types. */
1574   DEFSYM (Qbutton, "Button"); //changed to match the gtk class because xwgir(experimental and not really needed)
1575   DEFSYM (Qtoggle, "ToggleButton");
1576   DEFSYM (Qslider, "slider");
1577   DEFSYM (Qsocket, "socket");
1578   DEFSYM (Qsocket_osr, "socket-osr");
1579   DEFSYM (Qcairo, "cairo");
1580
1581   DEFSYM (QCplist, ":plist");
1582
1583   DEFVAR_LISP ("xwidget-list", Vxwidget_list, doc: /*xwidgets list*/);
1584   Vxwidget_list = Qnil;
1585
1586   DEFVAR_LISP ("xwidget-view-list", Vxwidget_view_list, doc: /*xwidget views list*/);
1587   Vxwidget_view_list = Qnil;
1588
1589   Fprovide (intern ("xwidget-internal"), Qnil);
1590
1591 }
1592
1593
1594 /* Value is non-zero if OBJECT is a valid Lisp xwidget specification.  A
1595    valid xwidget specification is a list whose car is the symbol
1596    `xwidget', and whose rest is a property list.  The property list must
1597    contain a value for key `:type'.  That value must be the name of a
1598    supported xwidget type.  The rest of the property list depends on the
1599    xwidget type.  */
1600
1601 int
1602 valid_xwidget_spec_p (Lisp_Object object)
1603 {
1604   int valid_p = 0;
1605
1606   if (CONSP (object) && EQ (XCAR (object), Qxwidget))
1607     {
1608       /* Lisp_Object tem; */
1609
1610       /* for (tem = XCDR (object); CONSP (tem); tem = XCDR (tem)) */
1611       /*   if (EQ (XCAR (tem), QCtype)) */
1612       /*     { */
1613       /*       tem = XCDR (tem); */
1614       /*       if (CONSP (tem) && SYMBOLP (XCAR (tem))) */
1615       /*         { */
1616       /*        struct xwidget_type *type; */
1617       /*        type = lookup_xwidget_type (XCAR (tem)); */
1618       /*        if (type) */
1619       /*          valid_p = type->valid_p (object); */
1620       /*         } */
1621
1622       /*       break; */
1623       /*     } */
1624       //never mind type support for now
1625       valid_p = 1;
1626     }
1627
1628   return valid_p;
1629 }
1630
1631
1632
1633 /* find a value associated with key in spec */
1634 Lisp_Object
1635 xwidget_spec_value ( Lisp_Object spec, Lisp_Object  key,
1636                      int *found)
1637 {
1638   Lisp_Object tail;
1639
1640   eassert (valid_xwidget_spec_p (spec));
1641
1642   for (tail = XCDR (spec);
1643        CONSP (tail) && CONSP (XCDR (tail)); tail = XCDR (XCDR (tail)))
1644     {
1645       if (EQ (XCAR (tail), key))
1646         {
1647           if (found)
1648             *found = 1;
1649           return XCAR (XCDR (tail));
1650         }
1651     }
1652
1653   if (found)
1654     *found = 0;
1655   return Qnil;
1656 }
1657
1658
1659 void
1660 xwidget_view_delete_all_in_window (struct window *w)
1661 {
1662   struct xwidget_view* xv = NULL;
1663   for (Lisp_Object tail = Vxwidget_view_list; CONSP (tail); tail = XCDR (tail))
1664     {
1665       if (XWIDGET_VIEW_P (XCAR (tail))) {
1666         xv = XXWIDGET_VIEW (XCAR (tail));
1667         if(XWINDOW (xv->w) == w) {
1668           gtk_widget_destroy(xv->widgetwindow);
1669           Vxwidget_view_list = Fdelq (XCAR (tail), Vxwidget_view_list);
1670         }
1671       }
1672     }
1673 }
1674
1675 struct xwidget_view*
1676 xwidget_view_lookup (struct xwidget* xw, struct window *w)
1677 {
1678   Lisp_Object xwidget, window, ret;
1679   XSETXWIDGET (xwidget, xw);
1680   XSETWINDOW (window, w);
1681
1682   ret = Fxwidget_view_lookup (xwidget, window);
1683
1684   return EQ (ret, Qnil) ? NULL : XXWIDGET_VIEW (ret);
1685 }
1686
1687 struct xwidget*
1688 lookup_xwidget (Lisp_Object  spec)
1689 {
1690   /* When a xwidget lisp spec is found initialize the C struct that is used in the C code.
1691      This is done by redisplay so values change if the spec changes.
1692      So, take special care of one-shot events
1693
1694      TODO remove xwidget init from display spec. simply store an xwidget reference only and set
1695      size etc when creating the xwidget, which should happen before insertion into buffer
1696   */
1697   int found = 0, found1 = 0, found2 = 0;
1698   Lisp_Object value;
1699   struct xwidget *xw;
1700
1701   value = xwidget_spec_value (spec, QCxwidget, &found1);
1702   xw = XXWIDGET(value);
1703
1704   /* value = xwidget_spec_value (spec, QCtype, &found); */
1705   /* xw->type = SYMBOLP (value) ? value : Qbutton;      //default to button */
1706   /* value = xwidget_spec_value (spec, QCtitle, &found2); */
1707   /* xw->title = STRINGP (value) ? (char *) SDATA (value) : "?";        //funky cast FIXME TODO */
1708
1709   /* value = xwidget_spec_value (spec, QCheight, NULL); */
1710   /* xw->height = INTEGERP (value) ? XFASTINT (value) : 50;  */
1711   /* value = xwidget_spec_value (spec, QCwidth, NULL); */
1712   /* xw->width = INTEGERP (value) ? XFASTINT (value) : 50; */
1713
1714   /* value = xwidget_spec_value (spec, QCplist, NULL); */
1715   /* xw->plist = value; */
1716   /* coordinates are not known here */
1717   printf ("lookup_xwidget xwidget_id:%d type:%d found:%d %d %d title:'%s' (%d,%d)\n", xw,
1718           xw->type, found, found1, found2, xw->title, xw->height, xw->width);
1719
1720   //assert_valid_xwidget_id (id, "lookup_xwidget");
1721   return xw;
1722 }
1723
1724 /*set up detection of touched xwidget*/
1725 void
1726 xwidget_start_redisplay (void)
1727 {
1728   for (Lisp_Object tail = Vxwidget_view_list; CONSP (tail); tail = XCDR (tail))
1729     {
1730       if (XWIDGET_VIEW_P (XCAR (tail)))
1731         XXWIDGET_VIEW (XCAR (tail))->redisplayed = 0;
1732     }
1733 }
1734
1735 /* the xwidget was touched during redisplay, so it isnt a candidate for hiding*/
1736 void
1737 xwidget_touch (struct xwidget_view *xv)
1738 {
1739   xv->redisplayed = 1;
1740 }
1741
1742 int
1743 xwidget_touched (struct xwidget_view *xv)
1744 {
1745   return  xv->redisplayed;
1746 }
1747
1748 /* redisplay has ended, now we should hide untouched xwidgets
1749 */
1750 void
1751 xwidget_end_redisplay (struct window *w, struct glyph_matrix *matrix)
1752 {
1753
1754   int i;
1755   struct xwidget *xw;
1756   int area;
1757
1758
1759   xwidget_start_redisplay ();
1760   //iterate desired glyph matrix of window here, hide gtk widgets
1761   //not in the desired matrix.
1762
1763   //this only takes care of xwidgets in active windows.
1764   //if a window goes away from screen xwidget views wust be deleted
1765
1766   //  dump_glyph_matrix(matrix, 2);
1767   for (i = 0; i < matrix->nrows; ++i)
1768     {
1769       //    dump_glyph_row (MATRIX_ROW (matrix, i), i, glyphs);
1770       struct glyph_row *row;
1771       row = MATRIX_ROW (matrix, i);
1772       if (row->enabled_p != 0)
1773         {
1774           for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
1775             {
1776               struct glyph *glyph = row->glyphs[area];
1777               struct glyph *glyph_end = glyph + row->used[area];
1778               for (; glyph < glyph_end; ++glyph)
1779                 {
1780                   if (glyph->type == XWIDGET_GLYPH)
1781                     {
1782                       /*
1783                         the only call to xwidget_end_redisplay is in dispnew
1784                         xwidget_end_redisplay(w->current_matrix);
1785                       */
1786                       xwidget_touch (xwidget_view_lookup(glyph->u.xwidget,
1787                                                          w));
1788                     }
1789                 }
1790             }
1791         }
1792     }
1793
1794   for (Lisp_Object tail = Vxwidget_view_list; CONSP (tail); tail = XCDR (tail))
1795     {
1796       if (XWIDGET_VIEW_P (XCAR (tail))) {
1797         struct xwidget_view* xv = XXWIDGET_VIEW (XCAR (tail));
1798
1799         //"touched" is only meaningful for the current window, so disregard other views
1800         if (XWINDOW (xv->w) == w) {
1801           if (xwidget_touched(xv))
1802             xwidget_show_view (xv);
1803           else
1804             xwidget_hide_view (xv);
1805         }
1806       }
1807     }
1808 }
1809
1810 /* Kill all xwidget in BUFFER. */
1811 void
1812 kill_buffer_xwidgets (Lisp_Object buffer)
1813 {
1814   Lisp_Object tail, xwidget;
1815   for (tail = Fget_buffer_xwidgets (buffer); CONSP (tail); tail = XCDR (tail))
1816     {
1817       xwidget = XCAR (tail);
1818       Vxwidget_list = Fdelq (xwidget, Vxwidget_list);
1819       /* TODO free the GTK things in xw */
1820       {
1821         CHECK_XWIDGET (xwidget);
1822         struct xwidget *xw = XXWIDGET (xwidget);
1823         if (xw->widget_osr && xw->widgetwindow_osr)
1824           {
1825             gtk_widget_destroy(xw->widget_osr);
1826             gtk_widget_destroy(xw->widgetwindow_osr);
1827           }
1828       }
1829     }
1830 }
1831
1832 #endif  /* HAVE_XWIDGETS */