rxvt-unicode/src/rxvttoolkit.C

/*--------------------------------*-C-*---------------------------------*
 * File:        rxvttoolkit.C
 *----------------------------------------------------------------------*
 *
 * All portions of code are copyright by their respective author/s.
 * Copyright (c) 2003-2004 Marc Lehmann <pcg@goof.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *----------------------------------------------------------------------*/

#include "../config.h"
#include <rxvt.h>
#include <rxvttoolkit.h>

#include <unistd.h>
#include <fcntl.h>

#include <sys/utsname.h>

#ifndef NO_SLOW_LINK_SUPPORT
# include <sys/socket.h>
# include <sys/un.h>
#endif

#if XFT
# include <X11/extensions/Xrender.h>
#endif

const char *const xa_names[] =
{
  "TEXT",
  "COMPOUND_TEXT",
  "UTF8_STRING",
  "MULTIPLE",
  "TARGETS",
  "TIMESTAMP",
  "VT_SELECTION",
  "INCR",
  "WM_PROTOCOLS",
  "WM_DELETE_WINDOW",
  "CLIPBOARD",
  "AVERAGE_WIDTH",
  "WEIGHT_NAME",
  "SLANT",
  "CHARSET_REGISTRY",
  "CHARSET_ENCODING",
#if ENABLE_FRILLS
  "_MOTIF_WM_HINTS",
#endif
#if ENABLE_EWMH
  "_NET_WM_PID",
  "_NET_WM_NAME",
  "_NET_WM_ICON_NAME",
  "_NET_WM_PING",
#endif
#if USE_XIM
  "WM_LOCALE_NAME",
  "XIM_SERVERS",
#endif
#ifdef TRANSPARENT
  "_XROOTPMAP_ID",
  "ESETROOT_PMAP_ID",
#endif
#if ENABLE_XEMBED
  "_XEMBED",
  "_XEMBED_INFO",
#endif
#if !ENABLE_MINIMAL
  "SCREEN_RESOURCES",
  "XDCCC_LINEAR_RGB_CORRECTION",
  "XDCCC_LINEAR_RGB_MATRICES",
  "WM_COLORMAP_WINDOWS",
  "WM_STATE",
#endif
};

/////////////////////////////////////////////////////////////////////////////

refcounted::refcounted (const char *id)
{
  this->id = strdup (id);
}

refcounted::~refcounted ()
{
  free (id);
}

template<class T>
T *refcache<T>::get (const char *id)
{
  for (T **i = this->begin (); i < this->end (); ++i)
    {
      if (!strcmp (id, (*i)->id))
        {
          ++(*i)->referenced;
          (*i)->ref_next ();
          return *i;
        }
    }

  T *obj = new T (id);

  if (obj && obj->ref_init ())
    {
      obj->referenced = 1;
      this->push_back (obj);
      return obj;
    }
  else
    {
      delete obj;
      return 0;
    }
}

template<class T>
void refcache<T>::put (T *obj)
{
  if (!obj)
    return;

  if (!--obj->referenced)
    {
      this->erase (find (this->begin (), this->end (), obj));
      delete obj;
    }
}

template<class T>
void refcache<T>::clear ()
{
  while (this->size ())
    put (*this->begin ());
}

/////////////////////////////////////////////////////////////////////////////

#ifdef USE_XIM

static void
#if XIMCB_PROTO_BROKEN
im_destroy_cb (XIC unused1, XPointer client_data, XPointer unused3)
#else
im_destroy_cb (XIM unused1, XPointer client_data, XPointer unused3)
#endif
{
  rxvt_xim *xim = (rxvt_xim *)client_data;
  rxvt_display *display = xim->display;

  xim->xim = 0;

  display->xims.erase (find (display->xims.begin (), display->xims.end (), xim));
  display->im_change_cb ();
}

bool
rxvt_xim::ref_init ()
{
  display = GET_R->display; //HACK: TODO

  xim = XOpenIM (display->display, NULL, NULL, NULL);

  if (!xim)
    return false;

  XIMCallback ximcallback;
  ximcallback.client_data = (XPointer)this;
  ximcallback.callback = im_destroy_cb;

  XSetIMValues (xim, XNDestroyCallback, &ximcallback, NULL);

  return true;
}

rxvt_xim::~rxvt_xim ()
{
  if (xim)
    XCloseIM (xim);
}

#endif

/////////////////////////////////////////////////////////////////////////////

void
rxvt_screen::set (rxvt_display *disp)
{
  display = disp;
  xdisp   = disp->display;

  Screen *screen = ScreenOfDisplay (xdisp, disp->screen);

  depth   = DefaultDepthOfScreen    (screen);
  visual  = DefaultVisualOfScreen   (screen);
  cmap    = DefaultColormapOfScreen (screen);
}

void
rxvt_screen::set (rxvt_display *disp, int bitdepth)
{
  set (disp);

#if XFT
  XVisualInfo vinfo;

  if (XMatchVisualInfo (xdisp, display->screen, bitdepth, TrueColor, &vinfo))
    {
      depth  = bitdepth;
      visual = vinfo.visual;
      cmap   = XCreateColormap (xdisp, disp->root, visual, AllocNone);
    }
#endif
}

void
rxvt_screen::clear ()
{
  if (cmap != DefaultColormapOfScreen (ScreenOfDisplay (xdisp, display->screen)))
    XFreeColormap (xdisp, cmap);
}

/////////////////////////////////////////////////////////////////////////////

rxvt_display::rxvt_display (const char *id)
: refcounted (id)
, x_ev (this, &rxvt_display::x_cb)
, selection_owner (0)
{
}

