[ViewVC] Diff of: cvs/rxvt-unicode/src/rxvtperl.xs

Comparing rxvt-unicode/src/rxvtperl.xs (file contents):
Revision 1.75 by root, Wed Jan 18 11:05:09 2006 UTC vs.
Revision 1.104 by root, Mon Aug 7 22:28:18 2006 UTC

 #undef LINENO
 #define LINENO(n) MOD (THIS->term_start + int(n), THIS->total_rows)
 #undef ROW
 #define ROW(n) THIS->row_buf [LINENO (n)]
-#define ENABLE_PERL_FRILLS 1
+typedef int CHAINED UNUSED;
 /////////////////////////////////////////////////////////////////////////////
 static wchar_t *
 sv2wcs (SV *sv)
 new_ref (HV *hv, const char *klass)
 {
   return sv_bless (newRV ((SV *)hv), gv_stashpv (klass, 1));
 }
-//TODO: use magic
 static SV *
 newSVptr (void *ptr, const char *klass)
 {
   HV *hv = newHV ();
   sv_magic ((SV *)hv, 0, PERL_MAGIC_ext, (char *)ptr, 0);
     croak ("perl code used %s object, but C++ object is already destroyed, caught", klass);
   return (long)mg->mg_ptr;
 }
-#define newSVterm(term) SvREFCNT_inc ((SV *)term->perl.self)
+#define newSVterm(term) SvREFCNT_inc ((SV *)(term)->perl.self)
-#define SvTERM(sv) (rxvt_term *)SvPTR (sv, "urxvt::term")
+#define SvTERM(sv) (rxvt_term *)SvPTR ((sv), "urxvt::term")
 /////////////////////////////////////////////////////////////////////////////
+#define SvWATCHER(sv) (perl_watcher *)SvPTR (sv, "urxvt::watcher")
 struct perl_watcher
 {
   SV *cbsv;
   HV *self;
   perl_watcher ()
-  : cbsv (newSV (0))
+  : cbsv (0)
   {
   }
   ~perl_watcher ()
   {
     SvREFCNT_dec (cbsv);
   }
   void cb (SV *cb)
   {
-    sv_setsv (cbsv, cb);
+    SvREFCNT_dec (cbsv);
+    cbsv = newSVsv (cb);
   }
   void invoke (const char *type, SV *self, int arg = -1);
 };
   if (SvTRUE (ERRSV))
     rxvt_warn ("%s callback evaluation error: %s", type, SvPV_nolen (ERRSV));
 }
-#define newSVtimer(timer) new_ref (timer->self, "urxvt::timer")
+#define newSVtimer(timer) new_ref ((timer)->self, "urxvt::timer")
-#define SvTIMER(sv) (timer *)SvPTR (sv, "urxvt::timer")
+#define SvTIMER(sv) (timer *)(perl_watcher *)SvPTR ((sv), "urxvt::timer")
-struct timer : time_watcher, perl_watcher
+struct timer : perl_watcher, time_watcher
 {
   tstamp interval;
   timer ()
   : time_watcher (this, &timer::execute)
     invoke ("urxvt::timer", newSVtimer (this));
   }
 };
-#define newSViow(iow) new_ref (iow->self, "urxvt::iow")
+#define newSViow(iow) new_ref ((iow)->self, "urxvt::iow")
-#define SvIOW(sv) (iow *)SvPTR (sv, "urxvt::iow")
+#define SvIOW(sv) (iow *)(perl_watcher *)SvPTR ((sv), "urxvt::iow")
-struct iow : io_watcher, perl_watcher
+struct iow : perl_watcher, io_watcher
 {
   iow ()
   : io_watcher (this, &iow::execute)
   {
   }
   {
     invoke ("urxvt::iow", newSViow (this), revents);
   }
 };
+#define newSViw(iw) new_ref ((iw)->self, "urxvt::iw")
+#define SvIW(sv) (iw *)(perl_watcher *)SvPTR ((sv), "urxvt::iw")
+struct iw : perl_watcher, idle_watcher
+{
+  iw ()
+  : idle_watcher (this, &iw::execute)
+  {
+  }
+  void execute (idle_watcher &w)
+  {
+    invoke ("urxvt::iw", newSViw (this));
+  }
+};
+#define newSVpw(pw) new_ref ((pw)->self, "urxvt::pw")
+#define SvPW(sv) (pw *)(perl_watcher *)SvPTR ((sv), "urxvt::pw")
+struct pw : perl_watcher, child_watcher
+{
+  pw ()
+  : child_watcher (this, &pw::execute)
+  {
+  }
+  void execute (child_watcher &w, int status)
+  {
+    invoke ("urxvt::pw", newSVpw (this), status);
+  }
+};
 /////////////////////////////////////////////////////////////////////////////
 #define SvOVERLAY(sv) (overlay *)SvPTR (sv, "urxvt::overlay")
-struct overlay {
+class overlay {
-  HV *self;
   rxvt_term *THIS;
+  AV *overlay_av;
   int x, y, w, h;
   int border;
   text_t **text;
   rend_t **rend;
+public:
+  HV *self;
   overlay (rxvt_term *THIS, int x_, int y_, int w_, int h_, rend_t rstyle, int border);
   ~overlay ();
   void show ();
   void hide ();
   void set (int x, int y, SV *str, SV *rend);
 };
 overlay::overlay (rxvt_term *THIS, int x_, int y_, int w_, int h_, rend_t rstyle, int border)
-: THIS(THIS), x(x_), y(y_), w(w_), h(h_), border(border == 2)
+: THIS(THIS), x(x_), y(y_), w(w_), h(h_), border(border == 2), overlay_av (0)
 {
+  if (w < 0) w = 0;
+  if (h < 0) h = 0;
   if (border == 2)
     {
       w += 2;
       h += 2;
     }
             *rp++ = r;
           }
     }
   show ();
-  THIS->want_refresh = 1;
 }
 overlay::~overlay ()
 {
   hide ();
       delete [] rend[y];
     }
   delete [] text;
   delete [] rend;
+}
+void
+overlay::show ()
+{
+  if (overlay_av)
+    return;
+  overlay_av = (AV *)SvREFCNT_inc (SvRV (
+        *hv_fetch ((HV *)SvRV ((SV *)THIS->perl.self), "_overlay", 8, 0)
+     ));
+  av_push (overlay_av, newSViv ((long)this));
   THIS->want_refresh = 1;
 }
 void
