X-Git-Url: https://vcs.maemo.org/git/?a=blobdiff_plain;f=src%2Fconky.c;h=b08df7c0ccbc1b0a6a4418044cd6493c71c68048;hb=a9e5820a3454f27cdb388f988f21d154aa2c9cce;hp=13dee6056655c8853e2447e7cb5d3b0a6f2c2650;hpb=d2be5980ca2a19bd88e14853ceee1edffbbd4b68;p=monky

diff --git a/src/conky.c b/src/conky.c
index 13dee60..b08df7c 100644
--- a/src/conky.c
+++ b/src/conky.c
@@ -10,7 +10,7 @@
  * Please see COPYING for details
  *
  * Copyright (c) 2004, Hannu Saransaari and Lauri Hakkarainen
- * Copyright (c) 2005-2009 Brenden Matthews, Philip Kovacs, et. al.
+ * Copyright (c) 2005-2010 Brenden Matthews, Philip Kovacs, et. al.
  *	(see AUTHORS)
  * All rights reserved.
  *
@@ -32,6 +32,7 @@
 #include "text_object.h"
 #include "conky.h"
 #include "common.h"
+#include "timed_thread.h"
 #include <stdarg.h>
 #include <math.h>
 #include <time.h>
@@ -77,7 +78,11 @@
 #include "colours.h"
 #include "combine.h"
 #include "diskio.h"
+#include "entropy.h"
 #include "exec.h"
+#include "i8k.h"
+#include "proc.h"
+#include "user.h"
 #ifdef X11
 #include "fonts.h"
 #endif
@@ -142,6 +147,9 @@ char *get_apm_battery_time(void);
 /* debugging level, used by logging.h */
 int global_debug_level = 0;
 
+/* disable inotify auto reload feature if desired */
+int disable_auto_reload = 0;
+
 /* two strings for internal use */
 static char *tmpstring1, *tmpstring2;
 
@@ -161,7 +169,6 @@ int top_io;
 #ifdef __linux__
 int top_running;
 #endif
-static unsigned int top_name_width = 15;
 int output_methods;
 static int extra_newline;
 enum x_initialiser_state x_initialised = NO;
@@ -171,6 +178,7 @@ double update_interval;
 double update_interval_old;
 double update_interval_bat;
 void *global_cpu = NULL;
+unsigned int max_text_width = 0;
 
 int argc_copy;
 char** argv_copy;
@@ -198,6 +206,9 @@ static void print_version(void)
 # ifdef XFT
 		   "  * Xft\n"
 # endif /* XFT */
+# ifdef USE_ARGB
+		   "  * ARGB visual\n"
+# endif /* USE_ARGB */
 #endif /* X11 */
 		   "\n Music detection:\n"
 #ifdef AUDACIOUS
@@ -267,6 +278,9 @@ static void print_version(void)
 #ifdef IOSTATS
 		   "  * iostats\n"
 #endif /* IOSTATS */
+#ifdef NCURSES
+		   "  * ncurses\n"
+#endif /* NCURSES */
 #ifdef HAVE_LUA
 		   "  * Lua\n"
 		   "\n  Lua bindings:\n"
@@ -306,13 +320,15 @@ static int text_width, text_height;
 
 /* alignments */
 enum alignment {
-	TOP_LEFT = 1,
+	ALIGNMENT_ERROR,
+	TOP_LEFT,
 	TOP_RIGHT,
 	TOP_MIDDLE,
 	BOTTOM_LEFT,
 	BOTTOM_RIGHT,
 	BOTTOM_MIDDLE,
 	MIDDLE_LEFT,
+	MIDDLE_MIDDLE,
 	MIDDLE_RIGHT,
 	NONE
 };
@@ -338,6 +354,10 @@ static unsigned long total_run_times;
 /* fork? */
 static int fork_to_background;
 
+/* set to 0 after the first time conky is run, so we don't fork again after the
+ * first forking */
+static int first_pass = 1;
+
 static int cpu_avg_samples, net_avg_samples, diskio_avg_samples;
 
 /* filenames for output */
@@ -450,14 +470,15 @@ int check_contains(char *f, char *s)
 
 #define SECRIT_MULTILINE_CHAR '\x02'
 
-#ifdef X11
-
-static inline int calc_text_width(const char *s)
+int calc_text_width(const char *s)
 {
 	size_t slen = strlen(s);
 
+#ifdef X11
 	if ((output_methods & TO_X) == 0) {
+#endif /* X11 */
 		return slen;
+#ifdef X11
 	}
 #ifdef XFT
 	if (use_xft) {
@@ -476,8 +497,8 @@ static inline int calc_text_width(const char *s)
 	{
 		return XTextWidth(fonts[selected_font].font, s, slen);
 	}
-}
 #endif /* X11 */
+}
 
 /* formatted text to render on screen, generated in generate_text(),
  * drawn in draw_stuff() */
@@ -705,73 +726,11 @@ static void extract_variable_text(const char *p)
 	extract_variable_text_internal(&global_root_object, p);
 }
 
-void parse_conky_vars(struct text_object *root, const char *txt, char *p, struct information *cur)
+void parse_conky_vars(struct text_object *root, const char *txt,
+		char *p, int p_max_size, struct information *cur)
 {
 	extract_variable_text_internal(root, txt);
-	generate_text_internal(p, max_user_text, *root, cur);
-}
-
-char *format_time(unsigned long timeval, const int width)
-{
-	char buf[10];
-	unsigned long nt;	// narrow time, for speed on 32-bit
-	unsigned cc;		// centiseconds
-	unsigned nn;		// multi-purpose whatever
-
-	nt = timeval;
-	cc = nt % 100;		// centiseconds past second
-	nt /= 100;			// total seconds
-	nn = nt % 60;		// seconds past the minute
-	nt /= 60;			// total minutes
-	if (width >= snprintf(buf, sizeof buf, "%lu:%02u.%02u",
-				nt, nn, cc)) {
-		return strndup(buf, text_buffer_size);
-	}
-	if (width >= snprintf(buf, sizeof buf, "%lu:%02u", nt, nn)) {
-		return strndup(buf, text_buffer_size);
-	}
-	nn = nt % 60;		// minutes past the hour
-	nt /= 60;			// total hours
-	if (width >= snprintf(buf, sizeof buf, "%lu,%02u", nt, nn)) {
-		return strndup(buf, text_buffer_size);
-	}
-	nn = nt;			// now also hours
-	if (width >= snprintf(buf, sizeof buf, "%uh", nn)) {
-		return strndup(buf, text_buffer_size);
-	}
-	nn /= 24;			// now days
-	if (width >= snprintf(buf, sizeof buf, "%ud", nn)) {
-		return strndup(buf, text_buffer_size);
-	}
-	nn /= 7;			// now weeks
-	if (width >= snprintf(buf, sizeof buf, "%uw", nn)) {
-		return strndup(buf, text_buffer_size);
-	}
-	// well shoot, this outta' fit...
-	return strndup("<inf>", text_buffer_size);
-}
-
-static inline void format_media_player_time(char *buf, const int size,
-		int seconds)
-{
-	int days, hours, minutes;
-
-	days = seconds / (24 * 60 * 60);
-	seconds %= (24 * 60 * 60);
-	hours = seconds / (60 * 60);
-	seconds %= (60 * 60);
-	minutes = seconds / 60;
-	seconds %= 60;
-
-	if (days > 0) {
-		snprintf(buf, size, "%i days %i:%02i:%02i", days,
-				hours, minutes, seconds);
-	} else if (hours > 0) {
-		snprintf(buf, size, "%i:%02i:%02i", hours, minutes,
-				seconds);
-	} else {
-		snprintf(buf, size, "%i:%02i", minutes, seconds);
-	}
+	generate_text_internal(p, p_max_size, *root, cur);
 }
 
 /* substitutes all occurrences of '\n' with SECRIT_MULTILINE_CHAR, which allows
@@ -832,7 +791,8 @@ void generate_text_internal(char *p, int p_max_size,
  */
 #define DO_JUMP { \
 	DBGP2("jumping"); \
-	obj = obj->data.ifblock.next; \
+	if (obj->ifblock_next) \
+		obj = obj->ifblock_next; \
 }
 
 #define OBJ(a) break; case OBJ_##a:
@@ -849,35 +809,31 @@ void generate_text_internal(char *p, int p_max_size,
 			}
 #endif /* !__OpenBSD__ */
 			OBJ(freq) {
-				if (obj->a) {
-					obj->a = get_freq(p, p_max_size, "%.0f", 1,
-							obj->data.cpu_index);
+				static int ok = 1;
+				if (ok) {
+					ok = get_freq(p, p_max_size, "%.0f", 1,
+							obj->data.i);
 				}
 			}
 			OBJ(freq_g) {
-				if (obj->a) {
+				static int ok = 1;
+				if (ok) {
 #ifndef __OpenBSD__
-					obj->a = get_freq(p, p_max_size, "%'.2f", 1000,
-							obj->data.cpu_index);
+					ok = get_freq(p, p_max_size, "%'.2f", 1000,
+							obj->data.i);
 #else
 					/* OpenBSD has no such flag (SUSv2) */
-					obj->a = get_freq(p, p_max_size, "%.2f", 1000,
-							obj->data.cpu_index);
+					ok = get_freq(p, p_max_size, "%.2f", 1000,
+							obj->data.i);
 #endif /* __OpenBSD */
 				}
 			}
 #if defined(__linux__)
 			OBJ(voltage_mv) {
-				if (obj->a) {
-					obj->a = get_voltage(p, p_max_size, "%.0f", 1,
-							obj->data.cpu_index);
-				}
+				print_voltage_mv(obj, p, p_max_size);
 			}
 			OBJ(voltage_v) {
-				if (obj->a) {
-					obj->a = get_voltage(p, p_max_size, "%'.3f", 1000,
-							obj->data.cpu_index);
-				}
+				print_voltage_v(obj, p, p_max_size);
 			}
 
 #ifdef HAVE_IWLIB
@@ -910,17 +866,11 @@ void generate_text_internal(char *p, int p_max_size,
 #endif /* __linux__ */
 
 #ifndef __OpenBSD__
-			OBJ(adt746xcpu) {
-				get_adt746x_cpu(p, p_max_size);
-			}
-			OBJ(adt746xfan) {
-				get_adt746x_fan(p, p_max_size);
-			}
 			OBJ(acpifan) {
 				get_acpi_fan(p, p_max_size);
 			}
 			OBJ(acpiacadapter) {
-				get_acpi_ac_adapter(p, p_max_size);
+				get_acpi_ac_adapter(p, p_max_size, (const char *)obj->data.opaque);
 			}
 			OBJ(battery) {
 				get_battery_stuff(p, p_max_size, obj->data.s, BATTERY_STATUS);
@@ -932,16 +882,7 @@ void generate_text_internal(char *p, int p_max_size,
 				percent_print(p, p_max_size, get_battery_perct(obj->data.s));
 			}
 			OBJ(battery_bar) {
-#ifdef X11
-				if(output_methods & TO_X) {
-					new_bar(p, obj->a, obj->b, get_battery_perct_bar(obj->data.s));
-				}else{
-#endif /* X11 */
-					if(!obj->a) obj->a = DEFAULT_BAR_WIDTH_NO_X;
-					new_bar_in_shell(p, p_max_size, get_battery_perct_bar(obj->data.s) / 2.55, obj->a);
-#ifdef X11
-				}
-#endif /* X11 */
+				new_bar(obj, p, p_max_size, get_battery_perct_bar(obj->data.s));
 			}
 			OBJ(battery_short) {
 				get_battery_short_status(p, p_max_size, obj->data.s);
@@ -954,42 +895,31 @@ void generate_text_internal(char *p, int p_max_size,
 			OBJ(cached) {
 				human_readable(cur->cached * 1024, p, 255);
 			}
+			OBJ(cmdline_to_pid) {
+				print_cmdline_to_pid(obj, p, p_max_size);
+			}
 			OBJ(cpu) {
-				if (obj->data.cpu_index > info.cpu_count) {
-					NORM_ERR("obj->data.cpu_index %i info.cpu_count %i",
-							obj->data.cpu_index, info.cpu_count);
-					CRIT_ERR(NULL, NULL, "attempting to use more CPUs than you have!");
+				if (cur->cpu_usage) {
+					if (obj->data.i > info.cpu_count) {
+						NORM_ERR("obj->data.i %i info.cpu_count %i",
+								obj->data.i, info.cpu_count);
+						CRIT_ERR(NULL, NULL, "attempting to use more CPUs than you have!");
+					}
+				    percent_print(p, p_max_size,
+				              round_to_int(cur->cpu_usage[obj->data.i] * 100.0));
 				}
-				percent_print(p, p_max_size,
-				              round_to_int(cur->cpu_usage[obj->data.cpu_index] * 100.0));
 			}
-#ifdef X11
 			OBJ(cpugauge)
-				new_gauge(p, obj->a, obj->b,
-						round_to_int(cur->cpu_usage[obj->data.cpu_index] * 255.0));
-#endif /* X11 */
+				new_gauge(obj, p, p_max_size, round_to_int(cur->cpu_usage[obj->data.i] * 255.0));
 			OBJ(cpubar) {
-#ifdef X11
-				if(output_methods & TO_X) {
-					new_bar(p, obj->a, obj->b,
-						round_to_int(cur->cpu_usage[obj->data.cpu_index] * 255.0));
-				}else{
-#endif /* X11 */
-					if(!obj->a) obj->a = DEFAULT_BAR_WIDTH_NO_X;
-					new_bar_in_shell(p, p_max_size, round_to_int(cur->cpu_usage[obj->data.cpu_index] * 100), obj->a);
-#ifdef X11
-				}
-#endif /* X11 */
+				new_bar(obj, p, p_max_size, round_to_int(cur->cpu_usage[obj->data.i] * 255.0));
 			}
 #ifdef X11
 			OBJ(cpugraph) {
-				new_graph(p, obj->a, obj->b, obj->c, obj->d,
-						round_to_int(cur->cpu_usage[obj->data.cpu_index] * 100),
-						100, 1, obj->char_a, obj->char_b);
+				new_graph(obj, p, p_max_size, round_to_int(cur->cpu_usage[obj->data.i] * 100));
 			}
 			OBJ(loadgraph) {
-				new_graph(p, obj->a, obj->b, obj->c, obj->d, cur->loadavg[0],
-						obj->e, 1, obj->char_a, obj->char_b);
+				print_loadgraph(obj, p, p_max_size);
 			}
 #endif /* X11 */
 			OBJ(color) {
@@ -1027,98 +957,53 @@ void generate_text_internal(char *p, int p_max_size,
 				new_fg(p, color9);
 			}
 #endif /* X11 */
-			OBJ(conky_version) {
-				snprintf(p, p_max_size, "%s", VERSION);
-			}
-			OBJ(conky_build_date) {
-				snprintf(p, p_max_size, "%s", BUILD_DATE);
-			}
-			OBJ(conky_build_arch) {
-				snprintf(p, p_max_size, "%s", BUILD_ARCH);
-			}
 #if defined(__linux__)
 			OBJ(disk_protect) {
 				snprintf(p, p_max_size, "%s",
 						get_disk_protect_queue(obj->data.s));
 			}
 			OBJ(i8k_version) {
-				snprintf(p, p_max_size, "%s", i8k.version);
+				print_i8k_version(obj, p, p_max_size);
 			}
 			OBJ(i8k_bios) {
-				snprintf(p, p_max_size, "%s", i8k.bios);
+				print_i8k_bios(obj, p, p_max_size);
 			}
 			OBJ(i8k_serial) {
-				snprintf(p, p_max_size, "%s", i8k.serial);
+				print_i8k_serial(obj, p, p_max_size);
 			}
 			OBJ(i8k_cpu_temp) {
-				int cpu_temp;
-
-				sscanf(i8k.cpu_temp, "%d", &cpu_temp);
-				temp_print(p, p_max_size, (double)cpu_temp, TEMP_CELSIUS);
+				print_i8k_cpu_temp(obj, p, p_max_size);
 			}
 			OBJ(i8k_left_fan_status) {
-				int left_fan_status;
-
-				sscanf(i8k.left_fan_status, "%d", &left_fan_status);
-				if (left_fan_status == 0) {
-					snprintf(p, p_max_size, "off");
-				}
-				if (left_fan_status == 1) {
-					snprintf(p, p_max_size, "low");
-				}
-				if (left_fan_status == 2) {
-					snprintf(p, p_max_size, "high");
-				}
+				print_i8k_left_fan_status(obj, p, p_max_size);
 			}
 			OBJ(i8k_right_fan_status) {
-				int right_fan_status;
-
-				sscanf(i8k.right_fan_status, "%d", &right_fan_status);
-				if (right_fan_status == 0) {
-					snprintf(p, p_max_size, "off");
-				}
-				if (right_fan_status == 1) {
-					snprintf(p, p_max_size, "low");
-				}
-				if (right_fan_status == 2) {
-					snprintf(p, p_max_size, "high");
-				}
+				print_i8k_right_fan_status(obj, p, p_max_size);
 			}
 			OBJ(i8k_left_fan_rpm) {
-				snprintf(p, p_max_size, "%s", i8k.left_fan_rpm);
+				print_i8k_left_fan_rpm(obj, p, p_max_size);
 			}
 			OBJ(i8k_right_fan_rpm) {
-				snprintf(p, p_max_size, "%s", i8k.right_fan_rpm);
+				print_i8k_right_fan_rpm(obj, p, p_max_size);
 			}
 			OBJ(i8k_ac_status) {
-				int ac_status;
-
-				sscanf(i8k.ac_status, "%d", &ac_status);
-				if (ac_status == -1) {
-					snprintf(p, p_max_size, "disabled (read i8k docs)");
-				}
-				if (ac_status == 0) {
-					snprintf(p, p_max_size, "off");
-				}
-				if (ac_status == 1) {
-					snprintf(p, p_max_size, "on");
-				}
+				print_i8k_ac_status(obj, p, p_max_size);
 			}
 			OBJ(i8k_buttons_status) {
-				snprintf(p, p_max_size, "%s", i8k.buttons_status);
+				print_i8k_buttons_status(obj, p, p_max_size);
 			}
 #if defined(IBM)
 			OBJ(ibm_fan) {
-				get_ibm_acpi_fan(p, p_max_size);
+				get_ibm_acpi_fan(obj, p, p_max_size);
 			}
 			OBJ(ibm_temps) {
 				print_ibm_temps(obj, p, p_max_size);
 			}
 			OBJ(ibm_volume) {
-				get_ibm_acpi_volume(p, p_max_size);
+				get_ibm_acpi_volume(obj, p, p_max_size);
 			}
 			OBJ(ibm_brightness) {
-				get_ibm_acpi_brightness(p, p_max_size);
+				get_ibm_acpi_brightness(obj, p, p_max_size);
 			}
 #endif /* IBM */
 			/* information from sony_laptop kernel module
@@ -1146,31 +1031,20 @@ void generate_text_internal(char *p, int p_max_size,
 #endif /* __linux__ */
 #if (defined(__FreeBSD__) || defined(__linux__))
 			OBJ(if_up) {
-				if ((obj->data.ifblock.s)
-						&& (!interface_up(obj->data.ifblock.s))) {
+				if (!interface_up(obj)) {
 					DO_JUMP;
 				}
 			}
 #endif
 #ifdef __OpenBSD__
 			OBJ(obsd_sensors_temp) {
-				obsd_sensors.device = sensor_device;
-				update_obsd_sensors();
-				temp_print(p, p_max_size,
-				           obsd_sensors.temp[obsd_sensors.device][obj->data.sensor],
-					   TEMP_CELSIUS);
+				print_obsd_sensors_temp(obj, p, p_max_size);
 			}
 			OBJ(obsd_sensors_fan) {
-				obsd_sensors.device = sensor_device;
-				update_obsd_sensors();
-				snprintf(p, p_max_size, "%d",
-						obsd_sensors.fan[obsd_sensors.device][obj->data.sensor]);
+				print_obsd_sensors_fan(obj, p, p_max_size);
 			}
 			OBJ(obsd_sensors_volt) {
-				obsd_sensors.device = sensor_device;
-				update_obsd_sensors();
-				snprintf(p, p_max_size, "%.2f",
-						obsd_sensors.volt[obsd_sensors.device][obj->data.sensor]);
+				print_obsd_sensors_volt(obj, p, p_max_size);
 			}
 			OBJ(obsd_vendor) {
 				get_obsd_vendor(p, p_max_size);
@@ -1185,32 +1059,24 @@ void generate_text_internal(char *p, int p_max_size,
 				need_to_load_fonts = 1;
 			}
 #endif /* X11 */
-			/* TODO: move this correction from kB to kB/s elsewhere
-			 * (or get rid of it??) */
 			OBJ(diskio) {
-				human_readable((obj->data.diskio->current / update_interval) * 1024LL,
-						p, p_max_size);
+				print_diskio(obj, p, p_max_size);
 			}
 			OBJ(diskio_write) {
-				human_readable((obj->data.diskio->current_write / update_interval) * 1024LL,
-						p, p_max_size);
+				print_diskio_write(obj, p, p_max_size);
 			}
 			OBJ(diskio_read) {
-				human_readable((obj->data.diskio->current_read / update_interval) * 1024LL,
-						p, p_max_size);
+				print_diskio_read(obj, p, p_max_size);
 			}
 #ifdef X11
 			OBJ(diskiograph) {
-				new_graph(p, obj->a, obj->b, obj->c, obj->d,
-				          obj->data.diskio->current, obj->e, 1, obj->char_a, obj->char_b);
+				print_diskiograph(obj, p, p_max_size);
 			}
 			OBJ(diskiograph_read) {
-				new_graph(p, obj->a, obj->b, obj->c, obj->d,
-				          obj->data.diskio->current_read, obj->e, 1, obj->char_a, obj->char_b);
+				print_diskiograph_read(obj, p, p_max_size);
 			}
 			OBJ(diskiograph_write) {
-				new_graph(p, obj->a, obj->b, obj->c, obj->d,
-				          obj->data.diskio->current_write, obj->e, 1, obj->char_a, obj->char_b);
+				print_diskiograph_write(obj, p, p_max_size);
 			}
 #endif /* X11 */
 			OBJ(downspeed) {
@@ -1221,7 +1087,7 @@ void generate_text_internal(char *p, int p_max_size,
 			}
 #ifdef X11
 			OBJ(downspeedgraph) {
-				print_downspeedgraph(obj, p);
+				print_downspeedgraph(obj, p, p_max_size);
 			}
 #endif /* X11 */
 			OBJ(else) {
@@ -1229,7 +1095,7 @@ void generate_text_internal(char *p, int p_max_size,
 				 * Do Ninja jump here: without leaving traces.
 				 * This is to prevent us from stale jumped flags.
 				 */
-				obj = obj->data.ifblock.next;
+				obj = obj->ifblock_next;
 				continue;
 			}
 			OBJ(endif) {
@@ -1251,7 +1117,7 @@ void generate_text_internal(char *p, int p_max_size,
 			}
 #endif /* IMLIB2 */
 			OBJ(eval) {
-				evaluate(obj->data.s, p);
+				evaluate(obj->data.s, p, p_max_size);
 			}
 			OBJ(exec) {
 				print_exec(obj, p, p_max_size);
@@ -1259,11 +1125,9 @@ void generate_text_internal(char *p, int p_max_size,
 			OBJ(execp) {
 				print_execp(obj, p, p_max_size);
 			}
-#ifdef X11
 			OBJ(execgauge) {
 				print_execgauge(obj, p, p_max_size);
 			}
-#endif /* X11 */
 			OBJ(execbar) {
 				print_execbar(obj, p, p_max_size);
 			}
@@ -1279,15 +1143,15 @@ void generate_text_internal(char *p, int p_max_size,
 			OBJ(execigraph) {
 				print_execigraph(obj, p, p_max_size);
 			}
+#endif /* X11 */
 			OBJ(execigauge) {
 				print_execigauge(obj, p, p_max_size);
 			}
-#endif /* X11 */
 			OBJ(execi) {
 				print_execi(obj, p, p_max_size);
 			}
 			OBJ(execpi) {
-				print_execpi(obj, p);
+				print_execpi(obj, p, p_max_size);
 			}
 			OBJ(texeci) {
 				print_texeci(obj, p, p_max_size);
@@ -1329,27 +1193,13 @@ void generate_text_internal(char *p, int p_max_size,
 				print_fs_perc(obj, 0, p, p_max_size);
 			}
 			OBJ(loadavg) {
-				float *v = info.loadavg;
-
-				if (obj->data.loadavg[2]) {
-					snprintf(p, p_max_size, "%.2f %.2f %.2f",
-						v[obj->data.loadavg[0] - 1],
-						v[obj->data.loadavg[1] - 1],
-						v[obj->data.loadavg[2] - 1]);
-				} else if (obj->data.loadavg[1]) {
-					snprintf(p, p_max_size, "%.2f %.2f",
-						v[obj->data.loadavg[0] - 1],
-						v[obj->data.loadavg[1] - 1]);
-				} else if (obj->data.loadavg[0]) {
-					snprintf(p, p_max_size, "%.2f",
-						v[obj->data.loadavg[0] - 1]);
-				}
+				print_loadavg(obj, p, p_max_size);
 			}
 			OBJ(goto) {
 				new_goto(p, obj->data.i);
 			}
 			OBJ(tab) {
-				new_tab(p, obj->data.pair.a, obj->data.pair.b);
+				new_tab(obj, p);
 			}
 #ifdef X11
 			OBJ(hr) {
@@ -1386,49 +1236,22 @@ void generate_text_internal(char *p, int p_max_size,
 #endif
 #ifdef HAVE_LUA
 			OBJ(lua) {
-				char *str = llua_getstring(obj->data.s);
-				if (str) {
-					snprintf(p, p_max_size, "%s", str);
-					free(str);
-				}
+				print_lua(obj, p, p_max_size);
 			}
 			OBJ(lua_parse) {
-				char *str = llua_getstring(obj->data.s);
-				if (str) {
-					evaluate(str, p);
-					free(str);
-				}
+				print_lua_parse(obj, p, p_max_size);
 			}
 			OBJ(lua_bar) {
-				double per;
-				if (llua_getnumber(obj->data.s, &per)) {
-#ifdef X11
-					if(output_methods & TO_X) {
-						new_bar(p, obj->a, obj->b, (per/100.0 * 255));
-					} else {
-#endif /* X11 */
-						if(!obj->a) obj->a = DEFAULT_BAR_WIDTH_NO_X;
-						new_bar_in_shell(p, p_max_size, per, obj->a);
-#ifdef X11
-					}
-#endif /* X11 */
-				}
+				print_lua_bar(obj, p, p_max_size);
 			}
 #ifdef X11
 			OBJ(lua_graph) {
-				double per;
-				if (llua_getnumber(obj->data.s, &per)) {
-					new_graph(p, obj->a, obj->b, obj->c, obj->d,
-							per, obj->e, 1, obj->char_a, obj->char_b);
-				}
+				print_lua_graph(obj, p, p_max_size);
 			}
+#endif /* X11 */
 			OBJ(lua_gauge) {
-				double per;
-				if (llua_getnumber(obj->data.s, &per)) {
-					new_gauge(p, obj->a, obj->b, (per/100.0 * 255));
-				}
+				print_lua_gauge(obj, p, p_max_size);
 			}
-#endif /* X11 */
 #endif /* HAVE_LUA */
 #ifdef HDDTEMP
 			OBJ(hddtemp) {
@@ -1500,26 +1323,29 @@ void generate_text_internal(char *p, int p_max_size,
 				free(tmp_info);
 			}
 			OBJ(if_existing) {
-				if (obj->data.ifblock.str
-				    && !check_contains(obj->data.ifblock.s,
-				                       obj->data.ifblock.str)) {
-					DO_JUMP;
-				} else if (obj->data.ifblock.s
-				           && access(obj->data.ifblock.s, F_OK)) {
+				char *spc;
+
+				spc = strchr(obj->data.s, ' ');
+				if (!spc && access(obj->data.s, F_OK)) {
 					DO_JUMP;
+				} else if (spc) {
+					*spc = '\0';
+					if (check_contains(obj->data.s, spc + 1))
+						DO_JUMP;
+					*spc = ' ';
 				}
 			}
 			OBJ(if_mounted) {
-				if ((obj->data.ifblock.s)
-						&& (!check_mount(obj->data.ifblock.s))) {
+				if ((obj->data.s)
+						&& (!check_mount(obj->data.s))) {
 					DO_JUMP;
 				}
 			}
 			OBJ(if_running) {
 #ifdef __linux__
-				if (!get_process_by_name(obj->data.ifblock.s)) {
+				if (!get_process_by_name(obj->data.s)) {
 #else
-				if ((obj->data.ifblock.s) && system(obj->data.ifblock.s)) {
+				if ((obj->data.s) && system(obj->data.s)) {
 #endif
 					DO_JUMP;
 				}
@@ -1553,58 +1379,38 @@ void generate_text_internal(char *p, int p_max_size,
 				if (cur->memmax)
 					percent_print(p, p_max_size, cur->mem * 100 / cur->memmax);
 			}
-#ifdef X11
 			OBJ(memgauge){
-				new_gauge(p, obj->data.pair.a, obj->data.pair.b,
-					cur->memmax ? (cur->mem * 255) / (cur->memmax) : 0);
+				new_gauge(obj, p, p_max_size, cur->memmax ? (cur->mem * 255) / (cur->memmax) : 0);
 			}
-#endif /* X11 */
 			OBJ(membar) {
-#ifdef X11
-				if(output_methods & TO_X) {
-					new_bar(p, obj->data.pair.a, obj->data.pair.b,
-						cur->memmax ? (cur->mem * 255) / (cur->memmax) : 0);
-				}else{
-#endif /* X11 */
-					if(!obj->data.pair.a) obj->data.pair.a = DEFAULT_BAR_WIDTH_NO_X;
-					new_bar_in_shell(p, p_max_size, cur->memmax ? (cur->mem * 100) / (cur->memmax) : 0, obj->data.pair.a);
-#ifdef X11
-				}
-#endif /* X11 */
+				new_bar(obj, p, p_max_size, cur->memmax ? (cur->mem * 255) / (cur->memmax) : 0);
 			}
 #ifdef X11
 			OBJ(memgraph) {
-				new_graph(p, obj->a, obj->b, obj->c, obj->d,
-					cur->memmax ? (cur->mem * 100.0) / (cur->memmax) : 0.0,
-					100, 1, obj->char_a, obj->char_b);
+				new_graph(obj, p, p_max_size, cur->memmax ? (cur->mem * 100.0) / (cur->memmax) : 0.0);
 			}
 #endif /* X11 */
 			/* mixer stuff */
 			OBJ(mixer) {
-				percent_print(p, p_max_size, mixer_get_avg(obj->data.l));
+				print_mixer(obj, p, p_max_size);
 			}
 			OBJ(mixerl) {
-				percent_print(p, p_max_size, mixer_get_left(obj->data.l));
+				print_mixerl(obj, p, p_max_size);
 			}
 			OBJ(mixerr) {
-				percent_print(p, p_max_size, mixer_get_right(obj->data.l));
+				print_mixerr(obj, p, p_max_size);
 			}
-#ifdef X11
 			OBJ(mixerbar) {
-				new_bar(p, obj->data.mixerbar.w, obj->data.mixerbar.h,
-					mixer_to_255(obj->data.mixerbar.l,mixer_get_avg(obj->data.mixerbar.l)));
+				print_mixer_bar(obj, p, p_max_size);
 			}
 			OBJ(mixerlbar) {
-				new_bar(p, obj->data.mixerbar.w, obj->data.mixerbar.h,
-					mixer_to_255(obj->data.mixerbar.l,mixer_get_left(obj->data.mixerbar.l)));
+				print_mixerl_bar(obj, p, p_max_size);
 			}
 			OBJ(mixerrbar) {
-				new_bar(p, obj->data.mixerbar.w, obj->data.mixerbar.h,
-					mixer_to_255(obj->data.mixerbar.l,mixer_get_right(obj->data.mixerbar.l)));
+				print_mixerr_bar(obj, p, p_max_size);
 			}
-#endif /* X11 */
 			OBJ(if_mixer_mute) {
-				if (!mixer_is_mute(obj->data.ifblock.i)) {
+				if (!check_mixer_muted(obj)) {
 					DO_JUMP;
 				}
 			}
@@ -1647,6 +1453,13 @@ void generate_text_internal(char *p, int p_max_size,
 			}
 #endif /* X11 */
 
+			OBJ(format_time) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_format_time(obj, p, p_max_size);
+			}
 			/* mail stuff */
 			OBJ(mails) {
 				print_mails(obj, p, p_max_size);
@@ -1685,9 +1498,7 @@ void generate_text_internal(char *p, int p_max_size,
 				print_trashed_mails(obj, p, p_max_size);
 			}
 			OBJ(mboxscan) {
-				mbox_scan(obj->data.mboxscan.args, obj->data.mboxscan.output,
-					text_buffer_size);
-				snprintf(p, p_max_size, "%s", obj->data.mboxscan.output);
+				print_mboxscan(obj, p, p_max_size);
 			}
 			OBJ(nodename) {
 				snprintf(p, p_max_size, "%s", cur->uname_s.nodename);
@@ -1695,12 +1506,298 @@ void generate_text_internal(char *p, int p_max_size,
 			OBJ(outlinecolor) {
 				new_outline(p, obj->data.l);
 			}
+			OBJ(pid_chroot) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_chroot(obj, p, p_max_size);
+			}
+			OBJ(pid_cmdline) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_cmdline(obj, p, p_max_size);
+			}
+			OBJ(pid_cwd) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_cwd(obj, p, p_max_size);
+			}
+			OBJ(pid_environ) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_environ(obj, p, p_max_size);
+			}
+			OBJ(pid_environ_list) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_environ_list(obj, p, p_max_size);
+			}
+			OBJ(pid_exe) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_exe(obj, p, p_max_size);
+			}
+			OBJ(pid_nice) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_nice(obj, p, p_max_size);
+			}
+			OBJ(pid_openfiles) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_openfiles(obj, p, p_max_size);
+			}
+			OBJ(pid_parent) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_parent(obj, p, p_max_size);
+			}
+			OBJ(pid_priority) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_priority(obj, p, p_max_size);
+			}
+			OBJ(pid_state) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_state(obj, p, p_max_size);
+			}
+			OBJ(pid_state_short) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_state_short(obj, p, p_max_size);
+			}
+			OBJ(pid_stderr) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_stderr(obj, p, p_max_size);
+			}
+			OBJ(pid_stdin) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_stdin(obj, p, p_max_size);
+			}
+			OBJ(pid_stdout) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_stdout(obj, p, p_max_size);
+			}
+			OBJ(pid_threads) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_threads(obj, p, p_max_size);
+			}
+			OBJ(pid_thread_list) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_thread_list(obj, p, p_max_size);
+			}
+			OBJ(pid_time_kernelmode) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_time_kernelmode(obj, p, p_max_size);
+			}
+			OBJ(pid_time_usermode) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_time_usermode(obj, p, p_max_size);
+			}
+			OBJ(pid_time) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_time(obj, p, p_max_size);
+			}
+			OBJ(pid_uid) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_uid(obj, p, p_max_size);
+			}
+			OBJ(pid_euid) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_euid(obj, p, p_max_size);
+			}
+			OBJ(pid_suid) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_suid(obj, p, p_max_size);
+			}
+			OBJ(pid_fsuid) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_fsuid(obj, p, p_max_size);
+			}
+			OBJ(pid_gid) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_gid(obj, p, p_max_size);
+			}
+			OBJ(pid_egid) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_egid(obj, p, p_max_size);
+			}
+			OBJ(pid_sgid) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_sgid(obj, p, p_max_size);
+			}
+			OBJ(pid_fsgid) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_fsgid(obj, p, p_max_size);
+			}
+			OBJ(pid_read) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_read(obj, p, p_max_size);
+			}
+			OBJ(pid_vmpeak) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_vmpeak(obj, p, p_max_size);
+			}
+			OBJ(pid_vmsize) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_vmsize(obj, p, p_max_size);
+			}
+			OBJ(pid_vmlck) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_vmlck(obj, p, p_max_size);
+			}
+			OBJ(pid_vmhwm) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_vmhwm(obj, p, p_max_size);
+			}
+			OBJ(pid_vmrss) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_vmrss(obj, p, p_max_size);
+			}
+			OBJ(pid_vmdata) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_vmdata(obj, p, p_max_size);
+			}
+			OBJ(pid_vmstk) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_vmstk(obj, p, p_max_size);
+			}
+			OBJ(pid_vmexe) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_vmexe(obj, p, p_max_size);
+			}
+			OBJ(pid_vmlib) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_vmlib(obj, p, p_max_size);
+			}
+			OBJ(pid_vmpte) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_vmpte(obj, p, p_max_size);
+			}
+			OBJ(pid_write) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_pid_write(obj, p, p_max_size);
+			}
 			OBJ(processes) {
 				spaced_print(p, p_max_size, "%hu", 4, cur->procs);
 			}
 			OBJ(running_processes) {
 				spaced_print(p, p_max_size, "%hu", 4, cur->run_procs);
 			}
