upstream merge. cleanup

7 files changed, 216 insertions, 88 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 0b06e5bf2c0..e537848ea41 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,49 @@
+2011-07-24  Eli Zaretskii  <eliz@gnu.org>
+
+        * xfaces.c (check_lface_attrs) [HAVE_WINDOW_SYSTEM]: Allow `nil'
+        for attrs[LFACE_FONTSET_INDEX].
+
+2011-07-23  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * xml.c (parse_region): Remove unused local
+        that was recently introduced.
+
+2011-07-23  Eli Zaretskii  <eliz@gnu.org>
+
+        * xfns.c (unwind_create_frame) [GLYPH_DEBUG]: Adapt to changes in
+        2008-02-22T17:42:09Z!monnier@iro.umontreal.ca.
+
+        * xdisp.c (move_it_in_display_line_to): Record the best matching
+        position for TO_CHARPOS while scanning the line, and restore it on
+        exit if none of the characters scanned was an exact match.  Fixes
+        vertical-motion and pos-visible-in-window-p under bidi redisplay
+        when exact match is impossible due to invisible text, and the
+        lines are truncated.
+
+2011-07-23  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsterm.m (initFrameFromEmacs): Set NSTitledWindowMask in styleMask
+        for OSX >= 10.7.
+
+2011-07-22  Eli Zaretskii  <eliz@gnu.org>
+
+        Fix a significant slow-down of cursor motion with C-n, C-p,
+        C-f/C-b, and C-v/M-v that couldn't keep up with keyboard
+        auto-repeat under bidi redisplay in fontified buffers.
+        * xdisp.c (compute_stop_pos_backwards): New function.
+        (next_element_from_buffer): Call compute_stop_pos_backwards to
+        find a suitable prev_stop when we find ourselves before
+        base_level_stop.
+        (reseat): Don't look for prev_stop, as that could mean a very long
+        run.
+        <cached_disp_pos, cached_disp_buffer, cached_disp_modiff>
+        <cached_disp_overlay_modiff>: Cache for last found display string
+        position.
+        (compute_display_string_pos): Return the cached position if asked
+        about the same buffer in the same area of character positions, and
+        the buffer wasn't changed since the time the display string
+        position was cached.
+
 2011-07-22  Eli Zaretskii  <eliz@gnu.org>
 
         * xdisp.c (rows_from_pos_range): Don't ignore glyphs whose object
diff --git a/src/nsterm.m b/src/nsterm.m
index 546247ab74a..e45dc1a902d 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -5304,6 +5304,9 @@ ns_term_shutdown (int sig)
   win = [[EmacsWindow alloc]
             initWithContentRect: r
                       styleMask: (NSResizableWindowMask |
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
+                                  NSTitledWindowMask |
+#endif
                                   NSMiniaturizableWindowMask |
                                   NSClosableWindowMask)
                         backing: NSBackingStoreBuffered
diff --git a/src/xdisp.c b/src/xdisp.c
index 0effc63c3db..a8d62e32ed0 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -3136,6 +3136,14 @@ next_overlay_change (EMACS_INT pos)
   return endpos;
 }
 
+/* Record one cached display string position found recently by
+   compute_display_string_pos.  */
+static EMACS_INT cached_disp_pos;
+static EMACS_INT cached_prev_pos;
+static struct buffer *cached_disp_buffer;
+static int cached_disp_modiff;
+static int cached_disp_overlay_modiff;
+
 /* Return the character position of a display string at or after
    position specified by POSITION.  If no display string exists at or
    after POSITION, return ZV.  A display string is either an overlay
@@ -3157,6 +3165,7 @@ compute_display_string_pos (struct text_pos *position,
   EMACS_INT begb = string_p ? 0 : BEGV;
   EMACS_INT bufpos, charpos = CHARPOS (*position);
   struct text_pos tpos;
+  struct buffer *b;
 
   if (charpos >= eob
       /* We don't support display properties whose values are strings
@@ -3166,6 +3175,33 @@ compute_display_string_pos (struct text_pos *position,
       || (string->s && !STRINGP (object)))
     return eob;
 
+  /* Check the cached values.  */
+  if (!STRINGP (object))
+    {
+      if (NILP (object))
+        b = current_buffer;
+      else
+        b = XBUFFER (object);
+      if (b == cached_disp_buffer
+          && BUF_MODIFF (b) == cached_disp_modiff
+          && BUF_OVERLAY_MODIFF (b) == cached_disp_overlay_modiff)
+        {
+          if (cached_prev_pos
+              && cached_prev_pos < charpos && charpos <= cached_disp_pos)
+            return cached_disp_pos;
+          /* Handle overstepping either end of the known interval.  */
+          if (charpos > cached_disp_pos)
+            cached_prev_pos = cached_disp_pos;
+          else  /* charpos <= cached_prev_pos */
+            cached_prev_pos = max (charpos - 1, BEGV);
+        }
+
+      /* Record new values in the cache.  */
+      cached_disp_buffer = b;
+      cached_disp_modiff = BUF_MODIFF (b);
+      cached_disp_overlay_modiff = BUF_OVERLAY_MODIFF (b);
+    }
+
   /* If the character at CHARPOS is where the display string begins,
      return CHARPOS.  */
   pos = make_number (charpos);
@@ -3181,7 +3217,11 @@ compute_display_string_pos (struct text_pos *position,
                   spec))
       && handle_display_spec (NULL, spec, object, Qnil, &tpos, bufpos,
                               frame_window_p))
-    return charpos;
+    {
+      if (!STRINGP (object))
+        cached_disp_pos = charpos;
+      return charpos;
+    }
 
   /* Look forward for the first character with a `display' property
      that will replace the underlying text when displayed.  */