-overlay::show ()
-{
-  char key[33]; sprintf (key, "%32lx", (long)this);
-  HV *hv = (HV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)THIS->perl.self), "_overlay", 8, 0));
-  hv_store (hv, key, 32, newSViv ((long)this), 0);
-}
-void
 overlay::hide ()
 {
-  SV **ovs = hv_fetch ((HV *)SvRV ((SV *)THIS->perl.self), "_overlay", 8, 0);
+  if (!overlay_av)
+    return;
-  if (ovs)
+  int i;
-    {
-      char key[33]; sprintf (key, "%32lx", (long)this);
-      HV *hv = (HV *)SvRV (*ovs);
+  for (i = AvFILL (overlay_av); i >= 0; i--)
-      hv_delete (hv, key, 32, G_DISCARD);
+    if (SvIV (*av_fetch (overlay_av, i, 1)) == (long)this)
-    }
+      break;
+  for (; i < AvFILL (overlay_av); i++)
+    av_store (overlay_av, i, SvREFCNT_inc (*av_fetch (overlay_av, i + 1, 0)));
+  av_pop (overlay_av);
+  SvREFCNT_dec (overlay_av);
+  overlay_av = 0;
+  THIS->want_refresh = 1;
 }
 void overlay::swap ()
 {
   int ov_x = max (0, min (MOD (x, THIS->ncol), THIS->ncol - w));
       if (!SvROK (rend) || SvTYPE (SvRV (rend)) != SVt_PVAV)
         croak ("rend must be arrayref");
       AV *av = (AV *)SvRV (rend);
-      for (int col = min (av_len (av) + 1, w - x - border); col--; )
+      for (int col = min (AvFILL (av) + 1, w - x - border); col--; )
         this->rend [y][x + col] = SvIV (*av_fetch (av, col, 1));
     }
   THIS->want_refresh = 1;
 }
   if (perl)
     {
       // runs outside of perls ENV
       term->perl.self = (void *)newSVptr ((void *)term, "urxvt::term");
-      hv_store ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, newRV_noinc ((SV *)newHV ()), 0);
+      hv_store ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, newRV_noinc ((SV *)newAV ()), 0);
     }
 }
 static void
 ungrab (rxvt_term *THIS)
 {
   if (THIS->perl.grabtime)
     {
-      XUngrabKeyboard (THIS->display->display, THIS->perl.grabtime);
+      XUngrabKeyboard (THIS->dpy, THIS->perl.grabtime);
-      XUngrabPointer  (THIS->display->display, THIS->perl.grabtime);
+      XUngrabPointer  (THIS->dpy, THIS->perl.grabtime);
       THIS->perl.grabtime = 0;
     }
 }
-static void
-swap_overlays (rxvt_term *term)
-{
-  HV *hv = (HV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, 0));
-  if (HvKEYS (hv))
-    {
-      hv_iterinit (hv);
-      while (HE *he = hv_iternext (hv))
-        ((overlay *)SvIV (hv_iterval (hv, he)))->swap ();
-    }
-}
 bool
 rxvt_perl_interp::invoke (rxvt_term *term, hook_type htype, ...)
 {
   if (!perl || !term->perl.self)
     return false;
   // pre-handling of some events
   if (htype == HOOK_REFRESH_END)
-    swap_overlays (term);
+    {
+      AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, 0));
+      for (int i = 0; i <= AvFILL (av); i++)
+        ((overlay *)SvIV (*av_fetch (av, i, 0)))->swap ();
+    }
   swap (perl_environ, environ);
   bool event_consumed;
                 break;
               case DT_STR_LEN:
                 {
                   char *str = va_arg (ap, char *);
-                  int len = va_arg (ap, int);
+                  int len   = va_arg (ap, int);
                   XPUSHs (sv_2mortal (newSVpvn (str, len)));
                 }
                 break;
               case DT_WCS_LEN:
                 {
                   wchar_t *wstr = va_arg (ap, wchar_t *);
-                  int wlen = va_arg (ap, int);
+                  int wlen      = va_arg (ap, int);
                   XPUSHs (sv_2mortal (wcs2sv (wstr, wlen)));
+                }
+               break;
+              case DT_LCS_LEN:
+                {
+                  long *lstr = va_arg (ap, long *);
+                  int llen   = va_arg (ap, int);
+                  XPUSHs (sv_2mortal (newSVpvn ((char *)lstr, llen * sizeof (long))));
                 }
                break;
               case DT_XEVENT:
                 {
                   XEvent *xe = va_arg (ap, XEvent *);
                   HV *hv = newHV ();
-#           define set(name, sv) hv_store (hv, # name,  sizeof (# name) - 1, sv, 0)
+#                 define set(name, sv) hv_store (hv, # name,  sizeof (# name) - 1, sv, 0)
-#           define setiv(name, val) hv_store (hv, # name,  sizeof (# name) - 1, newSViv (val), 0)
+#                 define setiv(name, val) hv_store (hv, # name,  sizeof (# name) - 1, newSViv (val), 0)
-#           define setuv(name, val) hv_store (hv, # name,  sizeof (# name) - 1, newSVuv (val), 0)
+#                 define setuv(name, val) hv_store (hv, # name,  sizeof (# name) - 1, newSVuv (val), 0)
-#           undef set
+#                 undef set
                   setiv (type,       xe->type);
                   setiv (send_event, xe->xany.send_event);
                   setiv (serial,     xe->xany.serial);
                         setuv (root,      xe->xmotion.root);
                         setuv (subwindow, xe->xmotion.subwindow);
                         setuv (time,      xe->xmotion.time);
                         setiv (x,         xe->xmotion.x);
                         setiv (y,         xe->xmotion.y);
-                        setiv (row,       xe->xmotion.y / term->fheight);
+                        setiv (row,       xe->xmotion.y / term->fheight + term->view_start);
                         setiv (col,       xe->xmotion.x / term->fwidth);
                         setiv (x_root,    xe->xmotion.x_root);
                         setiv (y_root,    xe->xmotion.y_root);
                         setuv (state,     xe->xmotion.state);
                               setuv (above,  xe->xconfigure.above);
                               break;
                           }
                         break;