XrmDatabase
rxvt_display::get_resources ()
{
  char *homedir = (char *)getenv ("HOME");
  char fname[1024];

  /*
   * get resources using the X library function
   */
  char *displayResource, *xe;
  XrmDatabase database, rdb1;

  database = NULL;

  // for ordering, see for example http://www.faqs.org/faqs/Xt-FAQ/ Subject: 20

  // 6. System wide per application default file.

  /* Add in $XAPPLRESDIR/Rxvt only; not bothering with XUSERFILESEARCHPATH */
  if ((xe = (char *)getenv ("XAPPLRESDIR")))
    {
      snprintf (fname, sizeof (fname), "%s/%s", xe, RESCLASS);

      if ((rdb1 = XrmGetFileDatabase (fname)))
        XrmMergeDatabases (rdb1, &database);
    }

  // 5. User's per application default file.
  // none

  // 4. User's defaults file.
  /* Get any Xserver defaults */
  displayResource = XResourceManagerString (display);

  if (displayResource != NULL)
    {
      if ((rdb1 = XrmGetStringDatabase (displayResource)))
        XrmMergeDatabases (rdb1, &database);
    }
  else if (homedir)
    {
      snprintf (fname, sizeof (fname), "%s/.Xdefaults", homedir);

      if ((rdb1 = XrmGetFileDatabase (fname)))
        XrmMergeDatabases (rdb1, &database);
    }

  /* Get screen specific resources */
  displayResource = XScreenResourceString (ScreenOfDisplay (display, screen));

  if (displayResource != NULL)
    {
      if ((rdb1 = XrmGetStringDatabase (displayResource)))
        /* Merge with screen-independent resources */
        XrmMergeDatabases (rdb1, &database);

      XFree (displayResource);
    }

  // 3. User's per host defaults file
  /* Add in XENVIRONMENT file */
  if ((xe = (char *)getenv ("XENVIRONMENT"))
      && (rdb1 = XrmGetFileDatabase (xe)))
    XrmMergeDatabases (rdb1, &database);
  else if (homedir)
    {
      struct utsname un;

      if (!uname (&un))
        {
          snprintf (fname, sizeof (fname), "%s/.Xdefaults-%s", homedir, un.nodename);

          if ((rdb1 = XrmGetFileDatabase (fname)))
            XrmMergeDatabases (rdb1, &database);
        }
    }

  return database;
}

bool rxvt_display::ref_init ()
{
#ifdef LOCAL_X_IS_UNIX
  if (id[0] == ':')
    {
      val = rxvt_malloc (5 + strlen (id) + 1);
      strcpy (val, "unix/");
      strcat (val, id);
      display = XOpenDisplay (val);
      free (val);
    }
  else
#endif
    display = 0;

  if (!display)
    display = XOpenDisplay (id);

  if (!display)
    return false;

  screen = DefaultScreen (display);
  root   = DefaultRootWindow (display);

  assert (sizeof (xa_names) / sizeof (char *) == NUM_XA);
  XInternAtoms (display, (char **)xa_names, NUM_XA, False, xa);

  XrmSetDatabase (display, get_resources ());

#ifdef POINTER_BLANK
  XColor blackcolour;
  blackcolour.red   = 0;
  blackcolour.green = 0;
  blackcolour.blue  = 0;
  Font f = XLoadFont (display, "fixed");
  blank_cursor = XCreateGlyphCursor (display, f, f, ' ', ' ',
                                     &blackcolour, &blackcolour);
  XUnloadFont (display, f);
#endif

  int fd = XConnectionNumber (display);

#ifndef NO_SLOW_LINK_SUPPORT
  // try to detect wether we have a local connection.
  // assume unix domains socket == local, everything else not
  // TODO: might want to check for inet/127.0.0.1
  is_local = 0;
  sockaddr_un sa;
  socklen_t sl = sizeof (sa);

  if (!getsockname (fd, (sockaddr *)&sa, &sl))
    is_local = sa.sun_family == AF_LOCAL;
#endif

  x_ev.start (fd, EVENT_READ);
  fcntl (fd, F_SETFD, FD_CLOEXEC);

  XSelectInput (display, root, PropertyChangeMask);

  flush ();

  return true;
}

void
rxvt_display::ref_next ()
{
  // TODO: somehow check wether the database files/resources changed
  // before re-loading/parsing
  XrmDestroyDatabase (XrmGetDatabase (display));
  XrmSetDatabase (display, get_resources ());
}

rxvt_display::~rxvt_display ()
{
  if (!display)
    return;

#ifdef POINTER_BLANK
  XFreeCursor (display, blank_cursor);
#endif
  x_ev.stop ();
#ifdef USE_XIM
  xims.clear ();
#endif
  XCloseDisplay (display);
}

#ifdef USE_XIM
void rxvt_display::im_change_cb ()
{
  for (im_watcher **i = imw.begin (); i != imw.end (); ++i)
    (*i)->call ();
}

void rxvt_display::im_change_check ()
{
  // try to only call im_change_cb when a new input method
  // registers, as xlib crashes due to a race otherwise.
  Atom actual_type, *atoms;
  int actual_format;
  unsigned long nitems, bytes_after;

  if (XGetWindowProperty (display, root, xa[XA_XIM_SERVERS], 0L, 1000000L,
                          False, XA_ATOM, &actual_type, &actual_format,
                          &nitems, &bytes_after, (unsigned char **)&atoms)
      != Success )
    return;

  if (actual_type == XA_ATOM  && actual_format == 32)
    for (int i = 0; i < nitems; i++)
      if (XGetSelectionOwner (display, atoms[i]))
        {
          im_change_cb ();
          break;
        }

  XFree (atoms);
}
#endif