@@ -3201,6 +3241,8 @@ compute_display_string_pos (struct text_pos *position,
            || !handle_display_spec (NULL, spec, object, Qnil, &tpos, bufpos,
                                     frame_window_p));
 
+  if (!STRINGP (object))
+    cached_disp_pos = CHARPOS (tpos);
   return CHARPOS (tpos);
 }
 
@@ -5752,17 +5794,19 @@ reseat (struct it *it, struct text_pos pos, int force_p)
         {
           /* For bidi iteration, we need to prime prev_stop and
              base_level_stop with our best estimations.  */
-          if (CHARPOS (pos) < it->prev_stop)
-            {
-              handle_stop_backwards (it, BEGV);
-              if (CHARPOS (pos) < it->base_level_stop)
-                it->base_level_stop = 0;
-            }
-          else if (CHARPOS (pos) > it->stop_charpos
-                   && it->stop_charpos >= BEGV)
-            handle_stop_backwards (it, it->stop_charpos);
-          else  /* force_p */
-            handle_stop (it);
+          /* Implementation note: Of course, POS is not necessarily a
+             stop position, so assigning prev_pos to it is a lie; we
+             should have called compute_stop_backwards.  However, if
+             the current buffer does not include any R2L characters,
+             that call would be a waste of cycles, because the
+             iterator will never move back, and thus never cross this
+             "fake" stop position.  So we delay that backward search
+             until the time we really need it, in next_element_from_buffer.  */
+          if (CHARPOS (pos) != it->prev_stop)
+            it->prev_stop = CHARPOS (pos);
+          if (CHARPOS (pos) < it->base_level_stop)
+            it->base_level_stop = 0; /* meaning it's unknown */
+          handle_stop (it);
         }
       else
         {
@@ -7031,10 +7075,10 @@ next_element_from_string (struct it *it)
                   embedding level, so test for that explicitly.  */
                && !BIDI_AT_BASE_LEVEL (it->bidi_it))
         {
-          /* If we lost track of base_level_stop, we have no better place
-             for handle_stop_backwards to start from than BEGV.  This
-             happens, e.g., when we were reseated to the previous
-             screenful of text by vertical-motion.  */
+          /* If we lost track of base_level_stop, we have no better
+             place for handle_stop_backwards to start from than string
+             beginning.  This happens, e.g., when we were reseated to
+             the previous screenful of text by vertical-motion.  */
           if (it->base_level_stop <= 0
               || IT_STRING_CHARPOS (*it) < it->base_level_stop)
             it->base_level_stop = 0;
@@ -7234,6 +7278,50 @@ next_element_from_stretch (struct it *it)
   return 1;
 }
 