+			OBJ(running_threads) {
+				spaced_print(p, p_max_size, "%hu", 4, cur->run_threads);
+			}
+			OBJ(threads) {
+				spaced_print(p, p_max_size, "%hu", 4, cur->threads);
+			}
 			OBJ(text) {
 				snprintf(p, p_max_size, "%s", obj->data.s);
 			}
@@ -1709,7 +1806,7 @@ void generate_text_internal(char *p, int p_max_size,
 				new_bg(p, obj->data.l);
 			}
 			OBJ(stippled_hr) {
-				new_stippled_hr(p, obj->data.pair.a, obj->data.pair.b);
+				new_stippled_hr(obj, p);
 			}
 #endif /* X11 */
 			OBJ(swap) {
@@ -1729,17 +1826,7 @@ void generate_text_internal(char *p, int p_max_size,
 				}
 			}
 			OBJ(swapbar) {
-#ifdef X11
-				if(output_methods & TO_X) {
-					new_bar(p, obj->data.pair.a, obj->data.pair.b,
-						cur->swapmax ? (cur->swap * 255) / (cur->swapmax) : 0);
-				}else{
-#endif /* X11 */
-					if(!obj->data.pair.a) obj->data.pair.a = DEFAULT_BAR_WIDTH_NO_X;
-					new_bar_in_shell(p, p_max_size, cur->swapmax ? (cur->swap * 100) / (cur->swapmax) : 0, obj->data.pair.a);
-#ifdef X11
-				}
-#endif /* X11 */
+				new_bar(obj, p, p_max_size, cur->swapmax ? (cur->swap * 255) / (cur->swapmax) : 0);
 			}
 			OBJ(sysname) {
 				snprintf(p, p_max_size, "%s", cur->uname_s.sysname);
@@ -1759,11 +1846,25 @@ void generate_text_internal(char *p, int p_max_size,
 			OBJ(totalup) {
 				print_totalup(obj, p, p_max_size);
 			}
+			OBJ(gid_name) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_gid_name(obj, p, p_max_size);
+			}
+			OBJ(uid_name) {
+				char buf[max_user_text];
+
+				generate_text_internal(buf, max_user_text, *obj->sub, cur);
+				obj->data.s = buf;
+				print_uid_name(obj, p, p_max_size);
+			}
 			OBJ(updates) {
 				snprintf(p, p_max_size, "%d", total_updates);
 			}
 			OBJ(if_updatenr) {
-				if(total_updates % updatereset != obj->data.ifblock.i - 1) {
+				if(total_updates % updatereset != obj->data.i - 1) {
 					DO_JUMP;
 				}
 			}
@@ -1775,7 +1876,7 @@ void generate_text_internal(char *p, int p_max_size,
 			}
 #ifdef X11
 			OBJ(upspeedgraph) {
-				print_upspeedgraph(obj, p);
+				print_upspeedgraph(obj, p, p_max_size);
 			}
 #endif /* X11 */
 			OBJ(uptime_short) {
@@ -1784,6 +1885,7 @@ void generate_text_internal(char *p, int p_max_size,
 			OBJ(uptime) {
 				format_seconds(p, p_max_size, (int) cur->uptime);
 			}
+#ifdef __linux__
 			OBJ(user_names) {
 				snprintf(p, p_max_size, "%s", cur->users.names);
 			}
@@ -1793,9 +1895,14 @@ void generate_text_internal(char *p, int p_max_size,
 			OBJ(user_times) {
 				snprintf(p, p_max_size, "%s", cur->users.times);
 			}
+			OBJ(user_time) {
+				update_user_time(obj->data.s);
+				snprintf(p, p_max_size, "%s", cur->users.ctime);
+			}
 			OBJ(user_number) {
 				snprintf(p, p_max_size, "%d", cur->users.number);
 			}
+#endif /* __linux__ */
 #if (defined(__FreeBSD__) || defined(__FreeBSD_kernel__) \
 		|| defined(__OpenBSD__)) && (defined(i386) || defined(__i386__))
 			OBJ(apm_adapter) {
@@ -1822,86 +1929,48 @@ void generate_text_internal(char *p, int p_max_size,
 #endif /* __FreeBSD__ __OpenBSD__ */
 
 #ifdef MPD
-#define mpd_printf(fmt, val) \
-	snprintf(p, p_max_size, fmt, mpd_get_info()->val)
-#define mpd_sprintf(val) { \
-	if (!obj->data.i || obj->data.i > p_max_size) \
-		mpd_printf("%s", val); \
-	else \
-		snprintf(p, obj->data.i, "%s", mpd_get_info()->val); \
-}
 			OBJ(mpd_title)
-				mpd_sprintf(title);
+				print_mpd_title(obj, p, p_max_size);
 			OBJ(mpd_artist)
-				mpd_sprintf(artist);
+				print_mpd_artist(obj, p, p_max_size);
 			OBJ(mpd_album)
-				mpd_sprintf(album);
+				print_mpd_album(obj, p, p_max_size);
 			OBJ(mpd_random)
-				mpd_printf("%s", random);
+				print_mpd_random(obj, p, p_max_size);
 			OBJ(mpd_repeat)
-				mpd_printf("%s", repeat);
+				print_mpd_repeat(obj, p, p_max_size);
 			OBJ(mpd_track)
-				mpd_sprintf(track);
+				print_mpd_track(obj, p, p_max_size);
 			OBJ(mpd_name)
-				mpd_sprintf(name);
+				print_mpd_name(obj, p, p_max_size);
 			OBJ(mpd_file)
-				mpd_sprintf(file);
+				print_mpd_file(obj, p, p_max_size);
 			OBJ(mpd_vol)
-				mpd_printf("%d", volume);
+				print_mpd_vol(obj, p, p_max_size);
 			OBJ(mpd_bitrate)
-				mpd_printf("%d", bitrate);
+				print_mpd_bitrate(obj, p, p_max_size);
 			OBJ(mpd_status)
-				mpd_printf("%s", status);
+				print_mpd_status(obj, p, p_max_size);
 			OBJ(mpd_elapsed) {
-				format_media_player_time(p, p_max_size, mpd_get_info()->elapsed);
+				print_mpd_elapsed(obj, p, p_max_size);
 			}
 			OBJ(mpd_length) {
-				format_media_player_time(p, p_max_size, mpd_get_info()->length);
+				print_mpd_length(obj, p, p_max_size);
 			}
 			OBJ(mpd_percent) {
-				percent_print(p, p_max_size, (int)(mpd_get_info()->progress * 100));
+				print_mpd_percent(obj, p, p_max_size);
 			}
 			OBJ(mpd_bar) {
-#ifdef X11
-				if(output_methods & TO_X) {
-					new_bar(p, obj->data.pair.a, obj->data.pair.b,
-						(int) (mpd_get_info()->progress * 255.0f));
-				} else {
-#endif /* X11 */
-					if(!obj->data.pair.a) obj->data.pair.a = DEFAULT_BAR_WIDTH_NO_X;
-					new_bar_in_shell(p, p_max_size, (int) (mpd_get_info()->progress * 100.0f), obj->data.pair.a);
-#ifdef X11
-				}
-#endif /* X11 */
+				print_mpd_bar(obj, p, p_max_size);
 			}
 			OBJ(mpd_smart) {
-				struct mpd_s *mpd = mpd_get_info();
-				int len = obj->data.i;
-				if (len == 0 || len > p_max_size)
-					len = p_max_size;
-
-				memset(p, 0, p_max_size);
-				if (mpd->artist && *mpd->artist &&
-				    mpd->title && *mpd->title) {
-					snprintf(p, len, "%s - %s", mpd->artist,
-						mpd->title);
-				} else if (mpd->title && *mpd->title) {
-					snprintf(p, len, "%s", mpd->title);
-				} else if (mpd->artist && *mpd->artist) {
-					snprintf(p, len, "%s", mpd->artist);
-				} else if (mpd->file && *mpd->file) {
-					snprintf(p, len, "%s", mpd->file);
-				} else {
-					*p = 0;
-				}
+				print_mpd_smart(obj, p, p_max_size);
 			}
 			OBJ(if_mpd_playing) {
 				if (!mpd_get_info()->is_playing) {
 					DO_JUMP;
 				}
 			}
-#undef mpd_sprintf
-#undef mpd_printf
 #endif
 
 #ifdef MOC
@@ -1993,12 +2062,9 @@ void generate_text_internal(char *p, int p_max_size,
 			OBJ(xmms2_percent) {
 				snprintf(p, p_max_size, "%2.0f", cur->xmms2.progress * 100);
 			}
-#ifdef X11
 			OBJ(xmms2_bar) {
-				new_bar(p, obj->data.pair.a, obj->data.pair.b,
-					(int) (cur->xmms2.progress * 255.0f));
+				new_bar(obj, p, p_max_size, (int) (cur->xmms2.progress * 255.0f));
 			}
-#endif /* X11 */
 			OBJ(xmms2_playlist) {
 				snprintf(p, p_max_size, "%s", cur->xmms2.playlist);
 			}
@@ -2074,16 +2140,14 @@ void generate_text_internal(char *p, int p_max_size,
 				snprintf(p, p_max_size, "%s",
 					cur->audacious.items[AUDACIOUS_MAIN_VOLUME]);
 			}
-#ifdef X11
 			OBJ(audacious_bar) {
 				double progress;
 
 				progress =
 					atof(cur->audacious.items[AUDACIOUS_POSITION_SECONDS]) /
 					atof(cur->audacious.items[AUDACIOUS_LENGTH_SECONDS]);
-				new_bar(p, obj->a, obj->b, (int) (progress * 255.0f));
+				new_bar(obj, p, p_max_size, (int) (progress * 255.0f));
 			}
-#endif /* X11 */
 #endif /* AUDACIOUS */
 
 #ifdef BMPX
@@ -2109,72 +2173,16 @@ void generate_text_internal(char *p, int p_max_size,
 			/* we have four different types of top (top, top_mem,
 			 * top_time and top_io). To avoid having almost-same code four
 			 * times, we have this special handler. */
+#ifdef __linux__
 			break;
 			case OBJ_top:
-				parse_top_args("top", obj->data.top.s, obj);
-				if (!needed) needed = cur->cpu;
 			case OBJ_top_mem:
-				parse_top_args("top_mem", obj->data.top.s, obj);
-				if (!needed) needed = cur->memu;
 			case OBJ_top_time:
-				parse_top_args("top_time", obj->data.top.s, obj);
-				if (!needed) needed = cur->time;
 #ifdef IOSTATS
 			case OBJ_top_io:
-				parse_top_args("top_io", obj->data.top.s, obj);
-				if (!needed) needed = cur->io;
-#endif
-
-				if (needed[obj->data.top.num]) {
-					char *timeval;
-
-					switch (obj->data.top.type) {
-						case TOP_NAME:
-							snprintf(p, top_name_width + 1, "%-*s", top_name_width,
-									needed[obj->data.top.num]->name);
-							break;
-						case TOP_CPU:
-							snprintf(p, 7, "%6.2f",
-									needed[obj->data.top.num]->amount);
-							break;
-						case TOP_PID:
-							snprintf(p, 6, "%5i",
-									needed[obj->data.top.num]->pid);
-							break;
-						case TOP_MEM:
-							snprintf(p, 7, "%6.2f",
-									needed[obj->data.top.num]->totalmem);
-							break;
-						case TOP_TIME:
-							timeval = format_time(
-									needed[obj->data.top.num]->total_cpu_time, 9);
-							snprintf(p, 10, "%9s", timeval);
-							free(timeval);
-							break;
-						case TOP_MEM_RES:
-							human_readable(needed[obj->data.top.num]->rss,
-									p, 255);
-							break;
-						case TOP_MEM_VSIZE:
-							human_readable(needed[obj->data.top.num]->vsize,
-									p, 255);
-							break;
-#ifdef IOSTATS
-						case TOP_READ_BYTES:
-							human_readable(needed[obj->data.top.num]->read_bytes / update_interval,
-									p, 255);
-							break;
-						case TOP_WRITE_BYTES:
-							human_readable(needed[obj->data.top.num]->write_bytes / update_interval,
-									p, 255);
-							break;
-						case TOP_IO_PERC:
-							snprintf(p, 7, "%6.2f",
-									needed[obj->data.top.num]->io_perc);
-							break;
 #endif
-					}
-				}
+				print_top(obj, p, p_max_size);
+#endif /* __linux__ */
 			OBJ(tail) {
 				print_tailhead("tail", obj, p, p_max_size);
 			}
@@ -2182,55 +2190,11 @@ void generate_text_internal(char *p, int p_max_size,
 				print_tailhead("head", obj, p, p_max_size);
 			}
 			OBJ(lines) {
-				FILE *fp = open_file(obj->data.s, &obj->a);
-
-				if(fp != NULL) {
-/* FIXME: use something more general (see also tail.c, head.c */
-#define BUFSZ 0x1000
-					char buf[BUFSZ];
-					int j, lines;
-
-					lines = 0;
-					while(fgets(buf, BUFSZ, fp) != NULL){
-						for(j = 0; buf[j] != 0; j++) {
-							if(buf[j] == '\n') {
-								lines++;
-							}
-						}
-					}
-					sprintf(p, "%d", lines);
-					fclose(fp);
-				} else {
-					sprintf(p, "File Unreadable");
-				}
+				print_lines(obj, p, p_max_size);
 			}
 
 			OBJ(words) {
-				FILE *fp = open_file(obj->data.s, &obj->a);
-
-				if(fp != NULL) {
-					char buf[BUFSZ];
-					int j, words;
-					char inword = FALSE;
-
-					words = 0;
-					while(fgets(buf, BUFSZ, fp) != NULL){
-						for(j = 0; buf[j] != 0; j++) {
-							if(!isspace(buf[j])) {
-								if(inword == FALSE) {
-									words++;
-									inword = TRUE;
-								}
-							} else {
-								inword = FALSE;
-							}
-						}
-					}
-					sprintf(p, "%d", words);
-					fclose(fp);
-				} else {
-					sprintf(p, "File Unreadable");
-				}
+				print_words(obj, p, p_max_size);
 			}
 #ifdef TCP_PORT_MONITOR
 			OBJ(tcp_portmon) {
@@ -2248,44 +2212,24 @@ void generate_text_internal(char *p, int p_max_size,
 #endif /* HAVE_ICONV */
 
 			OBJ(entropy_avail) {
-				snprintf(p, p_max_size, "%d", cur->entropy.entropy_avail);
+				print_entropy_avail(obj, p, p_max_size);
 			}
 			OBJ(entropy_perc) {
-				percent_print(p, p_max_size,
-				              cur->entropy.entropy_avail *
-					      100 / cur->entropy.poolsize);
+				print_entropy_perc(obj, p, p_max_size);
 			}
 			OBJ(entropy_poolsize) {
-				snprintf(p, p_max_size, "%d", cur->entropy.poolsize);
+				print_entropy_poolsize(obj, p, p_max_size);
 			}
 			OBJ(entropy_bar) {
-				double entropy_perc;
-
-				entropy_perc = (double) cur->entropy.entropy_avail /
-					(double) cur->entropy.poolsize;
-#ifdef X11
-				if(output_methods & TO_X) {
-					new_bar(p, obj->a, obj->b, (int) (entropy_perc * 255.0f));
-				} else {
-#endif /* X11 */
-					if(!obj->a) obj->a = DEFAULT_BAR_WIDTH_NO_X;
-					new_bar_in_shell(p, p_max_size, (int) (entropy_perc * 100.0f), obj->a);
-#ifdef X11
-				}
-#endif /* X11 */
+				print_entropy_bar(obj, p, p_max_size);
 			}
 #ifdef IBM
 			OBJ(smapi) {
-				char *s;
-				if(obj->data.s) {
-					s = smapi_get_val(obj->data.s);
-					snprintf(p, p_max_size, "%s", s);
-					free(s);
-				}
+				print_smapi(obj, p, p_max_size);
 			}
 			OBJ(if_smapi_bat_installed) {
 				int idx;
-				if(obj->data.ifblock.s && sscanf(obj->data.ifblock.s, "%i", &idx) == 1) {
+				if(obj->data.s && sscanf(obj->data.s, "%i", &idx) == 1) {
 					if(!smapi_bat_installed(idx)) {
 						DO_JUMP;
 					}
@@ -2293,43 +2237,17 @@ void generate_text_internal(char *p, int p_max_size,
 					NORM_ERR("argument to if_smapi_bat_installed must be an integer");
 			}
 			OBJ(smapi_bat_perc) {
-				int idx, val;
-				if(obj->data.s && sscanf(obj->data.s, "%i", &idx) == 1) {
-					val = smapi_bat_installed(idx) ?
-						smapi_get_bat_int(idx, "remaining_percent") : 0;
-					percent_print(p, p_max_size, val);
-				} else
-					NORM_ERR("argument to smapi_bat_perc must be an integer");
+				print_smapi_bat_perc(obj, p, p_max_size);
 			}
 			OBJ(smapi_bat_temp) {
-				int idx, val;
-				if(obj->data.s && sscanf(obj->data.s, "%i", &idx) == 1) {
-					val = smapi_bat_installed(idx) ?
-						smapi_get_bat_int(idx, "temperature") : 0;
-					/* temperature is in milli degree celsius */
-					temp_print(p, p_max_size, val / 1000, TEMP_CELSIUS);
-				} else
-					NORM_ERR("argument to smapi_bat_temp must be an integer");
+				print_smapi_bat_temp(obj, p, p_max_size);
 			}
 			OBJ(smapi_bat_power) {
-				int idx, val;
-				if(obj->data.s && sscanf(obj->data.s, "%i", &idx) == 1) {
-					val = smapi_bat_installed(idx) ?
-						smapi_get_bat_int(idx, "power_now") : 0;
-					/* power_now is in mW, set to W with one digit precision */
-					snprintf(p, p_max_size, "%.1f", ((double)val / 1000));
-				} else
-					NORM_ERR("argument to smapi_bat_power must be an integer");
+				print_smapi_bat_power(obj, p, p_max_size);
 			}
-#ifdef X11
 			OBJ(smapi_bat_bar) {
-				if(obj->data.i >= 0 && smapi_bat_installed(obj->data.i))
-					new_bar(p, obj->a, obj->b, (int)
-							(255 * smapi_get_bat_int(obj->data.i, "remaining_percent") / 100));
-				else
-					new_bar(p, obj->a, obj->b, 0);
+				print_smapi_bat_bar(obj, p, p_max_size);
 			}
-#endif /* X11 */
 #endif /* IBM */
 			OBJ(include) {
 				if(obj->sub) {
@@ -2414,33 +2332,21 @@ void generate_text_internal(char *p, int p_max_size,
 			}
 			OBJ(apcupsd_loadbar) {
 				double progress;
-#ifdef X11
-				if(output_methods & TO_X) {
-					progress = atof(cur->apcupsd.items[APCUPSD_LOAD]) / 100.0 * 255.0;
-					new_bar(p, obj->a, obj->b, (int) progress);
-				} else {
-#endif /* X11 */
-					progress = atof(cur->apcupsd.items[APCUPSD_LOAD]);
-					if(!obj->a) obj->a = DEFAULT_BAR_WIDTH_NO_X;
-					new_bar_in_shell(p, p_max_size, (int) progress, obj->a);
-#ifdef X11
-				}
-#endif /* X11 */
+				progress = atof(cur->apcupsd.items[APCUPSD_LOAD]) / 100.0 * 255.0;
+				new_bar(obj, p, p_max_size, (int) progress);
 			}
 #ifdef X11
 			OBJ(apcupsd_loadgraph) {
 				double progress;
 				progress =	atof(cur->apcupsd.items[APCUPSD_LOAD]);
-				new_graph(p, obj->a, obj->b, obj->c, obj->d,
-						  (int)progress, 100, 1, obj->char_a, obj->char_b);
+				new_graph(obj, p, p_max_size, (int)progress);
 			}
+#endif /* X11 */
 			OBJ(apcupsd_loadgauge) {
 				double progress;
 				progress =	atof(cur->apcupsd.items[APCUPSD_LOAD]) / 100.0 * 255.0;
-				new_gauge(p, obj->a, obj->b,
-						  (int)progress);
+				new_gauge(obj, p, p_max_size, (int)progress);
 			}
-#endif /* X11 */
 			OBJ(apcupsd_charge) {
 				snprintf(p, p_max_size, "%s",
 						 cur->apcupsd.items[APCUPSD_CHARGE]);
@@ -2470,7 +2376,10 @@ void generate_text_internal(char *p, int p_max_size,
 			iconv_convert(&a, buff_in, p, p_max_size);
 #endif /* HAVE_ICONV */
 			if (obj->type != OBJ_text && obj->type != OBJ_execp && obj->type != OBJ_execpi
-					&& obj->type != OBJ_lua && obj->type != OBJ_lua_parse) {
+#ifdef HAVE_LUA
+					&& obj->type != OBJ_lua && obj->type != OBJ_lua_parse
+#endif /* HAVE_LUA */
+					) {
 				substitute_newlines(p, a - 2);
 			}
 			p += a;
@@ -2487,15 +2396,15 @@ void generate_text_internal(char *p, int p_max_size,
 #endif /* X11 */
 }
 
-void evaluate(const char *text, char *buffer)
+void evaluate(const char *text, char *p, int p_max_size)
 {
 	struct information *tmp_info;
 	struct text_object subroot;
 
 	tmp_info = malloc(sizeof(struct information));
 	memcpy(tmp_info, &info, sizeof(struct information));
-	parse_conky_vars(&subroot, text, buffer, tmp_info);
-	DBGP("evaluated '%s' to '%s'", text, buffer);
+	parse_conky_vars(&subroot, text, p, p_max_size, tmp_info);
+	DBGP2("evaluated '%s' to '%s'", text, p);
 
 	free_text_objects(&subroot, 1);
 	free(tmp_info);
@@ -2507,6 +2416,7 @@ static void generate_text(void)
 {
 	struct information *cur = &info;
 	char *p;
+	unsigned int i, j, k;
 
 	special_count = 0;
 
@@ -2523,6 +2433,22 @@ static void generate_text(void)
 	p = text_buffer;
 
 	generate_text_internal(p, max_user_text, global_root_object, cur);
+	if(max_text_width > 0) {
+		for(i = 0, j = 0; p[i] != 0; i++) {
+			if(p[i] == '\n') j = 0;
+			else if(j == max_text_width) {
+				k = i + strlen(p + i) + 1;
+				if(k < text_buffer_size) {
+					while(k != i) {
+						p[k] = p[k-1];
+						k--;
+					}
+					p[k] = '\n';
+					j = 0;
+				} else NORM_ERR("The end of the text_buffer is reached, increase \"text_buffer_size\"");
+			} else j++;
+		}
+	}
 
 	if (stuff_in_uppercase) {
 		char *tmp_p;
@@ -2550,7 +2476,7 @@ void set_update_interval(double interval)
 	update_interval_old = interval;
 }
 
-static inline int get_string_width(const char *s)
+int get_string_width(const char *s)
 {
 	return *s ? calc_text_width(s) : 0;
 }
@@ -2628,57 +2554,40 @@ static void update_text_area(void)
 
 	/* get text position on workarea */
 	switch (text_alignment) {
-		case TOP_LEFT:
-			x = gap_x;
+		case TOP_LEFT: case TOP_RIGHT: case TOP_MIDDLE:
 			y = gap_y;
 			break;
 
-		case TOP_RIGHT:
-			x = workarea[2] - text_width - gap_x;
-			y = gap_y;
+		case BOTTOM_LEFT: case BOTTOM_RIGHT: case BOTTOM_MIDDLE: default:
+			y = workarea[3] - text_height - gap_y;
 			break;
 
-		case TOP_MIDDLE:
-			x = workarea[2] / 2 - text_width / 2 - gap_x;
-			y = gap_y;
+		case MIDDLE_LEFT: case MIDDLE_RIGHT: case MIDDLE_MIDDLE:
+			y = workarea[3] / 2 - text_height / 2 - gap_y;
 			break;
-
-		default:
-		case BOTTOM_LEFT:
+	}
+	switch (text_alignment) {
+		case TOP_LEFT: case BOTTOM_LEFT: case MIDDLE_LEFT: default:
 			x = gap_x;
-			y = workarea[3] - text_height - gap_y;
 			break;
 
-		case BOTTOM_RIGHT:
+		case TOP_RIGHT: case BOTTOM_RIGHT: case MIDDLE_RIGHT:
 			x = workarea[2] - text_width - gap_x;
-			y = workarea[3] - text_height - gap_y;
 			break;
 
-		case BOTTOM_MIDDLE:
+		case TOP_MIDDLE: case BOTTOM_MIDDLE: case MIDDLE_MIDDLE:
 			x = workarea[2] / 2 - text_width / 2 - gap_x;
-			y = workarea[3] - text_height - gap_y;
-			break;
-
-		case MIDDLE_LEFT:
-			x = gap_x;
-			y = workarea[3] / 2 - text_height / 2 - gap_y;
 			break;
-
-		case MIDDLE_RIGHT:
-			x = workarea[2] - text_width - gap_x;
-			y = workarea[3] / 2 - text_height / 2 - gap_y;
-			break;
-
+	}
 #ifdef OWN_WINDOW
-		case NONE:	// Let the WM manage the window
+	if (text_alignment == NONE) {	// Let the WM manage the window
 			x = window.x;
 			y = window.y;
 
 			fixed_pos = 1;
 			fixed_size = 1;
-			break;
-#endif
 	}
+#endif /* OWN_WINDOW */
 #ifdef OWN_WINDOW
 
 	if (own_window && !fixed_pos) {
@@ -2720,6 +2629,8 @@ static long current_color;
 static int text_size_updater(char *s, int special_index)
 {
 	int w = 0;
+	int lw;
+	int contain_SECRIT_MULTILINE_CHAR = 0;
 	char *p;
 
 	if ((output_methods & TO_X) == 0)
@@ -2768,7 +2679,7 @@ static int text_size_updater(char *s, int special_index)
 			special_index++;
 			s = p + 1;
 		} else if (*p == SECRIT_MULTILINE_CHAR) {
-			int lw;
+			contain_SECRIT_MULTILINE_CHAR = 1;
 			*p = '\0';
 			lw = get_string_width(s);
 			*p = SECRIT_MULTILINE_CHAR;
@@ -2778,7 +2689,13 @@ static int text_size_updater(char *s, int special_index)
 		}
 		p++;
 	}
-	w += get_string_width(s);
+	/* Check also last substring if string contains SECRIT_MULTILINE_CHAR */
+	if (contain_SECRIT_MULTILINE_CHAR) {
+		lw = get_string_width(s);
+		w = lw > w ? lw : w;
+	} else {
+		w += get_string_width(s);
+	}
 	if (w > text_width) {
 		text_width = w;
 	}
@@ -2796,8 +2713,16 @@ static inline void set_foreground_color(long c)
 {
 #ifdef X11
 	if (output_methods & TO_X) {
-		current_color = c;
-		XSetForeground(display, window.gc, c);
+#ifdef USE_ARGB
+		if (have_argb_visual) {
+			current_color = c | (own_window_argb_value << 24);
+		} else {
+#endif /* USE_ARGB */
+			current_color = c;
+#ifdef USE_ARGB
+		}
+#endif /* USE_ARGB */
+		XSetForeground(display, window.gc, current_color);
 	}
 #endif /* X11 */
 #ifdef NCURSES
@@ -2898,7 +2823,8 @@ static void draw_string(const char *s)
 			XftColor c2;
 
 			c.pixel = current_color;
-			XQueryColor(display, DefaultColormap(display, screen), &c);
+			// query color on custom colormap
+			XQueryColor(display, window.colourmap, &c);
 
 			c2.pixel = c.pixel;
 			c2.color.red = c.red;
@@ -3659,7 +3585,7 @@ static void main_loop(void)
 						draw_stuff(); /* redraw everything in our newly sized window */
 						XResizeWindow(display, window.window, window.width,
 								window.height); /* resize window */
-						set_transparent_background(window.window);
+						set_transparent_background(window.window, own_window_argb_value);
 #ifdef HAVE_XDBE
 						/* swap buffers */
 						xdbe_swap_buffers();
@@ -3759,9 +3685,9 @@ static void main_loop(void)
 
 #ifdef OWN_WINDOW
 					case ReparentNotify:
-						/* set background to ParentRelative for all parents */
+						/* make background transparent */
 						if (own_window) {
-							set_transparent_background(window.window);
+							set_transparent_background(window.window, own_window_argb_value);
 						}
 						break;
 
@@ -3968,12 +3894,12 @@ static void main_loop(void)
 				break;
 		}
 #ifdef HAVE_SYS_INOTIFY_H
-		if (inotify_fd != -1 && inotify_config_wd == -1 && current_config != 0) {
+		if (!disable_auto_reload && inotify_fd != -1 && inotify_config_wd == -1 && current_config != 0) {
 			inotify_config_wd = inotify_add_watch(inotify_fd,
 					current_config,
 					IN_MODIFY);
 		}
-		if (inotify_fd != -1 && inotify_config_wd != -1 && current_config != 0) {
+		if (!disable_auto_reload && inotify_fd != -1 && inotify_config_wd != -1 && current_config != 0) {
 			int len = 0, idx = 0;
 			fd_set descriptors;
 			struct timeval time_to_wait;
@@ -4000,6 +3926,7 @@ static void main_loop(void)
 									current_config,
 									IN_MODIFY);
 						}
+						break;
 					}
 #ifdef HAVE_LUA
 					else {
@@ -4009,6 +3936,10 @@ static void main_loop(void)
 					idx += INOTIFY_EVENT_SIZE + ev->len;
 				}
 			}
+		} else if (disable_auto_reload && inotify_fd != -1) {
+			inotify_rm_watch(inotify_fd, inotify_config_wd);
+			close(inotify_fd);
+			inotify_fd = inotify_config_wd = 0;
 		}
 #endif /* HAVE_SYS_INOTIFY_H */
 
@@ -4017,7 +3948,7 @@ static void main_loop(void)
 #endif /* HAVE_LUA */
 		g_signal_pending = 0;
 	}
-	clean_up(NULL, NULL);
+	clean_up(current_mail_spool, NULL);
 
 #ifdef HAVE_SYS_INOTIFY_H
 	if (inotify_fd != -1) {
@@ -4038,6 +3969,7 @@ static void reload_config(void)
 {
 	char *current_config_copy = strdup(current_config);
 	clean_up(NULL, NULL);
+	sleep(1); /* slight pause */
 	current_config = current_config_copy;
 	initialisation(argc_copy, argv_copy);
 }
@@ -4046,6 +3978,8 @@ void clean_up(void *memtofree1, void* memtofree2)
 {
 	int i;
 
+	free_update_callbacks();
+
 #ifdef NCURSES
 	if(output_methods & TO_NCURSES) {
 		endwin();
@@ -4067,10 +4001,12 @@ void clean_up(void *memtofree1, void* memtofree2)
 	}
 #ifdef X11
 	if (x_initialised == YES) {
-		XClearArea(display, window.window, text_start_x - window.border_inner_margin - window.border_outer_margin - window.border_width,
-			text_start_y - window.border_inner_margin - window.border_outer_margin - window.border_width,
-			text_width + window.border_inner_margin * 2 + window.border_outer_margin * 2 + window.border_width * 2,
-			text_height + window.border_inner_margin * 2 + window.border_outer_margin * 2 + window.border_width * 2, 0);
+		if(window_created == 1) {
+			XClearArea(display, window.window, text_start_x - window.border_inner_margin - window.border_outer_margin - window.border_width,
+				text_start_y - window.border_inner_margin - window.border_outer_margin - window.border_width,
+				text_width + window.border_inner_margin * 2 + window.border_outer_margin * 2 + window.border_width * 2,
+				text_height + window.border_inner_margin * 2 + window.border_outer_margin * 2 + window.border_width * 2, 0);
+		}
 		destroy_window();
 		free_fonts();
 		if(x11_stuff.region) {
@@ -4095,8 +4031,6 @@ void clean_up(void *memtofree1, void* memtofree2)
 
 #endif /* X11 */
 
-	free_update_callbacks();
-
 	free_templates();
 
 	free_text_objects(&global_root_object, 0);
@@ -4197,6 +4131,8 @@ static enum alignment string_to_alignment(const char *s)
 		return MIDDLE_LEFT;
 	} else if (strcasecmp(s, "middle_right") == EQUAL) {
 		return MIDDLE_RIGHT;
+	} else if (strcasecmp(s, "middle_middle") == EQUAL) {
+		return MIDDLE_MIDDLE;
 	} else if (strcasecmp(s, "tl") == EQUAL) {
 		return TOP_LEFT;
 	} else if (strcasecmp(s, "tr") == EQUAL) {
@@ -4213,10 +4149,12 @@ static enum alignment string_to_alignment(const char *s)
 		return MIDDLE_LEFT;
 	} else if (strcasecmp(s, "mr") == EQUAL) {
 		return MIDDLE_RIGHT;
+	} else if (strcasecmp(s, "mm") == EQUAL) {
+		return MIDDLE_MIDDLE;
 	} else if (strcasecmp(s, "none") == EQUAL) {
 		return NONE;
 	}
-	return TOP_LEFT;
+	return ALIGNMENT_ERROR;
 }
 #endif /* X11 */
 
@@ -4332,6 +4270,10 @@ static void set_default_configurations(void)
 	window.hints = 0;
 	strcpy(window.class_name, PACKAGE_NAME);
 	sprintf(window.title, PACKAGE_NAME" (%s)", info.uname_s.nodename);
+#ifdef USE_ARGB
+	use_argb_visual = 0;
+	own_window_argb_value = 255;
+#endif
 #endif
 	stippled_borders = 0;
 	window.border_inner_margin = 3;
@@ -4366,6 +4308,8 @@ static void set_default_configurations(void)
 	stuff_in_uppercase = 0;
 	info.users.number = 1;
 
+	set_times_in_seconds(0);
+
 #ifdef TCP_PORT_MONITOR
 	/* set default connection limit */
 	tcp_portmon_set_max_connections(0);
@@ -4421,7 +4365,7 @@ int x11_ioerror_handler(Display *d)
 	NORM_ERR("X Error: Display %lx\n",
 			(long unsigned)d
 			);
-	abort();
+	exit(1);
 }
 #endif /* DEBUG */
 
@@ -4465,7 +4409,7 @@ static void X11_create_window(void)
 			XMoveWindow(display, window.window, window.x, window.y);
 		}
 		if (own_window) {
-			set_transparent_background(window.window);
+			set_transparent_background(window.window, own_window_argb_value);
 		}
 #endif
 
@@ -4563,6 +4507,29 @@ static int do_config_step(int *line, FILE *fp, char *buf, char **name, char **va
 	return 0;
 }
 
+#ifdef X11
+void setalignment(int* text_alignment, unsigned int windowtype, const char* value, const char *f, int line, char setbyconffile) {
+#ifdef OWN_WINDOW
+	if (windowtype == TYPE_DOCK) {
+		NORM_ERR("alignment is disabled when own_window_type is dock");
+	} else
+#endif /*OWN_WINDOW */
+	if (value) {
+		int a = string_to_alignment(value);
+
+		if (a <= 0) {
+			if(setbyconffile == true) {
+				CONF_ERR;
+			} else NORM_ERR("'%s' is not a alignment setting", value);
+		} else {
+			*text_alignment = a;
+		}
+	} else if(setbyconffile == true) {
+		CONF_ERR;
+	}
+}
+#endif /* X11 */
+
 char load_config_file(const char *f)
 {
 	int line = 0;
@@ -4606,22 +4573,7 @@ char load_config_file(const char *f)
 			}
 		}
 		CONF("alignment") {
-#ifdef OWN_WINDOW
-			if (window.type == TYPE_DOCK)
-				;
-			else
-#endif /*OWN_WINDOW */
-			if (value) {
-				int a = string_to_alignment(value);
-
-				if (a <= 0) {
-					CONF_ERR;
-				} else {
-					text_alignment = a;
-				}
-			} else {
-				CONF_ERR;
-			}
+			setalignment(&text_alignment, window.type, value, f, line, true);
 		}
 		CONF("background") {
 			fork_to_background = string_to_bool(value);
@@ -4680,14 +4632,14 @@ char load_config_file(const char *f)
 		TEMPLATE_CONF(9)
 		CONF("imap") {
 			if (value) {
-				info.mail = parse_mail_args(IMAP_TYPE, value);
+				parse_global_imap_mail_args(value);
 			} else {
 				CONF_ERR;
 			}
 		}
 		CONF("pop3") {
 			if (value) {
-				info.mail = parse_mail_args(POP3_TYPE, value);
+				parse_global_pop3_mail_args(value);
 			} else {
 				CONF_ERR;
 			}
@@ -4829,6 +4781,12 @@ char load_config_file(const char *f)
 			draw_outline = string_to_bool(value);
 		}
 #endif /* X11 */
+		CONF("times_in_seconds") {
+			set_times_in_seconds(string_to_bool(value));
+		}
+		CONF("max_text_width") {
+			max_text_width = atoi(value);
+		}
 		CONF("out_to_console") {
 			if(string_to_bool(value)) {
 				output_methods |= TO_STDOUT;
@@ -4839,6 +4797,9 @@ char load_config_file(const char *f)
 		CONF("extra_newline") {
 			extra_newline = string_to_bool(value);
 		}
+		CONF("disable_auto_reload") {
+			disable_auto_reload = string_to_bool(value);
+		}
 		CONF("out_to_stderr") {
 			if(string_to_bool(value))
 				output_methods |= TO_STDERR;
@@ -4996,16 +4957,8 @@ char load_config_file(const char *f)
 			no_buffers = string_to_bool(value);
 		}
 		CONF("top_name_width") {
-			if (value) {
-				if (sscanf(value, "%u", &top_name_width) != 1) {
-					CONF_ERR;
-				}
-			} else {
+			if (set_top_name_width(value))
 				CONF_ERR;
-			}
-			if (top_name_width >= max_user_text) {
-				top_name_width = max_user_text - 1;
-			}
 		}
 		CONF("top_cpu_separate") {
 			cpu_separate = string_to_bool(value);
@@ -5104,6 +5057,17 @@ char load_config_file(const char *f)
 				CONF_ERR;
 			}
 		}
+#ifdef USE_ARGB
+		CONF("own_window_argb_visual") {
+			use_argb_visual = string_to_bool(value);
+		}
+		CONF("own_window_argb_value") {
+			own_window_argb_value = strtol(value, 0, 0);
+			if (own_window_argb_value > 255 || own_window_argb_value < 0) {
+				CONF_ERR2("own_window_argb_value must be <= 255 and >= 0");
+			}
+		}
+#endif /* USE_ARGB */
 #endif
 		CONF("stippled_borders") {
 			if (value) {
@@ -5598,6 +5562,7 @@ static const char *getopt_string = "vVqdDt:u:i:hc:p:"
 static const struct option longopts[] = {
 	{ "help", 0, NULL, 'h' },
 	{ "version", 0, NULL, 'V' },
+	{ "quiet", 0, NULL, 'q' },
 	{ "debug", 0, NULL, 'D' },
 	{ "config", 1, NULL, 'c' },
 #ifdef CONFIG_OUTPUT
@@ -5617,15 +5582,62 @@ static const struct option longopts[] = {
 	{ "window-id", 1, NULL, 'w' },
 #endif /* X11 */
 	{ "text", 1, NULL, 't' },
-	{ "interval", 0, NULL, 'u' },
-	{ "pause", 0, NULL, 'p' },
+	{ "interval", 1, NULL, 'u' },
+	{ "pause", 1, NULL, 'p' },
 	{ 0, 0, 0, 0 }
 };
 
+void set_current_config() {
+	/* check if specified config file is valid */
+	if (current_config) {
+		struct stat sb;
+		if (stat(current_config, &sb) ||
+				(!S_ISREG(sb.st_mode) && !S_ISLNK(sb.st_mode))) {
+			NORM_ERR("invalid configuration file '%s'\n", current_config);
+			free(current_config);
+			current_config = 0;
+		}
+	}
+
+	/* load current_config, CONFIG_FILE or SYSTEM_CONFIG_FILE */
+
+	if (!current_config) {
+		/* load default config file */
+		char buf[DEFAULT_TEXT_BUFFER_SIZE];
+		FILE *fp;
+
+		/* Try to use personal config file first */
+		to_real_path(buf, CONFIG_FILE);
+		if (buf[0] && (fp = fopen(buf, "r"))) {
+			current_config = strndup(buf, max_user_text);
+			fclose(fp);
+		}
+
+		/* Try to use system config file if personal config not readable */
+		if (!current_config && (fp = fopen(SYSTEM_CONFIG_FILE, "r"))) {
+			current_config = strndup(SYSTEM_CONFIG_FILE, max_user_text);
+			fclose(fp);
+		}
+
+		/* No readable config found */
+		if (!current_config) {
+#define NOCFGFILEFOUND "no readable personal or system-wide config file found"
+#ifdef BUILD_BUILTIN_CONFIG
+			current_config = strdup("==builtin==");
+			NORM_ERR(NOCFGFILEFOUND
+					", using builtin default");
+#else
+			CRIT_ERR(NULL, NULL, NOCFGFILEFOUND);
+#endif /* ! CONF_OUTPUT */
+		}
+	}
+}
+
 void initialisation(int argc, char **argv) {
 	struct sigaction act, oact;
 
 	set_default_configurations();
+	set_current_config();
 	load_config_file(current_config);
 	currentconffile = conftree_add(currentconffile, current_config);
 
@@ -5682,7 +5694,7 @@ void initialisation(int argc, char **argv) {
 				set_first_font(optarg);
 				break;
 			case 'a':
-				text_alignment = string_to_alignment(optarg);
+				setalignment(&text_alignment, window.type, optarg, NULL, 0, false);
 				break;
 
 #ifdef OWN_WINDOW
@@ -5727,8 +5739,10 @@ void initialisation(int argc, char **argv) {
 				break;
 #endif /* X11 */
 			case 'p':
-				startup_pause = atoi(optarg);
-				sleep(startup_pause);
+				if (first_pass) {
+					startup_pause = atoi(optarg);
+					sleep(startup_pause);
+				}
 				break;
 
 			case '?':
@@ -5751,7 +5765,7 @@ void initialisation(int argc, char **argv) {
 	}
 	global_text = NULL;
 	/* fork */
-	if (fork_to_background) {
+	if (fork_to_background && first_pass) {
 		int pid = fork();
 
 		switch (pid) {
@@ -5905,48 +5919,7 @@ int main(int argc, char **argv)
 		}
 	}
 
-	/* check if specified config file is valid */
-	if (current_config) {
-		struct stat sb;
-		if (stat(current_config, &sb) ||
-				(!S_ISREG(sb.st_mode) && !S_ISLNK(sb.st_mode))) {
-			NORM_ERR("invalid configuration file '%s'\n", current_config);
-			free(current_config);
-			current_config = 0;
-		}
-	}
-
-	/* load current_config, CONFIG_FILE or SYSTEM_CONFIG_FILE */
-
-	if (!current_config) {
-		/* load default config file */
-		char buf[DEFAULT_TEXT_BUFFER_SIZE];
-		FILE *fp;
-
-		/* Try to use personal config file first */
-		to_real_path(buf, CONFIG_FILE);
-		if (buf[0] && (fp = fopen(buf, "r"))) {
-			current_config = strndup(buf, max_user_text);
-			fclose(fp);
-		}
-
-		/* Try to use system config file if personal config not readable */
-		if (!current_config && (fp = fopen(SYSTEM_CONFIG_FILE, "r"))) {
-			current_config = strndup(SYSTEM_CONFIG_FILE, max_user_text);
-			fclose(fp);
-		}
-
-		/* No readable config found */
-		if (!current_config) {
-#ifdef CONFIG_OUTPUT
-			current_config = strdup("==builtin==");
-			NORM_ERR("no readable personal or system-wide config file found,"
-					" using builtin default");
-#else
-			CRIT_ERR(NULL, NULL, "no readable personal or system-wide config file found");
-#endif /* ! CONF_OUTPUT */
-		}
-	}
+	set_current_config();
 
 #ifdef XOAP
 	/* Load xoap keys, if existing */
@@ -5959,6 +5932,8 @@ int main(int argc, char **argv)
 
 	initialisation(argc, argv);
 
+	first_pass = 0; /* don't ever call fork() again */
+
 	main_loop();
 
 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)