void rxvt_display::x_cb (io_watcher &w, short revents)
{
  do
    {
      XEvent xev;
      XNextEvent (display, &xev);

#ifdef USE_XIM
      if (!XFilterEvent (&xev, None))
        {
          if (xev.type == PropertyNotify
              && xev.xany.window == root
              && xev.xproperty.atom == xa[XA_XIM_SERVERS])
            im_change_check ();
#endif
          for (int i = xw.size (); i--; )
            {
              if (!xw[i])
                xw.erase_unordered (i);
              else if (xw[i]->window == xev.xany.window)
                xw[i]->call (xev);
            }
#ifdef USE_XIM
        }
#endif
    }
  while (XEventsQueued (display, QueuedAlready));

  XFlush (display);
}

void rxvt_display::flush ()
{
  if (XEventsQueued (display, QueuedAlready))
    x_cb (x_ev, EVENT_READ);

  XFlush (display);
}

void rxvt_display::reg (xevent_watcher *w)
{
  xw.push_back (w);
  w->active = xw.size ();
}

void rxvt_display::unreg (xevent_watcher *w)
{
  if (w->active)
    xw[w->active - 1] = 0;
}

void rxvt_display::set_selection_owner (rxvt_term *owner)
{
  if (selection_owner && selection_owner != owner)
    selection_owner->selection_clear ();

  selection_owner = owner;
}

#ifdef USE_XIM
void rxvt_display::reg (im_watcher *w)
{
  imw.push_back (w);
}

void rxvt_display::unreg (im_watcher *w)
{
  imw.erase (find (imw.begin (), imw.end (), w));
}

rxvt_xim *rxvt_display::get_xim (const char *locale, const char *modifiers)
{
  char *id;
  int l, m;

  l = strlen (locale);
  m = strlen (modifiers);

  if (!(id = (char *)malloc (l + m + 2)))
    return 0;

  memcpy (id, locale, l); id[l] = '\n';
  memcpy (id + l + 1, modifiers, m); id[l + m + 1] = 0;

  rxvt_xim *xim = xims.get (id);

  free (id);

  return xim;
}

void rxvt_display::put_xim (rxvt_xim *xim)
{
#if XLIB_IS_RACEFREE
  xims.put (xim);
#endif
}
#endif

Atom rxvt_display::atom (const char *name)
{
  return XInternAtom (display, name, False);
}

/////////////////////////////////////////////////////////////////////////////

template class refcache<rxvt_display>;
refcache<rxvt_display> displays;

/////////////////////////////////////////////////////////////////////////////
  
bool
rxvt_color::set (rxvt_screen *screen, const char *name)
{
#if XFT
  int l = strlen (name);
  rxvt_rgba r;
  char eos;
  int mult;

  // shortcutting this saves countless server RTTs for the built-in colours
  if (l == 3+3*3 && 3 == sscanf (name, "rgb:%hx/%hx/%hx/%hx%c", &r.r, &r.g, &r.b, &r.a, &eos))
    {
      r.a  = rxvt_rgba::MAX_CC;
      mult = rxvt_rgba::MAX_CC / 0x00ff;
    }

  // parse a number of non-standard ARGB colour specifications
  else if (     l == 1+4*1 && 4 == sscanf (name, "#%1hx%1hx%1hx%1hx%c", &r.a, &r.r, &r.g, &r.b, &eos))
    mult = rxvt_rgba::MAX_CC / 0x000f;
  else if (l == 1+4*2 && 4 == sscanf (name, "#%2hx%2hx%2hx%2hx%c", &r.a, &r.r, &r.g, &r.b, &eos))
    mult = rxvt_rgba::MAX_CC / 0x00ff;
  else if (l == 1+4*4 && 4 == sscanf (name, "#%4hx%4hx%4hx%4hx%c", &r.a, &r.r, &r.g, &r.b, &eos))
    mult = rxvt_rgba::MAX_CC / 0xffff;
  else if (l == 4+5*4 && 4 == sscanf (name, "rgba:%hx/%hx/%hx/%hx%c", &r.r, &r.g, &r.b, &r.a, &eos))
    mult = rxvt_rgba::MAX_CC / 0xffff;

  // slow case: server round trip
  else
    return XftColorAllocName (screen->xdisp, screen->visual, screen->cmap, name, &c);

  r.r *= mult; r.g *= mult; r.b *= mult; r.a *= mult;

  return set (screen, r);
#else
  XColor xc;

  if (XParseColor (screen->xdisp, screen->cmap, name, &xc))
    return set (screen, rxvt_rgba (xc.red, xc.green, xc.blue));

  return false;
#endif
}