+/* Scan backwards from IT's current position until we find a stop
+   position, or until BEGV.  This is called when we find ourself
+   before both the last known prev_stop and base_level_stop while
+   reordering bidirectional text.  */
+
+static void
+compute_stop_pos_backwards (struct it *it)
+{
+  const int SCAN_BACK_LIMIT = 1000;
+  struct text_pos pos;
+  struct display_pos save_current = it->current;
+  struct text_pos save_position = it->position;
+  EMACS_INT charpos = IT_CHARPOS (*it);
+  EMACS_INT where_we_are = charpos;
+  EMACS_INT save_stop_pos = it->stop_charpos;
+  EMACS_INT save_end_pos = it->end_charpos;
+
+  xassert (NILP (it->string) && !it->s);
+  xassert (it->bidi_p);
+  it->bidi_p = 0;
+  do
+    {
+      it->end_charpos = min (charpos + 1, ZV);
+      charpos = max (charpos - SCAN_BACK_LIMIT, BEGV);
+      SET_TEXT_POS (pos, charpos, BYTE_TO_CHAR (charpos));
+      reseat_1 (it, pos, 0);
+      compute_stop_pos (it);
+      /* We must advance forward, right?  */
+      if (it->stop_charpos <= charpos)
+        abort ();
+    }
+  while (charpos > BEGV && it->stop_charpos >= it->end_charpos);
+
+  if (it->stop_charpos <= where_we_are)
+    it->prev_stop = it->stop_charpos;
+  else
+    it->prev_stop = BEGV;
+  it->bidi_p = 1;
+  it->current = save_current;
+  it->position = save_position;
+  it->stop_charpos = save_stop_pos;
+  it->end_charpos = save_end_pos;
+}
+
 /* Scan forward from CHARPOS in the current buffer/string, until we
    find a stop position > current IT's position.  Then handle the stop
    position before that.  This is called when we bump into a stop
@@ -7253,6 +7341,7 @@ handle_stop_backwards (struct it *it, EMACS_INT charpos)
   EMACS_INT next_stop;
 
   /* Scan in strict logical order.  */
+  xassert (it->bidi_p);
   it->bidi_p = 0;
   do
     {
@@ -7272,11 +7361,11 @@ handle_stop_backwards (struct it *it, EMACS_INT charpos)
     }
   while (charpos <= where_we_are);
 
-  next_stop = it->stop_charpos;
-  it->stop_charpos = it->prev_stop;
   it->bidi_p = 1;
   it->current = save_current;
   it->position = save_position;
+  next_stop = it->stop_charpos;
+  it->stop_charpos = it->prev_stop;
   handle_stop (it);
   it->stop_charpos = next_stop;
 }
@@ -7373,14 +7462,19 @@ next_element_from_buffer (struct it *it)
               embedding level, so test for that explicitly.  */
            && !BIDI_AT_BASE_LEVEL (it->bidi_it))
     {
-      /* If we lost track of base_level_stop, we have no better place
-         for handle_stop_backwards to start from than BEGV.  This
-         happens, e.g., when we were reseated to the previous
-         screenful of text by vertical-motion.  */
       if (it->base_level_stop <= 0
           || IT_CHARPOS (*it) < it->base_level_stop)
-        it->base_level_stop = BEGV;
-      handle_stop_backwards (it, it->base_level_stop);
+        {
+          /* If we lost track of base_level_stop, we need to find
+             prev_stop by looking backwards.  This happens, e.g., when
+             we were reseated to the previous screenful of text by
+             vertical-motion.  */
+          it->base_level_stop = BEGV;
+          compute_stop_pos_backwards (it);
+          handle_stop_backwards (it, it->prev_stop);
+        }
+      else
+        handle_stop_backwards (it, it->base_level_stop);
       return GET_NEXT_DISPLAY_ELEMENT (it);
     }
   else