+                      case PropertyNotify:
+                        setuv (window,       xe->xproperty.window);
+                        setuv (atom,         xe->xproperty.atom);
+                        setuv (time,         xe->xproperty.time);
+                        setiv (state,        xe->xproperty.state);
+                        break;
+                      case ClientMessage:
+                        setuv (window,       xe->xclient.window);
+                        setuv (message_type, xe->xclient.message_type);
+                        setuv (format,       xe->xclient.format);
+                        setuv (l0,           xe->xclient.data.l[0]);
+                        setuv (l1,           xe->xclient.data.l[1]);
+                        setuv (l2,           xe->xclient.data.l[2]);
+                        setuv (l3,           xe->xclient.data.l[3]);
+                        setuv (l4,           xe->xclient.data.l[4]);
+                        break;
                     }
                   XPUSHs (sv_2mortal (newRV_noinc ((SV *)hv)));
                 }
                 break;
   else
     event_consumed = false;
   // post-handling of some events
   if (htype == HOOK_REFRESH_BEGIN)
-    swap_overlays (term);
+    {
+      AV *av = (AV *)SvRV (*hv_fetch ((HV *)SvRV ((SV *)term->perl.self), "_overlay", 8, 0));
+      for (int i = AvFILL (av); i >= 0; i--)
+        ((overlay *)SvIV (*av_fetch (av, i, 0)))->swap ();
+    }
   else if (htype == HOOK_DESTROY)
     {
       clearSVptr ((SV *)term->perl.self);
       SvREFCNT_dec ((SV *)term->perl.self);
+      // don't allow further calls
+      term->perl.self = 0;
     }
   swap (perl_environ, environ);
   return event_consumed;
 # include "optinc.h"
 # undef nodef
 # undef def
   HV *stash = gv_stashpv ("urxvt", 1);
-  struct {
+  static const struct {
     const char *name;
     IV iv;
   } *civ, const_iv[] = {
 #   define const_iv(name) { # name, (IV)name }
     const_iv (DEFAULT_RSTYLE),
     const_iv (Button2Mask),
     const_iv (Button3Mask),
     const_iv (Button4Mask),
     const_iv (Button5Mask),
     const_iv (AnyModifier),
+    const_iv (NoSymbol),
+    const_iv (GrabModeSync),
+    const_iv (GrabModeAsync),
     const_iv (EVENT_NONE),
     const_iv (EVENT_READ),
     const_iv (EVENT_WRITE),
     const_iv (SelectionRequest),
     const_iv (SelectionNotify),
     const_iv (ColormapNotify),
     const_iv (ClientMessage),
     const_iv (MappingNotify),
+#   if ENABLE_XIM_ONTHESPOT
+    const_iv (XIMReverse),
+    const_iv (XIMUnderline),
+    const_iv (XIMHighlight),
+    const_iv (XIMPrimary),
+    const_iv (XIMSecondary),
+    const_iv (XIMTertiary),
+    const_iv (XIMVisibleToForward),
+    const_iv (XIMVisibleToBackword),
+    const_iv (XIMVisibleToCenter),
+#   if 0
+    const_iv (XIMForwardChar),
+    const_iv (XIMBackwardChar),
+    const_iv (XIMForwardWord),
+    const_iv (XIMBackwardWord),
+    const_iv (XIMCaretUp),
+    const_iv (XIMCaretDown),
+    const_iv (XIMNextLine),
+    const_iv (XIMPreviousLine),
+    const_iv (XIMLineStart),
+    const_iv (XIMLineEnd),
+    const_iv (XIMAbsolutePosition),
+    const_iv (XIMDontChange),
+#   endif
+#   endif
   };
-  for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]);
+  for (civ = const_iv + sizeof (const_iv) / sizeof (const_iv [0]); civ-- > const_iv; )
-       civ-- > const_iv; )
     newCONSTSUB (stash, (char *)civ->name, newSViv (civ->iv));
 }
 void
 warn (const char *msg)
         RETVAL
 int
 SET_FGCOLOR (int rend, int new_color)
 	CODE:
-        RETVAL = SET_FGCOLOR (rend, new_color);
+        RETVAL = SET_FGCOLOR (rend, clamp (new_color, 0, TOTAL_COLORS - 1));
 	OUTPUT:
         RETVAL
 int
 SET_BGCOLOR (int rend, int new_color)
 	CODE:
-        RETVAL = SET_BGCOLOR (rend, new_color);
+        RETVAL = SET_BGCOLOR (rend, clamp (new_color, 0, TOTAL_COLORS - 1));
 	OUTPUT:
         RETVAL
 int
 GET_CUSTOM (int rend)
                | ((new_value << RS_customShift) & RS_customMask);
 }
 	OUTPUT:
         RETVAL
+void
+termlist ()
+	PPCODE:
+{
+        EXTEND (SP, rxvt_term::termlist.size ());
+        for (rxvt_term **t = rxvt_term::termlist.begin (); t < rxvt_term::termlist.end (); t++)
+          if ((*t)->perl.self)
+            PUSHs (sv_2mortal (newSVterm (*t)));
+}
 MODULE = urxvt             PACKAGE = urxvt::term
 SV *