bool
rxvt_color::set (rxvt_screen *screen, rxvt_rgba rgba)
{
#if XFT
  XRenderPictFormat *format;

  // FUCKING Xft gets it wrong, of course, so work around it
  // transparency users should eat shit and die, and then
  // XRenderQueryPictIndexValues themselves plenty.
  if (screen->visual->c_class == TrueColor
      && (format = XRenderFindVisualFormat (screen->xdisp, screen->visual)))
    {
      // the fun lies in doing everything manually...
      c.color.red   = rgba.r;
      c.color.green = rgba.g;
      c.color.blue  = rgba.b;
      c.color.alpha = rgba.a;

      c.pixel = ((rgba.r * format->direct.redMask   / rxvt_rgba::MAX_CC) << format->direct.red  )
              | ((rgba.g * format->direct.greenMask / rxvt_rgba::MAX_CC) << format->direct.green)
              | ((rgba.b * format->direct.blueMask  / rxvt_rgba::MAX_CC) << format->direct.blue )
              | ((rgba.a * format->direct.alphaMask / rxvt_rgba::MAX_CC) << format->direct.alpha);

      return true;
    }
  else
    {
      XRenderColor d;

      d.red   = rgba.r;
      d.green = rgba.g;
      d.blue  = rgba.b;
      d.alpha = rgba.a;

      return XftColorAllocValue (screen->xdisp, screen->visual, screen->cmap, &d, &c);
    }

  return false;
#else
  XColor xc;

  xc.red   = rgba.r;
  xc.green = rgba.g;
  xc.blue  = rgba.b;
  xc.flags = DoRed | DoGreen | DoBlue;

  if (XAllocColor (screen->xdisp, screen->cmap, &xc))
    {
      p = xc.pixel;
      return true;
    }

  return false;
#endif
}

void 
rxvt_color::get (rxvt_screen *screen, rxvt_rgba &rgba)
{
#if XFT
  rgba.r = c.color.red;
  rgba.g = c.color.green;
  rgba.b = c.color.blue;
  rgba.a = c.color.alpha;
#else
  XColor c;

  c.pixel = p;
  XQueryColor (screen->xdisp, screen->cmap, &c);

  rgba.r = c.red;
  rgba.g = c.green;
  rgba.b = c.blue;
  rgba.a = rxvt_rgba::MAX_CC;
#endif
}

void 
rxvt_color::free (rxvt_screen *screen)
{
#if XFT
  XftColorFree (screen->xdisp, screen->visual, screen->cmap, &c);
#else
  XFreeColors (screen->xdisp, screen->cmap, &p, 1, AllPlanes);
#endif
}

rxvt_color
rxvt_color::fade (rxvt_screen *screen, int percent)
{
  rxvt_color faded;

  rxvt_rgba c;
  get (screen, c);

  c.r = lerp (0, c.r, percent);
  c.g = lerp (0, c.g, percent);
  c.b = lerp (0, c.b, percent);

  faded.set (screen, c);

  return faded;
}

rxvt_color
rxvt_color::fade (rxvt_screen *screen, int percent, rxvt_color &fadeto)
{
  rxvt_rgba c, fc;
  rxvt_color faded;
  
  get (screen, c);
  fadeto.get (screen, fc);

  faded.set (
    screen,
    rxvt_rgba (
      lerp (fc.r, c.r, percent),
      lerp (fc.g, c.g, percent),
      lerp (fc.b, c.b, percent),
      lerp (fc.a, c.a, percent)
    )
  );

  return faded;
}