@@ -7582,8 +7676,9 @@ move_it_in_display_line_to (struct it *it,
 {
   enum move_it_result result = MOVE_UNDEFINED;
   struct glyph_row *saved_glyph_row;
-  struct it wrap_it, atpos_it, atx_it;
+  struct it wrap_it, atpos_it, atx_it, ppos_it;
   void *wrap_data = NULL, *atpos_data = NULL, *atx_data = NULL;
+  void *ppos_data = NULL;
   int may_wrap = 0;
   enum it_method prev_method = it->method;
   EMACS_INT prev_pos = IT_CHARPOS (*it);
@@ -7602,6 +7697,19 @@ move_it_in_display_line_to (struct it *it,
   atpos_it.sp = -1;
   atx_it.sp = -1;
 
+  /* Use ppos_it under bidi reordering to save a copy of IT for the
+     position > CHARPOS that is the closest to CHARPOS.  We restore
+     that position in IT when we have scanned the entire display line
+     without finding a match for CHARPOS and all the character
+     positions are greater than CHARPOS.  */
+  if (it->bidi_p)
+    {
+      SAVE_IT (ppos_it, *it, ppos_data);
+      SET_TEXT_POS (ppos_it.current.pos, ZV, ZV_BYTE);
+      if ((op & MOVE_TO_POS) && IT_CHARPOS (*it) >= to_charpos)
+        SAVE_IT (ppos_it, *it, ppos_data);
+    }
+
 #define BUFFER_POS_REACHED_P()                                  \
   ((op & MOVE_TO_POS) != 0                                      \
    && BUFFERP (it->object)                                      \
@@ -7727,6 +7835,11 @@ move_it_in_display_line_to (struct it *it,
           if (IT_CHARPOS (*it) < CHARPOS (this_line_min_pos))
             SET_TEXT_POS (this_line_min_pos,
                           IT_CHARPOS (*it), IT_BYTEPOS (*it));
+          if (it->bidi_p
+              && (op & MOVE_TO_POS)
+              && IT_CHARPOS (*it) > to_charpos
+              && IT_CHARPOS (*it) < IT_CHARPOS (ppos_it))
+            SAVE_IT (ppos_it, *it, ppos_data);
           continue;
         }
 
@@ -7937,7 +8050,11 @@ move_it_in_display_line_to (struct it *it,
           if ((op & MOVE_TO_POS) != 0
               && !saw_smaller_pos
               && IT_CHARPOS (*it) > to_charpos)
-            result = MOVE_POS_MATCH_OR_ZV;
+            {
+              result = MOVE_POS_MATCH_OR_ZV;
+              if (it->bidi_p && IT_CHARPOS (ppos_it) < ZV)
+                RESTORE_IT (it, &ppos_it, ppos_data);
+            }
           else
             result = MOVE_NEWLINE_OR_CR;
           break;
@@ -7953,6 +8070,11 @@ move_it_in_display_line_to (struct it *it,
         SET_TEXT_POS (this_line_min_pos, IT_CHARPOS (*it), IT_BYTEPOS (*it));
       if (IT_CHARPOS (*it) < to_charpos)
         saw_smaller_pos = 1;
+      if (it->bidi_p
+          && (op & MOVE_TO_POS)
+          && IT_CHARPOS (*it) >= to_charpos
+          && IT_CHARPOS (*it) < IT_CHARPOS (ppos_it))
+        SAVE_IT (ppos_it, *it, ppos_data);
 
       /* Stop if lines are truncated and IT's current x-position is
          past the right edge of the window now.  */
@@ -7962,7 +8084,9 @@ move_it_in_display_line_to (struct it *it,
           if (!FRAME_WINDOW_P (it->f)
               || IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
             {
-              if (!get_next_display_element (it)
+              int at_eob_p = 0;
+
+              if ((at_eob_p = !get_next_display_element (it))
                   || BUFFER_POS_REACHED_P ()
                   /* If we are past TO_CHARPOS, but never saw any
                      character positions smaller than TO_CHARPOS,
@@ -7973,6 +8097,8 @@ move_it_in_display_line_to (struct it *it,
                       && IT_CHARPOS (*it) > to_charpos))
                 {
                   result = MOVE_POS_MATCH_OR_ZV;
+                  if (it->bidi_p && !at_eob_p && IT_CHARPOS (ppos_it) < ZV)
+                    RESTORE_IT (it, &ppos_it, ppos_data);
                   break;
                 }
               if (ITERATOR_AT_END_OF_LINE_P (it))
@@ -7986,6 +8112,8 @@ move_it_in_display_line_to (struct it *it,
                    && IT_CHARPOS (*it) > to_charpos)
             {
               result = MOVE_POS_MATCH_OR_ZV;
+              if (it->bidi_p && IT_CHARPOS (ppos_it) < ZV)
+                RESTORE_IT (it, &ppos_it, ppos_data);
               break;
             }
           result = MOVE_LINE_TRUNCATED;
@@ -8011,6 +8139,8 @@ move_it_in_display_line_to (struct it *it,
     xfree (atx_data);
   if (wrap_data)
     xfree (wrap_data);
+  if (ppos_data)
+    xfree (ppos_data);
 
   /* Restore the iterator settings altered at the beginning of this
      function.  */
@@ -23304,7 +23434,7 @@ produce_glyphless_glyph (struct it *it, int for_no_font, Lisp_Object acronym)
   base_width = font->average_width;
 
   /* Get a face ID for the glyph by utilizing a cache (the same way as
-     doen for `escape-glyph' in get_next_display_element).  */
+     done for `escape-glyph' in get_next_display_element).  */
   if (it->f == last_glyphless_glyph_frame
       && it->face_id == last_glyphless_glyph_face_id)
     {
diff --git a/src/xfaces.c b/src/xfaces.c
index c1e75ab3e59..32729ce6f8d 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -1918,7 +1918,8 @@ check_lface_attrs (Lisp_Object *attrs)
            || IGNORE_DEFFACE_P (attrs[LFACE_FONT_INDEX])
            || FONTP (attrs[LFACE_FONT_INDEX]));
   xassert (UNSPECIFIEDP (attrs[LFACE_FONTSET_INDEX])
-           || STRINGP (attrs[LFACE_FONTSET_INDEX]));
+           || STRINGP (attrs[LFACE_FONTSET_INDEX])
+           || NILP (attrs[LFACE_FONTSET_INDEX]));
 #endif
 }
 
diff --git a/src/xfns.c b/src/xfns.c
index 11bf9ab57e1..eec19b9d275 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -2933,7 +2933,7 @@ unwind_create_frame (Lisp_Object frame)
 #if GLYPH_DEBUG
       /* Check that reference counts are indeed correct.  */
       xassert (dpyinfo->reference_count == dpyinfo_refcount);
-      //xassert (dpyinfo->image_cache->refcount == image_cache_refcount); //FIXME doesnt compilex
+      xassert (dpyinfo->terminal->image_cache->refcount == image_cache_refcount);
 #endif
       return Qt;
     }
diff --git a/src/xml.c b/src/xml.c
index a8a4d8122da..55352baae3a 100644
--- a/src/xml.c
+++ b/src/xml.c
@@ -87,7 +87,6 @@ static Lisp_Object
 parse_region (Lisp_Object start, Lisp_Object end, Lisp_Object base_url, int htmlp)
 {
   xmlDoc *doc;
-  xmlNode *node;
   Lisp_Object result = Qnil;
   const char *burl = "";
   EMACS_INT bytes;
@@ -129,13 +128,13 @@ parse_region (Lisp_Object start, Lisp_Object end, Lisp_Object base_url, int html
       Lisp_Object r = Qnil;
 
       while (n) {
-        if (r != Qnil)
+        if (!NILP (r))
           result = Fcons (r, result);
         r = make_dom (n);
         n = n->next;
       }
 
-      if (result == Qnil)
+      if (NILP (result))
         result = r;
       else
         result = Fcons (intern ("top"),
diff --git a/src/xwidget.c b/src/xwidget.c
index 6732fad02d5..2186d429a32 100644
--- a/src/xwidget.c
+++ b/src/xwidget.c
@@ -256,19 +256,9 @@ send_xembed_ready_event (struct xwidget* xw, int xembedid)
 
 }
 
-int xwidget_query_composition_called = 0;
-int hasNamePixmap = 0;
-
-
-
-
-
-
-
 void
 xwidget_show_view (struct xwidget_view *xv)
 {
-  //printf("xwidget %d shown\n",xw->id);
   xv->hidden = 0;
   gtk_widget_show(GTK_WIDGET(xv->widgetwindow));
   gtk_fixed_move (GTK_FIXED (xv->emacswindow), GTK_WIDGET (xv->widgetwindow),  xv->x  + xv->clip_left, xv->y + xv->clip_top); //TODO refactor
@@ -279,7 +269,6 @@ xwidget_show_view (struct xwidget_view *xv)
 void
 xwidget_hide_view (struct xwidget_view *xv)
 {
-  //printf("xwidget %d hidden\n",xw->id);
   xv->hidden = 1;
   //gtk_widget_hide(GTK_WIDGET(xw->widgetwindow));
   gtk_fixed_move (GTK_FIXED (xv->emacswindow), GTK_WIDGET (xv->widgetwindow),
@@ -432,10 +421,6 @@ xwidget_init_view (
     xv->widget = gtk_toggle_button_new_with_label (XSTRING(xww->title)->data);
   } else if (EQ(xww->type, Qsocket)) {
     xv->widget = gtk_socket_new ();
-    //gtk_widget_set_app_paintable (xw->widget, TRUE); //workaround for composited sockets
-
-    //gdk_color_parse("blue",&color); //the blue color never seems to show up. something else draws a grey bg
-    //gtk_widget_modify_bg(xv->widget, GTK_STATE_NORMAL, &color);
     g_signal_connect_after(xv->widget, "plug-added", G_CALLBACK(xwidget_plug_added), "plug added");
     g_signal_connect_after(xv->widget, "plug-removed", G_CALLBACK(xwidget_plug_removed), "plug removed");
   } else if (EQ(xww->type, Qslider)) {
@@ -518,39 +503,18 @@ xwidget_init_view (
   //make container widget 1st, and put the actual widget inside the container
   //later, drawing should crop container window if necessary to handle case where xwidget
   //is partially obscured by other emacs windows
+  //other containers than gtk_fixed where explored, but gtk_fixed had the most predictable behaviour so far.
   xv->emacswindow = GTK_CONTAINER (FRAME_GTK_WIDGET (s->f));
-  //xw->widgetwindow = GTK_CONTAINER (gtk_layout_new (NULL, NULL));
-  //xw->widgetwindow = GTK_CONTAINER (gtk_offscreen_window_new ());
-
-  xv->widgetwindow = GTK_CONTAINER (gtk_fixed_new ()); //works well for clipping on gtk2 not gtk3
-  //xv->widgetwindow = GTK_CONTAINER (gtk_event_box_new ()); //doesnt help clipping gtk3
-  //xv->widgetwindow = GTK_CONTAINER (gtk_scrolled_window_new (NULL, NULL)); //clips in gtk3
-  //xv->widgetwindow = GTK_CONTAINER (gtk_viewport_new (NULL, NULL));
-
-
-  /* GtkAllocation a; */
-  /* a.x=0;  a.y=0;   a.width=xww->width;  a.height=xww->height; */
-  /* gtk_widget_set_allocation (GTK_WIDGET (xv->widget), &a); */
-
+  xv->widgetwindow = GTK_CONTAINER (gtk_fixed_new ()); 
   gtk_widget_set_has_window(GTK_WIDGET (  xv->widgetwindow), TRUE);
-  //on GTK2 if gtk_fixed doesnt have a window it will surprisingly not honor
-  //setsize so that children gets clipped later. the documentation is
-  //not consistent regarding if its legal to call this method.
-
-  //on GTK3 the call isnt necessary except for windowless widgets such as the drawarea used for the webkit views
-
-
-  //gtk_layout_set_size (GTK_LAYOUT (xw->widgetwindow), xw->width, xw->height);
   gtk_container_add (xv->widgetwindow, xv->widget);
 
-  //gtk_scrolled_window_add_with_viewport (xv->widgetwindow, xv->widget); // when using scrollw
-
   //store some xwidget data in the gtk widgets
   g_object_set_data (G_OBJECT (xv->widget), XG_FRAME_DATA, (gpointer) (s->f)); //the emacs frame
   g_object_set_data (G_OBJECT (xv->widget), XG_XWIDGET, (gpointer) (xww)); //the xwidget
   g_object_set_data (G_OBJECT (xv->widget), XG_XWIDGET_VIEW, (gpointer) (xv)); //the xwidget
-  g_object_set_data (G_OBJECT (xv->widgetwindow), XG_XWIDGET, (gpointer) (xww)); //the xwidget
-  g_object_set_data (G_OBJECT (xv->widgetwindow), XG_XWIDGET_VIEW, (gpointer) (xv)); //the xwidget
+  g_object_set_data (G_OBJECT (xv->widgetwindow), XG_XWIDGET, (gpointer) (xww)); //the xwidget window
+  g_object_set_data (G_OBJECT (xv->widgetwindow), XG_XWIDGET_VIEW, (gpointer) (xv)); //the xwidget window
 
 
   gtk_widget_set_size_request (GTK_WIDGET (xv->widget), xww->width, xww->height);
@@ -559,19 +523,6 @@ xwidget_init_view (
   xv->x = x;  xv->y = y;
   gtk_widget_show_all (GTK_WIDGET (xv->widgetwindow));
 
-
-  //this seems to enable xcomposition. later we need to paint ourselves somehow,
-  //since the widget is no longer responsible for painting itself
-  //if(xw->type!=3)  //im having trouble with compositing and sockets. hmmm.
-  //gdk_window_set_composited (xw->widget->window, TRUE);
-  //gdk_window_set_composited (GTK_LAYOUT (xw->widgetwindow)->bin_window, TRUE);
-  // gtk_widget_set_double_buffered (xw->widget,FALSE);
-  // gtk_widget_set_double_buffered (xw->widgetwindow,FALSE);
-  //gdk_window_set_composited (xw->widgetwindow, TRUE);
-  //g_signal_connect_after(xw->widget, "expose-event", G_CALLBACK(xwidget_composite_draw), "widget exposed");
-  //g_signal_connect_after(xw->widgetwindow, "expose-event", G_CALLBACK(xwidget_composite_draw_widgetwindow), "widgetwindow exposed");
-  //  g_signal_connect_after(xw->widget, "damage-event", G_CALLBACK(xwidget_composite_draw), "damaged");
-
   //widgettype specific initialization only possible after realization
   if (EQ(xww->type, Qsocket)) {
     printf ("xwid:%d socket id:%x %d\n",
@@ -693,8 +644,6 @@ DEFUN ("xwidget-webkit-get-title", Fxwidget_webkit_get_title,  Sxwidget_webkit_g
   return make_string_from_bytes(str, wcslen((const wchar_t *)str), strlen(str));
 }
 
-
-
 #endif