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