Revision:	1.34
Committed:	Mon Jan 30 02:21:20 2006 UTC (18 years, 3 months ago) by root
Content type:	text/plain
Branch:	MAIN
Changes since 1.33:	+48 -25 lines
Log Message:	* empty log message *
#	User	Rev	Content
1	root	1.1	/---------------------------------C----------------------------------
2	root	1.5	* File: rxvttoolkit.C
3	root	1.1	----------------------------------------------------------------------
4			*
5			* All portions of code are copyright by their respective author/s.
6			* Copyright (c) 2003-2004 Marc Lehmann <pcg@goof.com>
7			*
8			* This program is free software; you can redistribute it and/or modify
9			* it under the terms of the GNU General Public License as published by
10			* the Free Software Foundation; either version 2 of the License, or
11			* (at your option) any later version.
12			*
13			* This program is distributed in the hope that it will be useful,
14			* but WITHOUT ANY WARRANTY; without even the implied warranty of
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16			* GNU General Public License for more details.
17			*
18			* You should have received a copy of the GNU General Public License
19			* along with this program; if not, write to the Free Software
20			* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21			----------------------------------------------------------------------/
22
23			#include "../config.h"
24			#include <rxvt.h>
25			#include <rxvttoolkit.h>
26
27			#include <unistd.h>
28			#include <fcntl.h>
29
30	root	1.23	#include <sys/utsname.h>
31
32	root	1.1	#ifndef NO_SLOW_LINK_SUPPORT
33			# include <sys/socket.h>
34			# include <sys/un.h>
35			#endif
36
37	root	1.31	#if XFT
38			# include <X11/extensions/Xrender.h>
39			#endif
40
41	root	1.25	const char *const xa_names[] =
42	root	1.34	{
43			"TEXT",
44			"COMPOUND_TEXT",
45			"UTF8_STRING",
46			"MULTIPLE",
47			"TARGETS",
48			"TIMESTAMP",
49			"VT_SELECTION",
50			"INCR",
51			"WM_PROTOCOLS",
52			"WM_DELETE_WINDOW",
53			"CLIPBOARD",
54			"AVERAGE_WIDTH",
55			"WEIGHT_NAME",
56			"SLANT",
57			"CHARSET_REGISTRY",
58			"CHARSET_ENCODING",
59	root	1.25	#if ENABLE_FRILLS
60	root	1.34	"_MOTIF_WM_HINTS",
61	root	1.25	#endif
62			#if ENABLE_EWMH
63	root	1.34	"_NET_WM_PID",
64			"_NET_WM_NAME",
65			"_NET_WM_ICON_NAME",
66			"_NET_WM_PING",
67	root	1.25	#endif
68			#if USE_XIM
69	root	1.34	"WM_LOCALE_NAME",
70			"XIM_SERVERS",
71	root	1.25	#endif
72			#ifdef TRANSPARENT
73	root	1.34	"_XROOTPMAP_ID",
74			"ESETROOT_PMAP_ID",
75	root	1.25	#endif
76			#if ENABLE_XEMBED
77	root	1.34	"_XEMBED",
78			"_XEMBED_INFO",
79			#endif
80			#if !ENABLE_MINIMAL
81			"SCREEN_RESOURCES",
82			"XDCCC_LINEAR_RGB_CORRECTION",
83			"XDCCC_LINEAR_RGB_MATRICES",
84			"WM_COLORMAP_WINDOWS",
85			"WM_STATE",
86	root	1.25	#endif
87	root	1.34	};
88	root	1.25
89			/////////////////////////////////////////////////////////////////////////////
90
91	root	1.1	refcounted::refcounted (const char *id)
92			{
93	root	1.2	this->id = strdup (id);
94	root	1.1	}
95
96			refcounted::~refcounted ()
97			{
98			free (id);
99			}
100
101			template<class T>
102			T refcache<T>::get (const char id)
103			{
104			for (T **i = this->begin (); i < this->end (); ++i)
105			{
106			if (!strcmp (id, (*i)->id))
107			{
108	root	1.23	++(*i)->referenced;
109			(*i)->ref_next ();
110	root	1.1	return *i;
111			}
112			}
113
114			T *obj = new T (id);
115
116	root	1.23	if (obj && obj->ref_init ())
117	root	1.1	{
118	root	1.23	obj->referenced = 1;
119	root	1.1	this->push_back (obj);
120			return obj;
121			}
122			else
123			{
124			delete obj;
125			return 0;
126			}
127			}
128
129			template<class T>
130			void refcache<T>::put (T *obj)
131			{
132			if (!obj)
133			return;
134
135			if (!--obj->referenced)
136			{
137			this->erase (find (this->begin (), this->end (), obj));
138			delete obj;
139			}
140			}
141
142			template<class T>
143	root	1.12	void refcache<T>::clear ()
144	root	1.1	{
145			while (this->size ())
146			put (*this->begin ());
147			}
148
149			/////////////////////////////////////////////////////////////////////////////
150
151			#ifdef USE_XIM
152	root	1.24
153	root	1.1	static void
154			#if XIMCB_PROTO_BROKEN
155			im_destroy_cb (XIC unused1, XPointer client_data, XPointer unused3)
156			#else
157			im_destroy_cb (XIM unused1, XPointer client_data, XPointer unused3)
158			#endif
159			{
160			rxvt_xim xim = (rxvt_xim )client_data;
161			rxvt_display *display = xim->display;
162
163	root	1.5	xim->xim = 0;
164
165	root	1.1	display->xims.erase (find (display->xims.begin (), display->xims.end (), xim));
166			display->im_change_cb ();
167			}
168
169	root	1.23	bool
170			rxvt_xim::ref_init ()
171	root	1.1	{
172			display = GET_R->display; //HACK: TODO
173
174			xim = XOpenIM (display->display, NULL, NULL, NULL);
175
176			if (!xim)
177			return false;
178
179			XIMCallback ximcallback;
180			ximcallback.client_data = (XPointer)this;
181			ximcallback.callback = im_destroy_cb;
182
183			XSetIMValues (xim, XNDestroyCallback, &ximcallback, NULL);
184
185			return true;
186			}
187
188			rxvt_xim::~rxvt_xim ()
189			{
190			if (xim)
191			XCloseIM (xim);
192			}
193	root	1.24
194	root	1.1	#endif
195
196			/////////////////////////////////////////////////////////////////////////////
197
198	root	1.26	void
199			rxvt_screen::set (rxvt_display *disp)
200			{
201			display = disp;
202	root	1.27	xdisp = disp->display;
203	root	1.26
204			Screen *screen = ScreenOfDisplay (xdisp, disp->screen);
205
206	root	1.27	depth = DefaultDepthOfScreen (screen);
207			visual = DefaultVisualOfScreen (screen);
208			cmap = DefaultColormapOfScreen (screen);
209	root	1.26	}
210
211			void
212	root	1.28	rxvt_screen::set (rxvt_display *disp, int bitdepth)
213	root	1.26	{
214			set (disp);
215
216	root	1.31	#if XFT
217	root	1.26	XVisualInfo vinfo;
218
219	root	1.28	if (XMatchVisualInfo (xdisp, display->screen, bitdepth, TrueColor, &vinfo))
220	root	1.26	{
221	root	1.28	depth = bitdepth;
222			visual = vinfo.visual;
223			cmap = XCreateColormap (xdisp, disp->root, visual, AllocNone);
224	root	1.26	}
225	root	1.31	#endif
226	root	1.26	}
227
228			void
229			rxvt_screen::clear ()
230			{
231			if (cmap != DefaultColormapOfScreen (ScreenOfDisplay (xdisp, display->screen)))
232			XFreeColormap (xdisp, cmap);
233			}
234
235			/////////////////////////////////////////////////////////////////////////////
236
237	root	1.1	rxvt_display::rxvt_display (const char *id)
238			: refcounted (id)
239			, x_ev (this, &rxvt_display::x_cb)
240			, selection_owner (0)
241			{
242			}
243
244	root	1.23	XrmDatabase
245			rxvt_display::get_resources ()
246			{
247			char homedir = (char )getenv ("HOME");
248			char fname[1024];
249
250			/*
251			* get resources using the X library function
252			*/
253			char displayResource, xe;
254			XrmDatabase database, rdb1;
255
256			database = NULL;
257
258			// for ordering, see for example http://www.faqs.org/faqs/Xt-FAQ/ Subject: 20
259
260			// 6. System wide per application default file.
261
262			/* Add in $XAPPLRESDIR/Rxvt only; not bothering with XUSERFILESEARCHPATH */
263			if ((xe = (char *)getenv ("XAPPLRESDIR")))
264			{
265			snprintf (fname, sizeof (fname), "%s/%s", xe, RESCLASS);
266
267			if ((rdb1 = XrmGetFileDatabase (fname)))
268			XrmMergeDatabases (rdb1, &database);
269			}
270
271			// 5. User's per application default file.
272			// none
273
274			// 4. User's defaults file.
275			/* Get any Xserver defaults */
276			displayResource = XResourceManagerString (display);
277
278			if (displayResource != NULL)
279			{
280			if ((rdb1 = XrmGetStringDatabase (displayResource)))
281			XrmMergeDatabases (rdb1, &database);
282			}
283			else if (homedir)
284			{
285			snprintf (fname, sizeof (fname), "%s/.Xdefaults", homedir);
286
287			if ((rdb1 = XrmGetFileDatabase (fname)))
288			XrmMergeDatabases (rdb1, &database);
289			}
290
291			/* Get screen specific resources */
292			displayResource = XScreenResourceString (ScreenOfDisplay (display, screen));
293
294			if (displayResource != NULL)
295			{
296			if ((rdb1 = XrmGetStringDatabase (displayResource)))
297			/* Merge with screen-independent resources */
298			XrmMergeDatabases (rdb1, &database);
299
300			XFree (displayResource);
301			}
302
303			// 3. User's per host defaults file
304			/* Add in XENVIRONMENT file */
305			if ((xe = (char *)getenv ("XENVIRONMENT"))
306			&& (rdb1 = XrmGetFileDatabase (xe)))
307			XrmMergeDatabases (rdb1, &database);
308			else if (homedir)
309			{
310			struct utsname un;
311
312			if (!uname (&un))
313			{
314			snprintf (fname, sizeof (fname), "%s/.Xdefaults-%s", homedir, un.nodename);
315
316			if ((rdb1 = XrmGetFileDatabase (fname)))
317			XrmMergeDatabases (rdb1, &database);
318			}
319			}
320
321			return database;
322			}
323
324			bool rxvt_display::ref_init ()
325	root	1.1	{
326	root	1.14	#ifdef LOCAL_X_IS_UNIX
327			if (id[0] == ':')
328			{
329			val = rxvt_malloc (5 + strlen (id) + 1);
330			strcpy (val, "unix/");
331			strcat (val, id);
332			display = XOpenDisplay (val);
333			free (val);
334			}
335			else
336	root	1.15	#endif
337	root	1.14	display = 0;
338
339			if (!display)
340			display = XOpenDisplay (id);
341	root	1.1
342			if (!display)
343			return false;
344
345			screen = DefaultScreen (display);
346			root = DefaultRootWindow (display);
347
348	root	1.25	assert (sizeof (xa_names) / sizeof (char *) == NUM_XA);
349			XInternAtoms (display, (char **)xa_names, NUM_XA, False, xa);
350
351	root	1.23	XrmSetDatabase (display, get_resources ());
352	root	1.1
353	root	1.12	#ifdef POINTER_BLANK
354			XColor blackcolour;
355			blackcolour.red = 0;
356			blackcolour.green = 0;
357			blackcolour.blue = 0;
358			Font f = XLoadFont (display, "fixed");
359			blank_cursor = XCreateGlyphCursor (display, f, f, ' ', ' ',
360			&blackcolour, &blackcolour);
361			XUnloadFont (display, f);
362			#endif
363
364	root	1.23	int fd = XConnectionNumber (display);
365
366			#ifndef NO_SLOW_LINK_SUPPORT
367			// try to detect wether we have a local connection.
368			// assume unix domains socket == local, everything else not
369			// TODO: might want to check for inet/127.0.0.1
370			is_local = 0;
371			sockaddr_un sa;
372			socklen_t sl = sizeof (sa);
373
374			if (!getsockname (fd, (sockaddr *)&sa, &sl))
375			is_local = sa.sun_family == AF_LOCAL;
376			#endif
377
378	root	1.1	x_ev.start (fd, EVENT_READ);
379			fcntl (fd, F_SETFD, FD_CLOEXEC);
380
381			XSelectInput (display, root, PropertyChangeMask);
382
383			flush ();
384
385			return true;
386			}
387
388	root	1.23	void
389			rxvt_display::ref_next ()
390			{
391			// TODO: somehow check wether the database files/resources changed
392			// before re-loading/parsing
393			XrmDestroyDatabase (XrmGetDatabase (display));
394			XrmSetDatabase (display, get_resources ());
395			}
396
397	root	1.1	rxvt_display::~rxvt_display ()
398			{
399	root	1.22	if (!display)
400			return;
401
402	root	1.21	#ifdef POINTER_BLANK
403			XFreeCursor (display, blank_cursor);
404			#endif
405	root	1.1	x_ev.stop ();
406	root	1.12	#ifdef USE_XIM
407			xims.clear ();
408			#endif
409	root	1.22	XCloseDisplay (display);
410	root	1.1	}
411
412			#ifdef USE_XIM
413			void rxvt_display::im_change_cb ()
414			{
415			for (im_watcher **i = imw.begin (); i != imw.end (); ++i)
416			(*i)->call ();
417			}
418	root	1.5
419			void rxvt_display::im_change_check ()
420			{
421	root	1.13	// try to only call im_change_cb when a new input method
422	root	1.5	// registers, as xlib crashes due to a race otherwise.
423			Atom actual_type, *atoms;
424			int actual_format;
425			unsigned long nitems, bytes_after;
426
427	root	1.25	if (XGetWindowProperty (display, root, xa[XA_XIM_SERVERS], 0L, 1000000L,
428	root	1.5	False, XA_ATOM, &actual_type, &actual_format,
429			&nitems, &bytes_after, (unsigned char **)&atoms)
430			!= Success )
431			return;
432
433			if (actual_type == XA_ATOM && actual_format == 32)
434			for (int i = 0; i < nitems; i++)
435			if (XGetSelectionOwner (display, atoms[i]))
436			{
437			im_change_cb ();
438			break;
439			}
440
441			XFree (atoms);
442			}
443	root	1.1	#endif
444
445			void rxvt_display::x_cb (io_watcher &w, short revents)
446			{
447			do
448			{
449			XEvent xev;
450			XNextEvent (display, &xev);
451
452	root	1.5	#ifdef USE_XIM
453			if (!XFilterEvent (&xev, None))
454			{
455			if (xev.type == PropertyNotify
456			&& xev.xany.window == root
457	root	1.25	&& xev.xproperty.atom == xa[XA_XIM_SERVERS])
458	root	1.5	im_change_check ();
459			#endif
460			for (int i = xw.size (); i--; )
461			{
462			if (!xw[i])
463			xw.erase_unordered (i);
464			else if (xw[i]->window == xev.xany.window)
465			xw[i]->call (xev);
466			}
467	root	1.1	#ifdef USE_XIM
468	root	1.5	}
469	root	1.1	#endif
470			}
471	root	1.6	while (XEventsQueued (display, QueuedAlready));
472	root	1.1
473	root	1.10	XFlush (display);
474	root	1.1	}
475
476			void rxvt_display::flush ()
477			{
478	root	1.10	if (XEventsQueued (display, QueuedAlready))
479			x_cb (x_ev, EVENT_READ);
480
481	root	1.8	XFlush (display);
482	root	1.1	}
483
484			void rxvt_display::reg (xevent_watcher *w)
485			{
486			xw.push_back (w);
487			w->active = xw.size ();
488			}
489
490			void rxvt_display::unreg (xevent_watcher *w)
491			{
492			if (w->active)
493			xw[w->active - 1] = 0;
494			}
495
496			void rxvt_display::set_selection_owner (rxvt_term *owner)
497			{
498			if (selection_owner && selection_owner != owner)
499			selection_owner->selection_clear ();
500
501			selection_owner = owner;
502			}
503
504			#ifdef USE_XIM
505			void rxvt_display::reg (im_watcher *w)
506			{
507			imw.push_back (w);
508			}
509
510			void rxvt_display::unreg (im_watcher *w)
511			{
512			imw.erase (find (imw.begin (), imw.end (), w));
513			}
514
515			rxvt_xim rxvt_display::get_xim (const char locale, const char *modifiers)
516			{
517			char *id;
518			int l, m;
519
520			l = strlen (locale);
521			m = strlen (modifiers);
522
523			if (!(id = (char *)malloc (l + m + 2)))
524			return 0;
525
526			memcpy (id, locale, l); id[l] = '\n';
527			memcpy (id + l + 1, modifiers, m); id[l + m + 1] = 0;
528
529			rxvt_xim *xim = xims.get (id);
530
531			free (id);
532
533			return xim;
534			}
535
536			void rxvt_display::put_xim (rxvt_xim *xim)
537			{
538	root	1.10	#if XLIB_IS_RACEFREE
539	root	1.1	xims.put (xim);
540	root	1.10	#endif
541	root	1.1	}
542			#endif
543
544			Atom rxvt_display::atom (const char *name)
545			{
546			return XInternAtom (display, name, False);
547			}
548
549			/////////////////////////////////////////////////////////////////////////////
550
551			template class refcache<rxvt_display>;
552			refcache<rxvt_display> displays;
553
554			/////////////////////////////////////////////////////////////////////////////
555
556			bool
557	root	1.28	rxvt_color::set (rxvt_screen screen, const char name)
558	root	1.1	{
559			#if XFT
560	root	1.28	int l = strlen (name);
561			rxvt_rgba r;
562			char eos;
563			int mult;
564
565	root	1.34	// shortcutting this saves countless server RTTs for the built-in colours
566			if (l == 3+3*3 && 3 == sscanf (name, "rgb:%hx/%hx/%hx/%hx%c", &r.r, &r.g, &r.b, &r.a, &eos))
567			{
568			r.a = rxvt_rgba::MAX_CC;
569			mult = rxvt_rgba::MAX_CC / 0x00ff;
570			}
571
572			// parse a number of non-standard ARGB colour specifications
573			else if ( l == 1+4*1 && 4 == sscanf (name, "#%1hx%1hx%1hx%1hx%c", &r.a, &r.r, &r.g, &r.b, &eos))
574	root	1.29	mult = rxvt_rgba::MAX_CC / 0x000f;
575	root	1.28	else if (l == 1+4*2 && 4 == sscanf (name, "#%2hx%2hx%2hx%2hx%c", &r.a, &r.r, &r.g, &r.b, &eos))
576	root	1.29	mult = rxvt_rgba::MAX_CC / 0x00ff;
577	root	1.28	else if (l == 1+4*4 && 4 == sscanf (name, "#%4hx%4hx%4hx%4hx%c", &r.a, &r.r, &r.g, &r.b, &eos))
578	root	1.29	mult = rxvt_rgba::MAX_CC / 0xffff;
579			else if (l == 4+5*4 && 4 == sscanf (name, "rgba:%hx/%hx/%hx/%hx%c", &r.r, &r.g, &r.b, &r.a, &eos))
580			mult = rxvt_rgba::MAX_CC / 0xffff;
581	root	1.34
582			// slow case: server round trip
583	root	1.28	else
584			return XftColorAllocName (screen->xdisp, screen->visual, screen->cmap, name, &c);
585	root	1.1
586	root	1.28	r.r = mult; r.g = mult; r.b = mult; r.a = mult;
587	root	1.34
588	root	1.28	return set (screen, r);
589	root	1.7	#else
590	root	1.1	XColor xc;
591
592	root	1.26	if (XParseColor (screen->xdisp, screen->cmap, name, &xc))
593	root	1.28	return set (screen, rxvt_rgba (xc.red, xc.green, xc.blue));
594	root	1.1
595			return false;
596	root	1.7	#endif
597	root	1.1	}
598
599			bool
600	root	1.28	rxvt_color::set (rxvt_screen *screen, rxvt_rgba rgba)
601	root	1.1	{
602	root	1.28	#if XFT
603	root	1.31	XRenderPictFormat *format;
604	root	1.28
605	root	1.31	// FUCKING Xft gets it wrong, of course, so work around it
606			// transparency users should eat shit and die, and then
607			// XRenderQueryPictIndexValues themselves plenty.
608			if (screen->visual->c_class == TrueColor
609			&& (format = XRenderFindVisualFormat (screen->xdisp, screen->visual)))
610			{
611			// the fun lies in doing everything manually...
612			c.color.red = rgba.r;
613			c.color.green = rgba.g;
614			c.color.blue = rgba.b;
615			c.color.alpha = rgba.a;
616
617	root	1.33	c.pixel = ((rgba.r * format->direct.redMask / rxvt_rgba::MAX_CC) << format->direct.red )
618	root	1.32	\| ((rgba.g * format->direct.greenMask / rxvt_rgba::MAX_CC) << format->direct.green)
619	root	1.33	\| ((rgba.b * format->direct.blueMask / rxvt_rgba::MAX_CC) << format->direct.blue )
620	root	1.32	\| ((rgba.a * format->direct.alphaMask / rxvt_rgba::MAX_CC) << format->direct.alpha);
621	root	1.29
622			return true;
623			}
624	root	1.31	else
625			{
626			XRenderColor d;
627
628			d.red = rgba.r;
629			d.green = rgba.g;
630			d.blue = rgba.b;
631			d.alpha = rgba.a;
632
633			return XftColorAllocValue (screen->xdisp, screen->visual, screen->cmap, &d, &c);
634			}
635	root	1.29
636			return false;
637	root	1.28	#else
638	root	1.1	XColor xc;
639
640	root	1.28	xc.red = rgba.r;
641			xc.green = rgba.g;
642			xc.blue = rgba.b;
643	root	1.1	xc.flags = DoRed \| DoGreen \| DoBlue;
644
645	root	1.26	if (XAllocColor (screen->xdisp, screen->cmap, &xc))
646	root	1.28	{
647			p = xc.pixel;
648			return true;
649			}
650	root	1.1
651			return false;
652	root	1.28	#endif
653	root	1.1	}
654
655			void
656	root	1.28	rxvt_color::get (rxvt_screen *screen, rxvt_rgba &rgba)
657	root	1.1	{
658			#if XFT
659	root	1.28	rgba.r = c.color.red;
660			rgba.g = c.color.green;
661			rgba.b = c.color.blue;
662			rgba.a = c.color.alpha;
663	root	1.1	#else
664			XColor c;
665
666			c.pixel = p;
667	root	1.26	XQueryColor (screen->xdisp, screen->cmap, &c);
668	root	1.1
669	root	1.28	rgba.r = c.red;
670			rgba.g = c.green;
671			rgba.b = c.blue;
672			rgba.a = rxvt_rgba::MAX_CC;
673	root	1.1	#endif
674			}
675
676			void
677	root	1.26	rxvt_color::free (rxvt_screen *screen)
678	root	1.1	{
679			#if XFT
680	root	1.26	XftColorFree (screen->xdisp, screen->visual, screen->cmap, &c);
681	root	1.1	#else
682	root	1.26	XFreeColors (screen->xdisp, screen->cmap, &p, 1, AllPlanes);
683	root	1.1	#endif
684			}
685
686			rxvt_color
687	root	1.26	rxvt_color::fade (rxvt_screen *screen, int percent)
688	root	1.1	{
689	root	1.28	rxvt_color faded;
690	root	1.18
691	root	1.28	rxvt_rgba c;
692			get (screen, c);
693	root	1.1
694	root	1.28	c.r = lerp (0, c.r, percent);
695			c.g = lerp (0, c.g, percent);
696			c.b = lerp (0, c.b, percent);
697	root	1.18
698	root	1.28	faded.set (screen, c);
699	root	1.18
700			return faded;
701			}
702
703			rxvt_color
704	root	1.26	rxvt_color::fade (rxvt_screen *screen, int percent, rxvt_color &fadeto)
705	root	1.18	{
706	root	1.28	rxvt_rgba c, fc;
707	root	1.18	rxvt_color faded;
708
709	root	1.28	get (screen, c);
710			fadeto.get (screen, fc);
711	root	1.18
712			faded.set (
713	root	1.26	screen,
714	root	1.28	rxvt_rgba (
715			lerp (fc.r, c.r, percent),
716			lerp (fc.g, c.g, percent),
717			lerp (fc.b, c.b, percent),
718			lerp (fc.a, c.a, percent)
719			)
720	root	1.18	);
721	root	1.1
722			return faded;
723			}
724