move X11 stuff from conky.cc to display-x11

Still some things to sort out, but seems to work.

A lot of variables and calls had to be made non-static.

src/CMakeLists.txt

@@ -224,8 +224,13 @@ if(BUILD_PORT_MONITORS)
   set(optional_sources ${optional_sources} ${port_monitors})
 endif(BUILD_PORT_MONITORS)
 
+if(BUILD_GUI)
+  set(gui fonts.cc fonts.h)
+  set(optional_sources ${optional_sources} ${gui})
+endif(BUILD_GUI)
+
 if(BUILD_X11)
-  set(x11 x11.cc x11.h fonts.cc fonts.h)
+  set(x11 x11.cc x11.h)
   set(optional_sources ${optional_sources} ${x11})
 
   if(BUILD_XINERAMA)

src/conky.h

@@ -292,7 +292,15 @@ extern conky::range_config_setting<double> update_interval;
 extern conky::range_config_setting<double> update_interval_on_battery;
 double active_update_interval();
 
+extern conky::simple_config_setting<bool> show_graph_scale;
+extern conky::simple_config_setting<bool> show_graph_range;
+extern conky::simple_config_setting<int> gap_x;
+extern conky::simple_config_setting<int> gap_y;
+extern conky::simple_config_setting<bool> draw_borders;
+extern conky::simple_config_setting<bool> draw_graph_borders;
 extern conky::range_config_setting<char> stippled_borders;
+extern conky::simple_config_setting<bool> draw_shades;
+extern conky::simple_config_setting<bool> draw_outline;
 
 void set_current_text_color(long colour);
 long get_current_text_color(void);
@@ -301,7 +309,7 @@ void set_updatereset(int);
 int get_updatereset(void);
 int get_total_updates(void);
 
-int xft_dpi_scale(int value);
+int dpi_scale(int value);
 
 int get_saved_coordinates_x(int);
 int get_saved_coordinates_y(int);
@@ -322,6 +330,9 @@ void extract_object_args_to_sub(struct text_object *, const char *);
 
 void generate_text_internal(char *, int, struct text_object);
 
+void update_text_area();
+void draw_stuff();
+
 int percent_print(char *, int, unsigned);
 void human_readable(long long, char *, int);
 

src/display-output.cc

@@ -28,10 +28,10 @@
 
 #include "display-output.hh"
 
+#include <algorithm>
 #include <iostream>
 #include <sstream>
 #include <unordered_map>