-_new (...)
+_new (AV *env, AV *arg)
 	CODE:
 {
-	if (items < 1 || !SvROK (ST (0)) || SvTYPE (SvRV (ST (0))) != SVt_PVAV)
-          croak ("first argument to urxvt::term->_new must be arrayref");
         rxvt_term *term = new rxvt_term;
-	term->argv = new stringvec;
+	stringvec *argv = new stringvec;
-	term->envv = new stringvec;
+	stringvec *envv = new stringvec;
-        for (int i = 1; i < items; i++)
+        for (int i = 0; i <= AvFILL (arg); i++)
-          term->argv->push_back (strdup (SvPVbyte_nolen (ST (i))));
+          argv->push_back (strdup (SvPVbyte_nolen (*av_fetch (arg, i, 1))));
-        AV *envv = (AV *)SvRV (ST (0));
-        for (int i = av_len (envv) + 1; i--; )
+        for (int i = AvFILL (env) + 1; i--; )
-          term->envv->push_back (strdup (SvPVbyte_nolen (*av_fetch (envv, i, 1))));
+          envv->push_back (strdup (SvPVbyte_nolen (*av_fetch (env, i, 1))));
-        term->envv->push_back (0);
+        envv->push_back (0);
         bool success;
         try
           {
-            success = term->init (term->argv->size (), term->argv->begin ());
+            success = term->init (argv, envv);
           }
         catch (const class rxvt_failure_exception &e)
           {
             success = false;
           }
         RETVAL
 void
 rxvt_term::destroy ()
-#if ENABLE_PERL_FRILLS
-void
-rxvt_term::XListProperties (U32 window)
-	PPCODE:
-{
-	int count;
-	Atom *props = XListProperties (THIS->display->display, (Window)window, &count);
-        EXTEND (SP, count);
-        while (count--)
-          PUSHs (newSVuv ((U32)props [count]));
-        XFree (props);
-}
-void
-rxvt_term::XGetWindowProperty (U32 window, U32 property)
-	PPCODE:
-{
-        Atom type;
-        int format;
-        unsigned long nitems;
-        unsigned long bytes_after;
-        unsigned char *prop;
-	XGetWindowProperty (THIS->display->display, (Window)window, (Atom)property,
-                            0, 1<<30, 0, AnyPropertyType,
-                            &type, &format, &nitems, &bytes_after, &prop);
-        if (type != None)
-          {
-            EXTEND (SP, 3);
-            PUSHs (newSVuv ((U32)type));
-            PUSHs (newSViv (format));
-            PUSHs (newSVpvn ((char *)prop, nitems * format / 8));
-            XFree (prop);
-          }
-}
-void
-rxvt_term::XChangeWindowProperty (U32 window, U32 property, U32 type, int format, SV *data)
-	CODE:
-{
-	STRLEN len;
-        char *data_ = SvPVbyte (data, len);
-	XChangeProperty (THIS->display->display, (Window)window, (Atom)property,
-                         type, format, PropModeReplace,
-                         (unsigned char *)data, len * 8 / format);
-}
-void
-rxvt_term::XDeleteProperty (U32 window, U32 property)
-	CODE:
-        XDeleteProperty (THIS->display->display, (Window)window, (Atom)property);
-U32
-rxvt_term::DefaultRootWindow ()
-	CODE:
-        RETVAL = (U32)THIS->display->root;
-        OUTPUT:
-        RETVAL
-U32
-rxvt_term::XCreateSimpleWindow (U32 parent, int x, int y, unsigned int width, unsigned int height)
-	CODE:
-        RETVAL = XCreateSimpleWindow (THIS->display->display, (Window)parent,
-                                      x, y, width, height, 0,
-                                      THIS->pix_colors_focused[Color_border],
-                                      THIS->pix_colors_focused[Color_border]);
-	OUTPUT:
-        RETVAL
-void
-rxvt_term::XReparentWindow (U32 window, U32 parent, int x = 0, int y = 0)
-	CODE:
-        XReparentWindow (THIS->display->display, (Window)window, (Window)parent, x, y);
-void
-rxvt_term::XMapWindow (U32 window)
-	CODE:
-        XMapWindow (THIS->display->display, (Window)window);
-void
-rxvt_term::XUnmapWindow (U32 window)
-	CODE:
-        XUnmapWindow (THIS->display->display, (Window)window);
-#endif
 void
 rxvt_term::set_should_invoke (int htype, int inc)
 	CODE:
         THIS->perl.should_invoke [htype] += inc;
-void
+int
-rxvt_term::grab_button (int button, U32 modifiers)
+rxvt_term::grab_button (int button, U32 modifiers, Window window = THIS->vt)
 	CODE:
-	XGrabButton (THIS->display->display, button, modifiers, THIS->vt, 1,
+        RETVAL = XGrabButton (THIS->dpy, button, modifiers, window, 1,
-                     ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,
+                              ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,
-                     GrabModeSync, GrabModeSync, None, GRAB_CURSOR);
+                              GrabModeSync, GrabModeSync, None, GRAB_CURSOR);
+	OUTPUT: RETVAL
+int
+rxvt_term::ungrab_button (int button, U32 modifiers, Window window = THIS->vt)
+	CODE:
+        RETVAL = XUngrabButton (THIS->dpy, button, modifiers, window);
+	OUTPUT: RETVAL
+void
+rxvt_term::XGrabKey (int keycode, U32 modifiers, Window window = THIS->vt, \
+                     int owner_events = 1, int pointer_mode = GrabModeAsync, int keyboard_mode = GrabModeAsync)
+	CODE:
+        XGrabKey (THIS->dpy, keycode, modifiers, window, owner_events, pointer_mode, keyboard_mode);
+void
+rxvt_term::XUngrabKey (int keycode, U32 modifiers, Window window = THIS->vt)
+	CODE:
+	XUngrabKey (THIS->dpy, keycode, modifiers, window);
+void
+rxvt_term::XUngrabKeyboard (Time eventtime)
+	CODE:
+	XUngrabKeyboard (THIS->dpy, eventtime);
 bool
-rxvt_term::grab (U32 eventtime, int sync = 0)
+rxvt_term::grab (Time eventtime, int sync = 0)
 	CODE:
 {
         int mode = sync ? GrabModeSync : GrabModeAsync;
         THIS->perl.grabtime = 0;
-        if (!XGrabPointer (THIS->display->display, THIS->vt, 0,
+        if (!XGrabPointer (THIS->dpy, THIS->vt, 0,
                            ButtonPressMask | ButtonReleaseMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask,
                            mode, mode, None, GRAB_CURSOR, eventtime))
-          if (!XGrabKeyboard (THIS->display->display, THIS->vt, 0, mode, mode, eventtime))
+          if (!XGrabKeyboard (THIS->dpy, THIS->vt, 0, mode, mode, eventtime))
             THIS->perl.grabtime = eventtime;
           else
-            XUngrabPointer (THIS->display->display, eventtime);
+            XUngrabPointer (THIS->dpy, eventtime);
         RETVAL = !!THIS->perl.grabtime;
 }
 	OUTPUT:
         RETVAL
 void
 rxvt_term::allow_events_async ()
 	CODE:
-        XAllowEvents (THIS->display->display, AsyncBoth,      THIS->perl.grabtime);
+        XAllowEvents (THIS->dpy, AsyncBoth,      THIS->perl.grabtime);
 void
 rxvt_term::allow_events_sync ()
 	CODE:
-        XAllowEvents (THIS->display->display, SyncBoth,       THIS->perl.grabtime);
+        XAllowEvents (THIS->dpy, SyncBoth,       THIS->perl.grabtime);
 void
 rxvt_term::allow_events_replay ()
 	CODE:
-        XAllowEvents (THIS->display->display, ReplayPointer,  THIS->perl.grabtime);
+        XAllowEvents (THIS->dpy, ReplayPointer,  THIS->perl.grabtime);
-        XAllowEvents (THIS->display->display, ReplayKeyboard, THIS->perl.grabtime);
+        XAllowEvents (THIS->dpy, ReplayKeyboard, THIS->perl.grabtime);
 void
 rxvt_term::ungrab ()
 	CODE:
         ungrab (THIS);
+int
+rxvt_term::XStringToKeysym (char *string)
+	CODE:
+        RETVAL = XStringToKeysym (string);
+	OUTPUT: RETVAL
+char *
+rxvt_term::XKeysymToString (int sym)
+	CODE:
+        RETVAL = XKeysymToString (sym);
+	OUTPUT: RETVAL
+int
+rxvt_term::XKeysymToKeycode (int sym)
+	CODE:
+        RETVAL = XKeysymToKeycode (THIS->dpy, sym);
+	OUTPUT: RETVAL
+int
+rxvt_term::XKeycodeToKeysym (int code, int index)
+	CODE:
+        RETVAL = XKeycodeToKeysym (THIS->dpy, code, index);
+	OUTPUT: RETVAL
 int
 rxvt_term::strwidth (SV *str)
 	CODE:
 {
         wchar_t *wstr = sv2wcs (str);
 	rxvt_push_locale (THIS->locale);
+        //TODO: use same algorithm as screen.C
         RETVAL = wcswidth (wstr, wcslen (wstr));
         rxvt_pop_locale ();
         free (wstr);
 }
 #define TERM_OFFSET_fbase      TERM_OFFSET(fbase)
 #define TERM_OFFSET_nrow       TERM_OFFSET(nrow)
 #define TERM_OFFSET_ncol       TERM_OFFSET(ncol)
 #define TERM_OFFSET_focus      TERM_OFFSET(focus)
 #define TERM_OFFSET_mapped     TERM_OFFSET(mapped)
+#define TERM_OFFSET_int_bwidth TERM_OFFSET(int_bwidth)
+#define TERM_OFFSET_ext_bwidth TERM_OFFSET(ext_bwidth)
+#define TERM_OFFSET_lineSpace  TERM_OFFSET(lineSpace)
 #define TERM_OFFSET_saveLines  TERM_OFFSET(saveLines)
 #define TERM_OFFSET_total_rows TERM_OFFSET(total_rows)
 #define TERM_OFFSET_top_row    TERM_OFFSET(top_row)
 int
            fbase      = TERM_OFFSET_fbase
            nrow       = TERM_OFFSET_nrow
            ncol       = TERM_OFFSET_ncol
            focus      = TERM_OFFSET_focus
            mapped     = TERM_OFFSET_mapped
+           int_bwidth = TERM_OFFSET_int_bwidth
+           ext_bwidth = TERM_OFFSET_ext_bwidth
+           lineSpace  = TERM_OFFSET_lineSpace
            saveLines  = TERM_OFFSET_saveLines
            total_rows = TERM_OFFSET_total_rows
            top_row    = TERM_OFFSET_top_row
 	CODE:
         RETVAL = *(int *)((char *)THIS + ix);
 rxvt_term::ModLevel3Mask ()
 	ALIAS:
            ModLevel3Mask  = 0
            ModMetaMask    = 1
            ModNumLockMask = 2
+           current_screen = 3
+           hidden_cursor  = 4
 	CODE:
         switch (ix)
           {
-           case 0: RETVAL = THIS->ModLevel3Mask;  break;
+            case 0: RETVAL = THIS->ModLevel3Mask;  break;
-           case 1: RETVAL = THIS->ModMetaMask;    break;
+            case 1: RETVAL = THIS->ModMetaMask;    break;
-           case 2: RETVAL = THIS->ModNumLockMask; break;
+            case 2: RETVAL = THIS->ModNumLockMask; break;
+            case 3: RETVAL = THIS->current_screen; break;
+            case 4: RETVAL = THIS->hidden_cursor;  break;
           }
         OUTPUT:
         RETVAL
 char *
           }
         OUTPUT:
         RETVAL
 SV *
-rxvt_term::_env ()
+rxvt_term::envv ()
+	ALIAS:
+        argv = 1
-	CODE:
+	PPCODE:
 {
-        if (THIS->envv)
+	stringvec *vec = ix ? THIS->argv : THIS->envv;
-          {
-            AV *av = newAV ();
+        EXTEND (SP, vec->size ());
-            for (char **i = THIS->envv->begin (); i != THIS->envv->end (); ++i)
+        for (char **i = vec->begin (); i != vec->end (); ++i)
-              if (*i)
+          if (*i)
-                av_push (av, newSVpv (*i, 0));
+            PUSHs (sv_2mortal (newSVpv (*i, 0)));
-            RETVAL = newRV_noinc ((SV *)av);
-          }
-        else
-          RETVAL = &PL_sv_undef;
 }
-        OUTPUT:
-        RETVAL
 int
 rxvt_term::pty_ev_events (int events = EVENT_UNDEF)
 	CODE:
         RETVAL = THIS->pty_ev.events;
         if (events != EVENT_UNDEF)
           THIS->pty_ev.set (events);
 	OUTPUT:
         RETVAL
-U32
+int
+rxvt_term::pty_fd ()
+	CODE:
+        RETVAL = THIS->pty->pty;
+	OUTPUT:
+        RETVAL
+Window
 rxvt_term::parent ()
 	CODE:
-        RETVAL = (U32)THIS->parent [0];
+        RETVAL = THIS->parent [0];
         OUTPUT:
         RETVAL
-U32
+Window
 rxvt_term::vt ()
 	CODE:
-        RETVAL = (U32)THIS->vt;
+        RETVAL = THIS->vt;
         OUTPUT:
         RETVAL
 void
 rxvt_term::vt_emask_add (U32 emask)
 }
         OUTPUT:
 	RETVAL
 void
+rxvt_term::focus_in ()
+void
+rxvt_term::focus_out ()
+void
+rxvt_term::key_press (unsigned int state, unsigned int keycode, Time time = CurrentTime)
+	ALIAS:
+           key_release = 1
+	CODE:
+{
+        XKeyEvent xkey;
+        memset (&xkey, 0, sizeof (xkey));
+        xkey.time      = time;
+        xkey.state     = state;
+        xkey.keycode   = keycode;
+        xkey.type      = ix ? KeyRelease : KeyPress;
+        xkey.display   = THIS->dpy;
+        xkey.window    = THIS->vt;
+        xkey.root      = THIS->display->root;
+        xkey.subwindow = THIS->vt;
+        if (ix)
+          THIS->key_release (xkey);
+        else
+          THIS->key_press (xkey);
+}
+void
 rxvt_term::want_refresh ()
 	CODE:
         THIS->want_refresh = 1;
 void
         line_t &l = ROW(row_number);
         if (GIMME_V != G_VOID)
           {
-            wchar_t *wstr = new wchar_t [THIS->ncol];
+            wchar_t *wstr = rxvt_temp_buf<wchar_t> (THIS->ncol);
             for (int col = 0; col < THIS->ncol; col++)
               wstr [col] = l.t [col];
             XPUSHs (sv_2mortal (wcs2sv (wstr, THIS->ncol)));
-            delete [] wstr;
           }
         if (new_text)
           {
             wchar_t *wstr = sv2wcs (new_text);
             int len = min (wcslen (wstr) - start_ofs, max_len);
-            if (!IN_RANGE_INC (start_col, 0, THIS->ncol - len))
+            if (start_col < 0 || start_col + len > THIS->ncol)
               {
                 free (wstr);
                 croak ("new_text extends beyond horizontal margins");
               }
           {
             if (!SvROK (new_rend) || SvTYPE (SvRV (new_rend)) != SVt_PVAV)
               croak ("new_rend must be arrayref");
             AV *av = (AV *)SvRV (new_rend);
-            int len = min (av_len (av) + 1 - start_ofs, max_len);
+            int len = min (AvFILL (av) + 1 - start_ofs, max_len);
-            if (!IN_RANGE_INC (start_col, 0, THIS->ncol - len))
+            if (start_col < 0 || start_col + len > THIS->ncol)
               croak ("new_rend array extends beyond horizontal margins");
             for (int col = start_col; col < start_col + len; col++)
               {
                 rend_t r = SvIV (*av_fetch (av, start_ofs + col - start_col, 1)) & ~RS_fontMask;
 rxvt_term::special_encode (SV *string)
 	CODE:
 {
         wchar_t *wstr = sv2wcs (string);
         int wlen = wcslen (wstr);
-        wchar_t *rstr = new wchar_t [wlen]; // cannot become longer
+        wchar_t *rstr = rxvt_temp_buf<wchar_t> (wlen * 2); // cannot become longer
 	rxvt_push_locale (THIS->locale);
         wchar_t *r = rstr;
         for (wchar_t *s = wstr; *s; s++)
+          {
+            int w = WCWIDTH (*s);
-          if (wcwidth (*s) == 0)
+            if (w == 0)
-            {
+              {
-              if (r == rstr)
+                if (r == rstr)
-                croak ("leading combining character unencodable");
+                  croak ("leading combining character unencodable");
-              unicode_t n = rxvt_compose (r[-1], *s);
+                unicode_t n = rxvt_compose (r[-1], *s);
-              if (n == NOCHAR)
+                if (n == NOCHAR)
-                n = rxvt_composite.compose (r[-1], *s);
+                  n = rxvt_composite.compose (r[-1], *s);
-              r[-1] = n;
+                r[-1] = n;
-            }
+              }
 #if !UNICODE_3
-          else if (*s >= 0x10000)
+            else if (*s >= 0x10000)
-            *r++ = rxvt_composite.compose (*s);
+              *r++ = rxvt_composite.compose (*s);
 #endif
-          else
+            else
-            *r++ = *s;
+              *r++ = *s;
+            // the *2 above only allows wcwidth <= 2
+            if (w > 1)
+              *r++ = NOCHAR;
+          }
 	rxvt_pop_locale ();
         RETVAL = wcs2sv (rstr, r - rstr);
-        delete [] rstr;
 }
 	OUTPUT:
         RETVAL
 SV *
           else if (IS_COMPOSE (*s))
             dlen += rxvt_composite.expand (*s, 0);
           else
             dlen++;
-        wchar_t *rstr = new wchar_t [dlen];
+        wchar_t *rstr = rxvt_temp_buf<wchar_t> (dlen);
         // decode
         wchar_t *r = rstr;
         for (wchar_t *s = wstr; *s; s++)
           if (*s == NOCHAR)
             r += rxvt_composite.expand (*s, r);
           else
             *r++ = *s;
         RETVAL = wcs2sv (rstr, r - rstr);
-        delete [] rstr;
 }
 	OUTPUT:
         RETVAL
 void
 rxvt_term::_resource (char *name, int index, SV *newval = 0)
 	PPCODE:
 {
-	struct resval { const char *name; int value; } rslist [] = {
+	static const struct resval { const char *name; int value; } *rs, rslist [] = {
 #	  define def(name) { # name, Rs_ ## name },
 #	  define reserve(name,count)
 #	  include "rsinc.h"
 #	  undef def
 #	  undef reserve
         };
-        struct resval *rs = rslist + sizeof (rslist) / sizeof (rslist [0]);
+        rs = rslist + sizeof (rslist) / sizeof (rslist [0]);
         do {
           if (rs-- == rslist)
             croak ("no such resource '%s', requested", name);
         } while (strcmp (name, rs->name));
             if (set)
               THIS->options |= optval;
             else
               THIS->options &= ~optval;
+            if (THIS->check_ev.is_active ()) // avoid doing this before START
-            switch (optval)
+              switch (optval)
-              {
+                {
-                case Opt_skipBuiltinGlyphs:
+                  case Opt_skipBuiltinGlyphs:
-                  THIS->set_fonts ();
+                    THIS->set_fonts ();
-                  THIS->scr_remap_chars ();
+                    THIS->scr_remap_chars ();
-                  THIS->scr_touch (true);
+                    THIS->scr_touch (true);
-                  THIS->want_refresh = 1;
+                    THIS->want_refresh = 1;
-                  break;
+                    break;
-                case Opt_cursorUnderline:
+                  case Opt_cursorUnderline:
-                  THIS->want_refresh = 1;
+                    THIS->want_refresh = 1;
-                  break;
+                    break;
 #                  case Opt_scrollBar_floating:
 #                  case Opt_scrollBar_right:
 #                    THIS->resize_all_windows (THIS->width, THIS->height, 1);
 #                    break;
-              }
+                }
           }
 }
         OUTPUT:
         RETVAL
         if (items == 3)
           {
             rc.row = SvIV (ST (1));
             rc.col = SvIV (ST (2));
-            if (ix == 2 && rc.col == 0)
+            if (ix == 2)
               {
+                if (rc.col == 0)
+                  {
+                    // col == 0 means end of previous line
-                rc.row--;
+                    rc.row--;
-                rc.col = THIS->ncol;
+                    rc.col = THIS->ncol;
+                  }
+                else if (IN_RANGE_EXC (rc.row, THIS->top_row, THIS->nrow)
+                         && rc.col > ROW(rc.row).l)
+                  {
+                    // col >= length means while line and add newline
+                    rc.col = THIS->ncol;
+                  }
               }
             clamp_it (rc.col, 0, THIS->ncol);
             clamp_it (rc.row, THIS->top_row, THIS->nrow - 1);
 	CODE:
         RETVAL = THIS->charsets [THIS->screen.charset];
 	OUTPUT:
         RETVAL
-#void
+void
-#rxvt_term::selection_clear ()
+rxvt_term::selection_clear ()
 void
-rxvt_term::selection_make (U32 eventtime, bool rect = false)
+rxvt_term::selection_make (Time eventtime, bool rect = false)
 	CODE:
         THIS->selection.op = SELECTION_CONT;
         THIS->selection.rect = rect;
         THIS->selection_make (eventtime);
 int
-rxvt_term::selection_grab (U32 eventtime)
+rxvt_term::selection_grab (Time eventtime)
 void
 rxvt_term::selection (SV *newtext = 0)
         PPCODE:
 {
 void
 rxvt_term::scr_xor_span (int beg_row, int beg_col, int end_row, int end_col, U32 rstyle = RS_RVid)
 void
 rxvt_term::scr_bell ()
+void
+rxvt_term::scr_change_screen (int screen)
 void
 rxvt_term::scr_add_lines (SV *string)
 	CODE:
 {
         o->self = (HV *)SvRV (RETVAL);
 }
 	OUTPUT:
         RETVAL
+#############################################################################
+# Various X Utility Functions
+#############################################################################
+void
+rxvt_term::XListProperties (Window window)
+	PPCODE:
+{
+	int count;
+	Atom *props = XListProperties (THIS->dpy, window, &count);
+        EXTEND (SP, count);
+        while (count--)
+          PUSHs (newSVuv ((U32)props [count]));
+        XFree (props);
+}
+void
+rxvt_term::XGetWindowProperty (Window window, Atom property)
+	PPCODE:
+{
+        Atom type;
+        int format;
+        unsigned long nitems;
+        unsigned long bytes_after;
+        unsigned char *prop;
+	XGetWindowProperty (THIS->dpy, window, property,
+                            0, 1<<24, 0, AnyPropertyType,
+                            &type, &format, &nitems, &bytes_after, &prop);
+        if (type != None)
+          {
+            int elemsize = format == 16 ? sizeof (short)
+                         : format == 32 ? sizeof (long)
+                         :                1;
+            EXTEND (SP, 3);
+            PUSHs (newSVuv ((U32)type));
+            PUSHs (newSViv (format));
+            PUSHs (newSVpvn ((char *)prop, nitems * elemsize));
+            XFree (prop);
+          }
+}
+void
+rxvt_term::XChangeWindowProperty (Window window, Atom property, Atom type, int format, SV *data)
+	CODE:
+{
+	STRLEN len;
+        char *data_ = SvPVbyte (data, len);
+        int elemsize = format == 16 ? sizeof (short)
+                     : format == 32 ? sizeof (long)
+                     :                1;
+	XChangeProperty (THIS->dpy, window, property,
+                         type, format, PropModeReplace,
+                         (unsigned char *)data_, len / elemsize);
+}
+Atom
+XInternAtom (rxvt_term *term, char *atom_name, int only_if_exists = FALSE)
+	C_ARGS: term->dpy, atom_name, only_if_exists
+char *
+XGetAtomName (rxvt_term *term, Atom atom)
+	C_ARGS: term->dpy, atom
+        CLEANUP:
+        XFree (RETVAL);
+void
+XDeleteProperty (rxvt_term *term, Window window, Atom property)
+  	C_ARGS: term->dpy, window, property
+Window
+rxvt_term::DefaultRootWindow ()
+	CODE:
+        RETVAL = THIS->display->root;
+        OUTPUT:
+        RETVAL
+#if 0
+Window
+XCreateSimpleWindow (rxvt_term *term, Window parent, int x, int y, unsigned int width, unsigned int height)
+	C_ARGS: term->dpy, (Window)parent,
+                x, y, width, height, 0,
+                term->pix_colors_focused[Color_border],
+                term->pix_colors_focused[Color_border]
+#endif
+void
+XReparentWindow (rxvt_term *term, Window window, Window parent, int x = 0, int y = 0)
+	C_ARGS: term->dpy, window, parent, x, y
+void
+XMapWindow (rxvt_term *term, Window window)
+	C_ARGS: term->dpy, window
+void
+XUnmapWindow (rxvt_term *term, Window window)
+	C_ARGS: term->dpy, window
+void
+XMoveResizeWindow (rxvt_term *term, Window window, int x, int y, unsigned int width, unsigned int height)
+	C_ARGS: term->dpy, window, x, y, width, height
+void
+rxvt_term::XChangeInput (Window window, U32 add_events, U32 del_events = 0)
+	CODE:
+{
+	XWindowAttributes attr;
+        XGetWindowAttributes (THIS->dpy, window, &attr);
+        XSelectInput (THIS->dpy, window, attr.your_event_mask | add_events & ~del_events);
+}
+void
+rxvt_term::XTranslateCoordinates (Window src, Window dst, int x, int y)
+	PPCODE:
+{
+        int dx, dy;
+        Window child;
+        if (XTranslateCoordinates (THIS->dpy, src, dst, x, y, &dx, &dy, &child))
+          {
+            EXTEND (SP, 3);
+            PUSHs (newSViv (dx));
+            PUSHs (newSViv (dy));
+            PUSHs (newSVuv (child));
+          }
+}
+#############################################################################
+# urxvt::overlay
+#############################################################################
 MODULE = urxvt             PACKAGE = urxvt::overlay
 void
 overlay::set (int x, int y, SV *text, SV *rend = 0)
 void
 overlay::hide ()
 void
 overlay::DESTROY ()
+#############################################################################
+# urxvt::watcher
+#############################################################################
+MODULE = urxvt             PACKAGE = urxvt::watcher
+CHAINED
+perl_watcher::cb (SV *cb)
+	CODE:
+        THIS->cb (cb);
+        OUTPUT:
+        RETVAL
+#############################################################################
+# urxvt::timer
+#############################################################################
 MODULE = urxvt             PACKAGE = urxvt::timer
 SV *
 timer::new ()
 	CODE:
         timer *w =  new timer;
         w->start (NOW);
-        RETVAL = newSVptr ((void *)w, "urxvt::timer");
+        RETVAL = newSVptr ((void *)(perl_watcher *)w, "urxvt::timer");
         w->self = (HV *)SvRV (RETVAL);
-        OUTPUT:
-        RETVAL
-timer *
-timer::cb (SV *cb)
-	CODE:
-        THIS->cb (cb);
-        RETVAL = THIS;
         OUTPUT:
         RETVAL
 NV
 timer::at ()
 	CODE:
         RETVAL = THIS->at;
         OUTPUT:
         RETVAL
-timer *
+CHAINED
 timer::interval (NV interval)
 	CODE:
         THIS->interval = interval;
+        OUTPUT:
-        RETVAL = THIS;
+        RETVAL
-        OUTPUT:
-        RETVAL
-timer *
+CHAINED
 timer::set (NV tstamp)
 	CODE:
         THIS->set (tstamp);
+        OUTPUT:
-        RETVAL = THIS;
+        RETVAL
-        OUTPUT:
-        RETVAL
-timer *
+CHAINED
 timer::start (NV tstamp = THIS->at)
-        CODE:
+	CODE:
         THIS->start (tstamp);
+        OUTPUT:
-        RETVAL = THIS;
+        RETVAL
-        OUTPUT:
-        RETVAL
-timer *
+CHAINED
 timer::after (NV delay)
 	CODE:
         THIS->start (NOW + delay);
         OUTPUT:
         RETVAL
-timer *
+CHAINED
 timer::stop ()
 	CODE:
         THIS->stop ();
-        RETVAL = THIS;
         OUTPUT:
         RETVAL
 void
 timer::DESTROY ()
+#############################################################################
+# urxvt::iow
+#############################################################################
 MODULE = urxvt             PACKAGE = urxvt::iow
 SV *
 iow::new ()
 	CODE:
         iow *w =  new iow;
-        RETVAL = newSVptr ((void *)w, "urxvt::iow");
+        RETVAL = newSVptr ((void *)(perl_watcher *)w, "urxvt::iow");
         w->self = (HV *)SvRV (RETVAL);
         OUTPUT:
         RETVAL
-iow *
+CHAINED
-iow::cb (SV *cb)
-	CODE:
-        THIS->cb (cb);
-        RETVAL = THIS;
-        OUTPUT:
-        RETVAL
-iow *
 iow::fd (int fd)
 	CODE:
         THIS->fd = fd;
+        OUTPUT:
-        RETVAL = THIS;
+        RETVAL
-        OUTPUT:
-        RETVAL
-iow *
+CHAINED
 iow::events (short events)
 	CODE:
         THIS->events = events;
+        OUTPUT:
-        RETVAL = THIS;
+        RETVAL
-        OUTPUT:
-        RETVAL
-iow *
+CHAINED
 iow::start ()
-        CODE:
+	CODE:
         THIS->start ();
+        OUTPUT:
-        RETVAL = THIS;
+        RETVAL
-        OUTPUT:
-        RETVAL
-iow *
+CHAINED
 iow::stop ()
 	CODE:
         THIS->stop ();
-        RETVAL = THIS;
         OUTPUT:
         RETVAL
 void
 iow::DESTROY ()
+#############################################################################
+# urxvt::iw
+#############################################################################
+MODULE = urxvt             PACKAGE = urxvt::iw
+SV *
+iw::new ()
+	CODE:
+        iw *w =  new iw;
+        RETVAL = newSVptr ((void *)(perl_watcher *)w, "urxvt::iw");
+        w->self = (HV *)SvRV (RETVAL);
+        OUTPUT:
+        RETVAL
+CHAINED
+iw::start ()
+	CODE:
+        THIS->start ();
+        OUTPUT:
+        RETVAL
+CHAINED
+iw::stop ()
+	CODE:
+        THIS->stop ();
+        OUTPUT:
+        RETVAL
+void
+iw::DESTROY ()
+#############################################################################
+# urxvt::pw
+#############################################################################
+MODULE = urxvt             PACKAGE = urxvt::pw
+SV *
+pw::new ()
+	CODE:
+        pw *w =  new pw;
+        RETVAL = newSVptr ((void *)(perl_watcher *)w, "urxvt::pw");
+        w->self = (HV *)SvRV (RETVAL);
+        OUTPUT:
+        RETVAL
+CHAINED
+pw::start (int pid)
+	CODE:
+        THIS->start (pid);
+        OUTPUT:
+        RETVAL
+CHAINED
+pw::stop ()
+	CODE:
+        THIS->stop ();
+        OUTPUT:
+        RETVAL
+void
+pw::DESTROY ()

Diff Legend

-–
+Removed lines
-+
+Added lines
-<
+Changed lines
->
+Changed lines

Comparing rxvt-unicode/src/rxvtperl.xs (file contents): Revision 1.75 by root, Wed Jan 18 11:05:09 2006 UTC vs. Revision 1.104 by root, Mon Aug 7 22:28:18 2006 UTC

Diff Legend

Comparing rxvt-unicode/src/rxvtperl.xs (file contents):
Revision 1.75 by root, Wed Jan 18 11:05:09 2006 UTC vs.
Revision 1.104 by root, Mon Aug 7 22:28:18 2006 UTC