-#include <vector>
 
 namespace conky {
 namespace {
@@ -101,8 +101,11 @@ bool initialize_display_outputs() {
   outputs.reserve(display_outputs->size());
 
   for (auto &output : *display_outputs) { outputs.push_back(output.second); }
+  // Sort display outputs by descending priority, to try graphical ones first.
   sort(outputs.begin(), outputs.end(), &display_output_base::priority_compare);
 
+  int graphical_count = 0;
+
   for (auto output : outputs) {
     if (output->priority < 0) continue;
     std::cerr << "Testing display output '" << output->name << "'... "
@@ -110,23 +113,43 @@ bool initialize_display_outputs() {
     if (output->detect()) {
       std::cerr << "Detected display output '" << output->name << "'... "
                 << std::endl;
+
+      if (graphical_count && output->graphical()) continue;
+
+      // X11 init needs to draw, so we must add it to the list first.
+      active_display_outputs.push_back(output);
+
       if (output->initialize()) {
         std::cerr << "Initialized display output '" << output->name << "'... "
                   << std::endl;
+
         output->is_active = true;
-        active_display_outputs.push_back(output);
+        if (output->graphical()) graphical_count++;
+        /*
+         * We only support a single graphical display for now.
+         * More than one text display (ncurses + http, ...) should be ok.
+         */
+        // if (graphical_count)
+        // return true;
+      } else {
+        // failed, so remove from list
+        active_display_outputs.pop_back();
       }
     }
   }
   if (active_display_outputs.size()) return true;
 
   std::cerr << "Unable to find a usable display output." << std::endl;
-  return true;  // false;
+  return false;
 }
 
 bool shutdown_display_outputs() {
   bool ret = true;
-  for (auto output : active_display_outputs) ret = output->shutdown();
+  for (auto output : active_display_outputs) {
+    output->is_active = false;
+    ret = output->shutdown();
+  }
+  active_display_outputs.clear();
   return ret;
 }
 

src/display-output.hh

@@ -27,6 +27,7 @@
 #include <limits>
 #include <string>
 #include <type_traits>
+#include <vector>
 
 #include "luamm.hh"
 
@@ -102,10 +103,10 @@ class display_output_base {
   virtual void fill_rect(int x, int y, int w, int h) {}
   virtual void draw_arc(int x, int y, int w, int h, int a1, int a2) {}
   virtual void move_win(int x, int y) {}
+  virtual int dpi_scale(int value) { return value; }
 
   virtual void begin_draw_stuff() {}
   virtual void end_draw_stuff() {}
-  virtual void swap_buffers() {}
   virtual void clear_text(int exposures) {}
   virtual void load_fonts(bool utf8) {}
 

src/display-x11.cc

@@ -26,12 +26,112 @@
 
 #include <config.h>
 
-#include "display-x11.hh"
+#ifdef BUILD_X11
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wvariadic-macros"
+#include <X11/Xutil.h>
+#ifdef BUILD_XFT
+#include <X11/Xlib.h>
+#endif /* BUILD_XFT */
+#pragma GCC diagnostic pop
+#include "x11.h"
+#ifdef BUILD_XDAMAGE
+#include <X11/extensions/Xdamage.h>
+#endif
+#ifdef BUILD_IMLIB2
+#include "imlib2.h"
+#endif /* BUILD_IMLIB2 */
+#endif /* BUILD_X11 */
 
 #include <iostream>
 #include <sstream>
 #include <unordered_map>
 
+#include "conky.h"
+#include "display-x11.hh"
+#include "llua.h"
+#include "x11.h"
+#ifdef BUILD_X11
+#include "fonts.h"
+#endif
+
+/* TODO: cleanup global namespace */
+#ifdef BUILD_X11
+
+// TODO: cleanup externs (move to conky.h ?)
+#ifdef OWN_WINDOW
+extern int fixed_size, fixed_pos;
+#endif
+extern int text_start_x, text_start_y;   /* text start position in window */
+extern int text_offset_x, text_offset_y; /* offset for start position */
+extern int text_width,
+    text_height; /* initially 1 so no zero-sized window is created */
+extern double current_update_time, next_update_time, last_update_time;
+void update_text();
+extern int need_to_update;
+int get_border_total();
+extern conky::range_config_setting<int> maximum_width;
+extern long current_color;
+#ifdef BUILD_XFT
+static int xft_dpi = -1;
+#endif /* BUILD_XFT */
+
+static void X11_create_window();
+
+struct _x11_stuff_s {
+  Region region;
+#ifdef BUILD_XDAMAGE
+  Damage damage;
+  XserverRegion region2, part;
+  int event_base, error_base;
+#endif
+} x11_stuff;
+
+static void X11_create_window() {
+  setup_fonts();
+  load_fonts(utf8_mode.get(*state));
+#ifdef BUILD_XFT
+  if (use_xft.get(*state)) {
+    auto dpi = XGetDefault(display, "Xft", "dpi");
+    if (dpi) { xft_dpi = atoi(dpi); }
+  }
+#endif                /* BUILD_XFT */
+  update_text_area(); /* to position text/window on screen */
+
+#ifdef OWN_WINDOW
+  if (own_window.get(*state)) {
+    if (fixed_pos == 0) {
+      XMoveWindow(display, window.window, window.x, window.y);
+    }
+
+    set_transparent_background(window.window);
+  }
+#endif
+
+  create_gc();
+
+  draw_stuff();
+
+  x11_stuff.region = XCreateRegion();
+#ifdef BUILD_XDAMAGE
+  if (XDamageQueryExtension(display, &x11_stuff.event_base,
+                            &x11_stuff.error_base) == 0) {
+    NORM_ERR("Xdamage extension unavailable");
+    x11_stuff.damage = 0;
+  } else {
+    x11_stuff.damage =
+        XDamageCreate(display, window.window, XDamageReportNonEmpty);
+    x11_stuff.region2 = XFixesCreateRegionFromWindow(display, window.window, 0);
+    x11_stuff.part = XFixesCreateRegionFromWindow(display, window.window, 0);
+  }
+#endif /* BUILD_XDAMAGE */
+
+  selected_font = 0;
+  update_text_area(); /* to get initial size of the window */
+}
+
+#endif /* BUILD_X11 */
+
 namespace conky {
 namespace {
 
@@ -48,6 +148,7 @@ namespace priv {}  // namespace priv
 #ifdef BUILD_X11
 
 display_output_x11::display_output_x11() : display_output_base("x11") {
+  is_graphical = true;
   priority = 2;
 }
 
@@ -60,10 +161,503 @@ bool display_output_x11::detect() {
   return false;
 }
 
-bool display_output_x11::initialize() { return false; }
+bool display_output_x11::initialize() {
+  X11_create_window();
+  return true;
+}
 
 bool display_output_x11::shutdown() { return false; }
 
+bool display_output_x11::main_loop_wait(double t) {
+  /* wait for X event or timeout */
+
+  if (XPending(display) == 0) {
+    fd_set fdsr;
+    struct timeval tv {};
+    int s;
+    // t = next_update_time - get_time();
+
+    t = std::min(std::max(t, 0.0), active_update_interval());
+
+    tv.tv_sec = static_cast<long>(t);
+    tv.tv_usec = static_cast<long>(t * 1000000) % 1000000;
+    FD_ZERO(&fdsr);
+    FD_SET(ConnectionNumber(display), &fdsr);
+
+    s = select(ConnectionNumber(display) + 1, &fdsr, nullptr, nullptr, &tv);
+    if (s == -1) {
+      if (errno != EINTR) { NORM_ERR("can't select(): %s", strerror(errno)); }
+    } else {
+      /* timeout */
+      if (s == 0) { update_text(); }
+    }
+  }
+
+  if (need_to_update != 0) {
+#ifdef OWN_WINDOW
+    int wx = window.x, wy = window.y;
+#endif
+
+    need_to_update = 0;
+    selected_font = 0;
+    update_text_area();
+
+#ifdef OWN_WINDOW
+    if (own_window.get(*state)) {
+      int changed = 0;
+      int border_total = get_border_total();
+
+      /* resize window if it isn't right size */
+      if ((fixed_size == 0) &&
+          (text_width + 2 * border_total != window.width ||
+           text_height + 2 * border_total != window.height)) {
+        window.width = text_width + 2 * border_total;
+        window.height = text_height + 2 * border_total;
+        draw_stuff(); /* redraw everything in our newly sized window */
+        XResizeWindow(display, window.window, window.width,
+                      window.height); /* resize window */
+        set_transparent_background(window.window);
+#ifdef BUILD_XDBE
+        /* swap buffers */
+        xdbe_swap_buffers();
+#else
+        if (use_xpmdb.get(*state)) {
+          XFreePixmap(display, window.back_buffer);
+          window.back_buffer =
+              XCreatePixmap(display, window.window, window.width, window.height,
+                            DefaultDepth(display, screen));
+
+          if (window.back_buffer != None) {
+            window.drawable = window.back_buffer;
+          } else {
+            // this is probably reallllly bad
+            NORM_ERR("Failed to allocate back buffer");
+          }
+          XSetForeground(display, window.gc, 0);
+          XFillRectangle(display, window.drawable, window.gc, 0, 0,
+                         window.width, window.height);
+        }
+#endif
+
+        changed++;
+        /* update lua window globals */
+        llua_update_window_table(text_start_x, text_start_y, text_width,
+                                 text_height);
+      }
+
+      /* move window if it isn't in right position */
+      if ((fixed_pos == 0) && (window.x != wx || window.y != wy)) {
+        XMoveWindow(display, window.window, window.x, window.y);
+        changed++;
+      }
+
+      /* update struts */
+      if ((changed != 0) && own_window_type.get(*state) == TYPE_PANEL) {
+        int sidenum = -1;
+
+        DBGP("%s", _(PACKAGE_NAME ": defining struts\n"));
+        fflush(stderr);
+
+        switch (text_alignment.get(*state)) {
+          case TOP_LEFT:
+          case TOP_RIGHT:
+          case TOP_MIDDLE: {
+            sidenum = 2;
+            break;
+          }
+          case BOTTOM_LEFT:
+          case BOTTOM_RIGHT:
+          case BOTTOM_MIDDLE: {
+            sidenum = 3;
+            break;
+          }
+          case MIDDLE_LEFT: {
+            sidenum = 0;
+            break;
+          }
+          case MIDDLE_RIGHT: {
+            sidenum = 1;
+            break;
+          }
+
+          case NONE:
+          case MIDDLE_MIDDLE: /* XXX What about these? */;
+        }
+
+        set_struts(sidenum);
+      }
+    }
+#endif
+
+    clear_text(1);
+
+#if defined(BUILD_XDBE)
+    if (use_xdbe.get(*state)) {
+#else
+    if (use_xpmdb.get(*state)) {
+#endif
+      XRectangle r;
+      int border_total = get_border_total();
+
+      r.x = text_start_x - border_total;
+      r.y = text_start_y - border_total;
+      r.width = text_width + 2 * border_total;
+      r.height = text_height + 2 * border_total;
+      XUnionRectWithRegion(&r, x11_stuff.region, x11_stuff.region);
+    }
+  }
+
+  /* handle X events */
+  while (XPending(display) != 0) {
+    XEvent ev;
+
+    XNextEvent(display, &ev);
+    switch (ev.type) {
+      case Expose: {
+        XRectangle r;
+        r.x = ev.xexpose.x;
+        r.y = ev.xexpose.y;
+        r.width = ev.xexpose.width;
+        r.height = ev.xexpose.height;
+        XUnionRectWithRegion(&r, x11_stuff.region, x11_stuff.region);
+        XSync(display, False);
+        break;
+      }
+
+      case PropertyNotify: {
+        if (ev.xproperty.state == PropertyNewValue) {
+          get_x11_desktop_info(ev.xproperty.display, ev.xproperty.atom);
+        }
+#ifdef USE_ARGB
+        if (!have_argb_visual) {
+#endif
+          if (ev.xproperty.atom == ATOM(_XROOTPMAP_ID) ||
+              ev.xproperty.atom == ATOM(_XROOTMAP_ID)) {
+            if (forced_redraw.get(*state)) {
+              draw_stuff();
+              next_update_time = get_time();
+              need_to_update = 1;
+            }
+          }
+#ifdef USE_ARGB
+        }
+#endif
+        break;
+      }
+
+#ifdef OWN_WINDOW
+      case ReparentNotify:
+        /* make background transparent */
+        if (own_window.get(*state)) {
+          set_transparent_background(window.window);
+        }
+        break;
+
+      case ConfigureNotify:
+        if (own_window.get(*state)) {
+          /* if window size isn't what expected, set fixed size */
+          if (ev.xconfigure.width != window.width ||
+              ev.xconfigure.height != window.height) {
+            if (window.width != 0 && window.height != 0) { fixed_size = 1; }
+
+            /* clear old stuff before screwing up
+             * size and pos */
+            clear_text(1);
+
+            {
+              XWindowAttributes attrs;
+              if (XGetWindowAttributes(display, window.window, &attrs) != 0) {
+                window.width = attrs.width;
+                window.height = attrs.height;
+              }
+            }
+
+            int border_total = get_border_total();
+
+            text_width = window.width - 2 * border_total;
+            text_height = window.height - 2 * border_total;
+            int mw = this->dpi_scale(maximum_width.get(*state));
+            if (text_width > mw && mw > 0) { text_width = mw; }
+          }
+
+          /* if position isn't what expected, set fixed pos
+           * total_updates avoids setting fixed_pos when window
+           * is set to weird locations when started */
+          /* // this is broken
+          if (total_updates >= 2 && !fixed_pos
+              && (window.x != ev.xconfigure.x
+              || window.y != ev.xconfigure.y)
+              && (ev.xconfigure.x != 0
+              || ev.xconfigure.y != 0)) {
+            fixed_pos = 1;
+          } */
+        }
+        break;
+
+      case ButtonPress:
+        if (own_window.get(*state)) {
+          /* if an ordinary window with decorations */
+          if ((own_window_type.get(*state) == TYPE_NORMAL &&
+               !TEST_HINT(own_window_hints.get(*state), HINT_UNDECORATED)) ||
+              own_window_type.get(*state) == TYPE_DESKTOP) {
+            /* allow conky to hold input focus. */
+            break;
+          }
+          /* forward the click to the desktop window */
+          XUngrabPointer(display, ev.xbutton.time);
+          ev.xbutton.window = window.desktop;
+          ev.xbutton.x = ev.xbutton.x_root;
+          ev.xbutton.y = ev.xbutton.y_root;
+          XSendEvent(display, ev.xbutton.window, False, ButtonPressMask, &ev);
+          XSetInputFocus(display, ev.xbutton.window, RevertToParent,
+                         ev.xbutton.time);
+        }
+        break;
+
+      case ButtonRelease:
+        if (own_window.get(*state)) {
+          /* if an ordinary window with decorations */
+          if ((own_window_type.get(*state) == TYPE_NORMAL) &&
+              !TEST_HINT(own_window_hints.get(*state), HINT_UNDECORATED)) {
+            /* allow conky to hold input focus. */
+            break;
+          }
+          /* forward the release to the desktop window */
+          ev.xbutton.window = window.desktop;
+          ev.xbutton.x = ev.xbutton.x_root;
+          ev.xbutton.y = ev.xbutton.y_root;
+          XSendEvent(display, ev.xbutton.window, False, ButtonReleaseMask, &ev);
+        }
+        break;
+
+#endif
+
+      default:
+#ifdef BUILD_XDAMAGE
+        if (ev.type == x11_stuff.event_base + XDamageNotify) {
+          auto *dev = reinterpret_cast<XDamageNotifyEvent *>(&ev);
+
+          XFixesSetRegion(display, x11_stuff.part, &dev->area, 1);
+          XFixesUnionRegion(display, x11_stuff.region2, x11_stuff.region2,
+                            x11_stuff.part);
+        }
+#endif /* BUILD_XDAMAGE */
+        break;
+    }
+  }
+
+#ifdef BUILD_XDAMAGE
+  if (x11_stuff.damage) {
+    XDamageSubtract(display, x11_stuff.damage, x11_stuff.region2, None);
+    XFixesSetRegion(display, x11_stuff.region2, nullptr, 0);
+  }
+#endif /* BUILD_XDAMAGE */
+
+  /* XDBE doesn't seem to provide a way to clear the back buffer
+   * without interfering with the front buffer, other than passing
+   * XdbeBackground to XdbeSwapBuffers. That means that if we're
+   * using XDBE, we need to redraw the text even if it wasn't part of
+   * the exposed area. OTOH, if we're not going to call draw_stuff at
+   * all, then no swap happens and we can safely do nothing. */
+
+  if (XEmptyRegion(x11_stuff.region) == 0) {
+#if defined(BUILD_XDBE)
+    if (use_xdbe.get(*state)) {
+#else
+    if (use_xpmdb.get(*state)) {
+#endif
+      XRectangle r;
+      int border_total = get_border_total();
+
+      r.x = text_start_x - border_total;
+      r.y = text_start_y - border_total;
+      r.width = text_width + 2 * border_total;
+      r.height = text_height + 2 * border_total;
+      XUnionRectWithRegion(&r, x11_stuff.region, x11_stuff.region);
+    }
+    XSetRegion(display, window.gc, x11_stuff.region);
+#ifdef BUILD_XFT
+    if (use_xft.get(*state)) {
+      XftDrawSetClip(window.xftdraw, x11_stuff.region);
+    }
+#endif
+    draw_stuff();
+    XDestroyRegion(x11_stuff.region);
+    x11_stuff.region = XCreateRegion();
+  }
+
+  // handled
+  return true;
+}
+
+void display_output_x11::sigterm_cleanup() {
+  XDestroyRegion(x11_stuff.region);
+  x11_stuff.region = nullptr;
+#ifdef BUILD_XDAMAGE
+  if (x11_stuff.damage) {
+    XDamageDestroy(display, x11_stuff.damage);
+    XFixesDestroyRegion(display, x11_stuff.region2);
+    XFixesDestroyRegion(display, x11_stuff.part);
+  }
+#endif /* BUILD_XDAMAGE */
+}
+
+void display_output_x11::cleanup() {
+  if (window_created == 1) {
+    int border_total = get_border_total();
+
+    XClearArea(display, window.window, text_start_x - border_total,
+               text_start_y - border_total, text_width + 2 * border_total,
+               text_height + 2 * border_total, 0);
+  }
+  destroy_window();
+  free_fonts(utf8_mode.get(*state));
+  if (x11_stuff.region != nullptr) {
+    XDestroyRegion(x11_stuff.region);
+    x11_stuff.region = nullptr;
+  }
+}
+
+void display_output_x11::set_foreground_color(long c) {
+#ifdef BUILD_ARGB
+  if (have_argb_visual) {
+    current_color = c | (own_window_argb_value.get(*state) << 24);
+  } else {
+#endif /* BUILD_ARGB */
+    current_color = c;
+#ifdef BUILD_ARGB
+  }
+#endif /* BUILD_ARGB */
+  XSetForeground(display, window.gc, current_color);
+}
+
+int display_output_x11::calc_text_width(const char *s) {
+  size_t slen = strlen(s);
+#ifdef BUILD_XFT
+  if (use_xft.get(*state)) {
+    XGlyphInfo gi;
+
+    if (utf8_mode.get(*state)) {
+      XftTextExtentsUtf8(display, fonts[selected_font].xftfont,
+                         reinterpret_cast<const FcChar8 *>(s), slen, &gi);
+    } else {
+      XftTextExtents8(display, fonts[selected_font].xftfont,
+                      reinterpret_cast<const FcChar8 *>(s), slen, &gi);
+    }
+    return gi.xOff;
+  }
+#endif /* BUILD_XFT */
+
+  return XTextWidth(fonts[selected_font].font, s, slen);
+}
+
+void display_output_x11::draw_string_at(int x, int y, const char *s, int w) {
+#ifdef BUILD_XFT
+  if (use_xft.get(*state)) {
+    XColor c;
+    XftColor c2;
+
+    c.pixel = current_color;
+    // query color on custom colormap
+    XQueryColor(display, window.colourmap, &c);
+
+    c2.pixel = c.pixel;
+    c2.color.red = c.red;
+    c2.color.green = c.green;
+    c2.color.blue = c.blue;
+    c2.color.alpha = fonts[selected_font].font_alpha;
+    if (utf8_mode.get(*state)) {
+      XftDrawStringUtf8(window.xftdraw, &c2, fonts[selected_font].xftfont, x, y,
+                        reinterpret_cast<const XftChar8 *>(s), w);
+    } else {
+      XftDrawString8(window.xftdraw, &c2, fonts[selected_font].xftfont, x, y,
+                     reinterpret_cast<const XftChar8 *>(s), w);
+    }
+  } else
+#endif
+  {
+    if (utf8_mode.get(*state)) {
+      Xutf8DrawString(display, window.drawable, fonts[selected_font].fontset,
+                      window.gc, x, y, s, w);
+    } else {
+      XDrawString(display, window.drawable, window.gc, x, y, s, w);
+    }
+  }
+}
+
+void display_output_x11::set_line_style(int w, bool solid) {
+  XSetLineAttributes(display, window.gc, w, solid ? LineSolid : LineOnOffDash,
+                     CapButt, JoinMiter);
+}
+
+void display_output_x11::set_dashes(char *s) {
+  XSetDashes(display, window.gc, 0, s, 2);
+}
+
+void display_output_x11::draw_line(int x1, int y1, int x2, int y2) {
+  XDrawLine(display, window.drawable, window.gc, x1, y1, x2, y2);
+}
+
+void display_output_x11::draw_rect(int x, int y, int w, int h) {
+  XDrawRectangle(display, window.drawable, window.gc, x, y, w, h);
+}
+
+void display_output_x11::fill_rect(int x, int y, int w, int h) {
+  XFillRectangle(display, window.drawable, window.gc, x, y, w, h);
+}
+
+void display_output_x11::draw_arc(int x, int y, int w, int h, int a1, int a2) {
+  XDrawArc(display, window.drawable, window.gc, x, y, w, h, a1, a2);
+}
+
+void display_output_x11::move_win(int x, int y) {
+  XMoveWindow(display, window.window, window.x, window.y);
+}
+
+int display_output_x11::dpi_scale(int value) {
+#if defined(BUILD_XFT)
+  if (use_xft.get(*state) && xft_dpi > 0) {
+    return (value * xft_dpi + (value > 0 ? 48 : -48)) / 96;
+  } else {
+    return value;
+  }
+#else  /* defined(BUILD_XFT) */
+  return value;
+#endif /* defined(BUILD_XFT) */
+}
+
+void display_output_x11::end_draw_stuff() {
+#if defined(BUILD_XDBE)
+  xdbe_swap_buffers();
+#else
+  xpmdb_swap_buffers();
+#endif
+}
+
+void display_output_x11::clear_text(int exposures) {
+#ifdef BUILD_XDBE
+  if (use_xdbe.get(*state)) {
+    /* The swap action is XdbeBackground, which clears */
+    return;
+  }
+#else
+  if (use_xpmdb.get(*state)) {
+    return;
+  } else
+#endif
+  if ((display != nullptr) &&
+      (window.window != 0u)) {  // make sure these are !null
+    /* there is some extra space for borders and outlines */
+    int border_total = get_border_total();
+
+    XClearArea(display, window.window, text_start_x - border_total,
+               text_start_y - border_total, text_width + 2 * border_total,
+               text_height + 2 * border_total, exposures != 0 ? True : 0);
+  }
+}
+
+void display_output_x11::load_fonts(bool utf8) { ::load_fonts(utf8); }
+
 #endif /* BUILD_X11 */
 
 }  // namespace conky

src/display-x11.hh

@@ -47,6 +47,32 @@ class display_output_x11 : public display_output_base {
   virtual bool initialize();
   virtual bool shutdown();
 
+  virtual bool main_loop_wait(double t);
+
+  virtual void sigterm_cleanup();
+  virtual void cleanup();
+
+  // drawing primitives
+  virtual void set_foreground_color(long c);
+
+  virtual int calc_text_width(const char *s);
+
+  // GUI interface
+  virtual void draw_string_at(int x, int y, const char *s, int w);
+  // X11 lookalikes
+  virtual void set_line_style(int w, bool solid);
+  virtual void set_dashes(char *s);
+  virtual void draw_line(int x1, int y1, int x2, int y2);
+  virtual void draw_rect(int x, int y, int w, int h);
+  virtual void fill_rect(int x, int y, int w, int h);
+  virtual void draw_arc(int x, int y, int w, int h, int a1, int a2);
+  virtual void move_win(int x, int y);
+  virtual int dpi_scale(int value);
+
+  virtual void end_draw_stuff();
+  virtual void clear_text(int exposures);
+  virtual void load_fonts(bool utf8);
+
   // X11-specific
 };
 

src/imlib2.cc

@@ -133,19 +133,15 @@ void cimlib_add_image(const char *args) {
   if (tmp != nullptr) {
     tmp += 3;
     sscanf(tmp, "%i,%i", &cur->x, &cur->y);
-#ifdef BUILD_XFT
-    cur->x = xft_dpi_scale(cur->x);
-    cur->y = xft_dpi_scale(cur->y);
-#endif /* BUILD_XFT */
+    cur->x = dpi_scale(cur->x);
+    cur->y = dpi_scale(cur->y);
   }
   tmp = strstr(args, "-s ");
   if (tmp != nullptr) {
     tmp += 3;
     if (sscanf(tmp, "%ix%i", &cur->w, &cur->h) != 0) { cur->wh_set = 1; }
-#ifdef BUILD_XFT
-    cur->w = xft_dpi_scale(cur->w);
-    cur->h = xft_dpi_scale(cur->h);
-#endif /* BUILD_XFT */
+    cur->w = dpi_scale(cur->w);
+    cur->h = dpi_scale(cur->h);
   }
 
   tmp = strstr(args, "-n");
@@ -208,8 +204,8 @@ static void cimlib_draw_image(struct image_list_s *cur, int *clip_x,
   w = imlib_image_get_width();
   h = imlib_image_get_height();
   if (cur->wh_set == 0) {
-    cur->w = xft_dpi_scale(w);
-    cur->h = xft_dpi_scale(h);
+    cur->w = dpi_scale(w);
+    cur->h = dpi_scale(h);
   }
   imlib_context_set_image(buffer);
   imlib_blend_image_onto_image(image, 1, 0, 0, w, h, cur->x, cur->y, cur->w,

src/specials.cc

@@ -396,8 +396,8 @@ void new_gauge_in_x11(struct text_object *obj, char *buf, double usage) {
   s = new_special(buf, GAUGE);
 
   s->arg = usage;
-  s->width = xft_dpi_scale(g->width);
-  s->height = xft_dpi_scale(g->height);
+  s->width = dpi_scale(g->width);
+  s->height = dpi_scale(g->height);
   s->scale = g->scale;
 }
 #endif /* BUILD_GUI */
@@ -551,7 +551,7 @@ void new_graph(struct text_object *obj, char *buf, int buf_max_size,
   s = new_special(buf, GRAPH);
 
   /* set graph (special) width to width in obj */
-  s->width = xft_dpi_scale(g->width);
+  s->width = dpi_scale(g->width);
   if (s->width != 0) { s->graph_width = s->width; }
 
   if (s->graph_width != s->graph_allocated) {
@@ -576,7 +576,7 @@ void new_graph(struct text_object *obj, char *buf, int buf_max_size,
     s->graph_allocated = s->graph_width;
     graphs[g->id] = graph;
   }
-  s->height = xft_dpi_scale(g->height);
+  s->height = dpi_scale(g->height);
   s->first_colour = adjust_colours(g->first_colour);
   s->last_colour = adjust_colours(g->last_colour);
   if (g->scale != 0) {
@@ -610,7 +610,7 @@ void new_hr(struct text_object *obj, char *p, unsigned int p_max_size) {
 
   if (p_max_size == 0) { return; }
 
-  new_special(p, HORIZONTAL_LINE)->height = xft_dpi_scale(obj->data.l);
+  new_special(p, HORIZONTAL_LINE)->height = dpi_scale(obj->data.l);
 }
 
 void scan_stippled_hr(struct text_object *obj, const char *arg) {
@@ -642,8 +642,8 @@ void new_stippled_hr(struct text_object *obj, char *p,
 
   s = new_special(p, STIPPLED_HR);
 
-  s->height = xft_dpi_scale(sh->height);
-  s->arg = xft_dpi_scale(sh->arg);
+  s->height = dpi_scale(sh->height);
+  s->arg = dpi_scale(sh->arg);
 }
 #endif /* BUILD_GUI */
 
@@ -704,8 +704,8 @@ static void new_bar_in_x11(struct text_object *obj, char *buf, double usage) {
   s = new_special(buf, BAR);
 
   s->arg = usage;
-  s->width = xft_dpi_scale(b->width);
-  s->height = xft_dpi_scale(b->height);
+  s->width = dpi_scale(b->width);
+  s->height = dpi_scale(b->height);
   s->scale = b->scale;
 }
 #endif /* BUILD_GUI */
@@ -740,12 +740,12 @@ void new_outline(struct text_object *obj, char *p, unsigned int p_max_size) {
 
 void new_offset(struct text_object *obj, char *p, unsigned int p_max_size) {
   if (p_max_size == 0) { return; }
-  new_special(p, OFFSET)->arg = xft_dpi_scale(obj->data.l);
+  new_special(p, OFFSET)->arg = dpi_scale(obj->data.l);
 }
 
 void new_voffset(struct text_object *obj, char *p, unsigned int p_max_size) {
   if (p_max_size == 0) { return; }
-  new_special(p, VOFFSET)->arg = xft_dpi_scale(obj->data.l);
+  new_special(p, VOFFSET)->arg = dpi_scale(obj->data.l);
 }
 
 void new_save_coordinates(struct text_object *obj, char *p,
@@ -756,18 +756,18 @@ void new_save_coordinates(struct text_object *obj, char *p,
 
 void new_alignr(struct text_object *obj, char *p, unsigned int p_max_size) {
   if (p_max_size == 0) { return; }
-  new_special(p, ALIGNR)->arg = xft_dpi_scale(obj->data.l);
+  new_special(p, ALIGNR)->arg = dpi_scale(obj->data.l);
 }
 
 // A positive offset pushes the text further left
 void new_alignc(struct text_object *obj, char *p, unsigned int p_max_size) {
   if (p_max_size == 0) { return; }
-  new_special(p, ALIGNC)->arg = xft_dpi_scale(obj->data.l);
+  new_special(p, ALIGNC)->arg = dpi_scale(obj->data.l);
 }
 
 void new_goto(struct text_object *obj, char *p, unsigned int p_max_size) {
   if (p_max_size == 0) { return; }
-  new_special(p, GOTO)->arg = xft_dpi_scale(obj->data.l);
+  new_special(p, GOTO)->arg = dpi_scale(obj->data.l);
 }
 
 void scan_tab(struct text_object *obj, const char *arg) {
@@ -795,8 +795,8 @@ void new_tab(struct text_object *obj, char *p, unsigned int p_max_size) {
   if ((t == nullptr) || (p_max_size == 0)) { return; }
 
   s = new_special(p, TAB);
-  s->width = xft_dpi_scale(t->width);
-  s->arg = xft_dpi_scale(t->arg);
+  s->width = dpi_scale(t->width);
+  s->arg = dpi_scale(t->arg);
 }
 
 void clear_stored_graphs() {