Moved makefile to the top directory. Version bump.

For now 'wmgeneral' was used for accessing common dockapps functions.
Those functions was extracted to the library called libdockapp[1]. This
patch removes wmgeneral directory and make use of libdockapp library.

[1] http://www.dockapps.net/libdockapp

Makefile

@@ -1,15 +1,14 @@
 # By RedSeb 1999, Liverbugg 2002
 
+SRC = src/wmtemp.c
 
-SRC = wmtempnv.c ../wmgeneral/wmgeneral.c ../wmgeneral/misc.c ../wmgeneral/list.c
-
-EXE = wmtempnv
+EXE = src/wmtemp
 
 OBJ = $(SRC:.c=.o)
 
 CFLAGS = -Wall -O3
 
-LIB = -I/usr/include/NVCtrl/ -L/usr/X11R6/lib -lXpm -lXext -lX11 -lsensors -lXNVCtrl
+LIB = -L/usr/X11R6/lib -lXpm -lXext -lX11 -ldockapp
 
 INSTALL = /usr/bin/install
 
@@ -23,12 +22,11 @@ $(OBJ): %.o : %.c
 	$(CC) $(CFLAGS) -c -o $@ $<
 
 clean:
-	rm -rf $(EXE)
-	rm -rf *.o
-	rm -rf ../wmgeneral/*.o
+	rm -rf $(EXE) src/*.o
 
 install:
 	$(INSTALL) $(EXE) /usr/local/bin/
+
 uninstall:
 	rm -rf /usr/local/bin/$(EXE)
 

README

@@ -1,4 +0,0 @@
-This is dead simple Window Wmaker app for monitoring CPU and GPU temperature.
-Hardcoded Core2 and Nvidia GPU support. Based on WMTempMon dockapp.
-
-Depends on lmsensors and optionally on nvidia-settings packages.

README.rst

@@ -0,0 +1,71 @@
+wmtemp
+======
+
+This is dead simple Window Maker app for monitoring CPU and GPU temperature.
+Based on WMTempMon dockapp, although it was heavily reworked.
+
+.. image:: /images/wmtemp.gif?raw=true
+      :alt: wmtemp transitions
+
+Compile
+-------
+
+To build the dockapp, you'll need `libdockapp`_ it should be available in your
+package repository. While you have it installed, perform the commands:
+
+.. code:: shell-session
+
+   $ make
+   $ sudo make install
+
+Binary will be installed in ``/usr/local/bin`` directory.
+
+Configuration
+-------------
+
+To use the dockapp, you'll need to prepare configuration file, otherwise you'll
+see 0 values for every core/gpu.
+
+Wmtemp will look for configuration file in home directory. Here is sample
+content of such file:
+
+.. code:: shell-session
+
+   $ cat ~/.wmtemp
+   # wmtemp conf file
+
+   cpu1_path = /sys/devices/platform/coretemp.0/hwmon/hwmon2/temp2_input
+   cpu1_critical = 80
+   cpu1_warning = 65
+   cpu2_path = /sys/devices/platform/coretemp.0/hwmon/hwmon2/temp3_input
+   cpu2_critical = 80
+   cpu2_warning = 65
+   cpu3_path = /sys/devices/platform/coretemp.0/hwmon/hwmon2/temp4_input
+   cpu3_critical = 80
+   cpu3_warning = 65
+   cpu4_path = /sys/devices/platform/coretemp.0/hwmon/hwmon2/temp5_input
+   cpu4_critical = 80
+   cpu4_warning = 65
+   gpu_path = /sys/devices/virtual/hwmon/hwmon1/temp4_input
+   gpu_critical = 70
+   gpu_warning = 60
+
+
+Every core have three options to change:
+
+* ``[core]_path`` - path to temperature file to read from. The content of such
+  file contains a number of temperature in mili-Celsius.
+* ``[core]_critical`` - temperature in °C, on which (and beyond) red color would
+  be used for highlight the entry.
+* ``[core]_warning`` - temperature in °C, on which (and beyond) orange color
+  would be used for highlight the entry.
+
+In main directory there is a ``wmtemp_sample`` file, which can be copied to
+``~/.wmtemp`` and tweaked according to the needs and hardware.
+
+Licence
+-------
+
+This software is licensed under GPL2 license. See COPYING file for details.
+
+.. _libdockapp: http://www.dockapps.net/libdockapp

src/wmtemp.c

@@ -0,0 +1,363 @@
+/*
+ * wmtemp: a temperature monitor for WindowMaker. This little app is mainly
+ * based on wmsensormon and other simple dockapps, although it doesn't use 
+ * lmsensors, just provided information from kernel via /sys filesystem.
+ *
+ * version = 0.7
+ *
+ * licence: GPL2
+ */
+
+#include <ctype.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <string.h>
+
+#include <sys/param.h>
+#include <sys/types.h>
+
+#include "standards.h"
+#include <X11/Xlib.h>
+#include <X11/xpm.h>
+#include <X11/extensions/shape.h>
+
+#include <libdockapp/wmgeneral.h>
+#include <libdockapp/misc.h>
+
+#include "wmtemp_master.xpm"
+#include "wmtemp_mask.xbm"
+
+#define MAXLEN 200
+#define MAXFNAME 70
+#define MAXCORENUM 4
+
+struct entry {
+    char *path;
+    long critical;
+    long warning;
+};
+
+struct config {
+    struct entry cpu1;
+    struct entry cpu2;
+    struct entry cpu3;
+    struct entry cpu4;
+    struct entry gpu;
+};
+
+char cpu1_path[100];
+int cpu1_warn = 0;
+int cpu1_crit = 0;
+char cpu2_path[100];
+int cpu2_warn = 0;
+int cpu2_crit = 0;
+char cpu3_path[100];
+int cpu3_warn = 0;
+int cpu3_crit = 0;
+char cpu4_path[100];
+int cpu4_warn = 0;
+int cpu4_crit = 0;
+char gpu1_path[100];
+int gpu1_warn = 0;
+int gpu1_crit = 0;
+
+typedef struct _core {
+    int temp;
+    /* offset is one of 0 (normal), 7 (critical), 14 (warning) */
+    short offset;
+} core;
+
+Display *display;
+
+char *vcopy(char *str);
+int get_gpu_temp(char *path, Display *disp);
+int get_temp(struct entry *etr);
+short get_offset(short temp, struct entry *etr);
+void conf_read(char *filename);
+void display_help(char *progname);
+void display_values(int, short, short);
+void draw_cpu_temp(short core_no, core *cpu);
+void draw_gpu_temp(core *gpu);
+void read_file_into(char *filepath, int *output);
+void set_defaults(struct config *conf);
+char *strip(char * string);
+void parse_config(struct config *conf);
+
+int main(int argc, char **argv){
+    int i;
+    short counter = 0;
+    struct config conf;
+
+    set_defaults(&conf);
+
+    parse_config(&conf);
+
+    display = XOpenDisplay(NULL);
+    core gpu, *cpus = malloc(MAXCORENUM * sizeof (core));
+
+    if (argc > 1) {
+        if (argc > 2) {
+            display_help(argv[0]);
+            exit(2);
+        }
+
+        if (argc == 2 &&
+                (strcmp(argv[1], "--help") == 0 ||
+                 strcmp(argv[1], "-h") == 0)) {
+            display_help(argv[0]);
+            exit(0);
+        }
+    }
+
+    openXwindow(argc, argv, wmtemp_master, wmtemp_mask_bits,
+            wmtemp_mask_width, wmtemp_mask_height);
+
+    while(TRUE){
+        if (counter < 1){
+            counter = 5;
+            cpus[0].temp = get_temp(&conf.cpu1);
+            cpus[0].offset = get_offset(cpus[0].temp, &conf.cpu1);
+            cpus[1].temp = get_temp(&conf.cpu2);
+            cpus[1].offset = get_offset(cpus[1].temp, &conf.cpu2);
+            cpus[2].temp = get_temp(&conf.cpu3);
+            cpus[2].offset = get_offset(cpus[2].temp, &conf.cpu3);
+            cpus[3].temp = get_temp(&conf.cpu4);
+            cpus[3].offset = get_offset(cpus[3].temp, &conf.cpu4);
+            gpu.temp = get_temp(&conf.gpu);
+            gpu.offset = get_offset(gpu.temp, &conf.gpu);
+        }
+
+        // cpu's
+        for (i=0; i < 4; i++){
+            draw_cpu_temp(i, &cpus[i]);
+        }
+
+        // gpu
+        draw_gpu_temp(&gpu);
+
+        RedrawWindow();
+        counter--;
+        usleep(100000);
+    }
+    free(conf.cpu1.path);
+    free(conf.cpu2.path);
+    free(conf.cpu3.path);
+    free(conf.cpu4.path);
+    free(conf.gpu.path);
+}
+
+void set_defaults(struct config *conf) {
+    struct config configuration;
+    configuration = *conf;
+    configuration.cpu1.critical = 80;
+    configuration.cpu1.warning = 65;
+    configuration.cpu2.critical = 80;
+    configuration.cpu2.warning = 65;
+    configuration.cpu3.critical = 80;
+    configuration.cpu3.warning = 65;
+    configuration.cpu4.critical = 80;
+    configuration.cpu4.warning = 65;
+    configuration.gpu.critical = 80;
+    configuration.gpu.warning = 65;
+
+    configuration.cpu1.path = malloc(sizeof(char));
+    strcpy(configuration.cpu1.path, "");
+    configuration.cpu2.path = malloc(sizeof(char));
+    strcpy(configuration.cpu2.path, "");
+    configuration.cpu3.path = malloc(sizeof(char));
+    strcpy(configuration.cpu3.path, "");
+    configuration.cpu4.path = malloc(sizeof(char));
+    strcpy(configuration.cpu4.path, "");
+    configuration.gpu.path = malloc(sizeof(char));
+    strcpy(configuration.gpu.path, "");
+    *conf = configuration;
+}
+
+char *strip(char * string) {
+    char *string1 = string,
+         *string2 = &string[strlen (string) - 1];
+
+    /* Strip right side */
+    while ((isspace(*string2)) && (string2 >= string1))
+        string2--;
+
+    *(string2+1) = '\0';
+
+    /* Strip left side */
+    while ((isspace(*string1)) && (string1 < string2))
+        string1++;
+
+    strcpy (string, string1);
+    return string;
+}
+
+void parse_config(struct config *conf) {
+    char *item, 
+         *conf_file,
+         buff[256],
+         name[MAXLEN],
+         value[MAXLEN];
+    struct config cfg;
+    FILE *fp;
+
+    conf_file = malloc(strlen(getenv("HOME")) + strlen("/.wmtemp") + 1);
+    sprintf(conf_file, "%s/.wmtemp", getenv("HOME"));
+
+    cfg = *conf;
+    fp = fopen (conf_file, "r");
+    if (fp == NULL) {
+        return;
+    }
+
+    while ((item = fgets (buff, sizeof buff, fp)) != NULL) {
+        if (buff[0] == '\n' || buff[0] == '#') 
+            continue;
+
+        /* Parse name/value pair from item */
+        item = strtok(buff, "=");
+        strip(item);
+        if (item == NULL)
+            continue;
+        else
+            strncpy (name, item, MAXLEN);
+
+        item = strtok (NULL, "=");
+        if (item == NULL)
+            continue;
+        else
+            strncpy (value, item, MAXLEN);
+        strip(value);
+
+        if (strncmp(name, "cpu1_path", 9) == 0){
+            free(cfg.cpu1.path);
+            cfg.cpu1.path = malloc(sizeof(value) + 1);
+            strcpy(cfg.cpu1.path, value);
+        }
+
+        if (strncmp(name, "cpu2_path", 9) == 0){
+            free(cfg.cpu2.path);
+            cfg.cpu2.path = malloc(sizeof(value) + 1);
+            strcpy(cfg.cpu2.path, value);
+        }
+
+        if (strncmp(name, "cpu3_path", 9) == 0){
+            free(cfg.cpu3.path);
+            cfg.cpu3.path = malloc(sizeof(value) + 1);
+            strcpy(cfg.cpu3.path, value);
+        }
+
+        if (strncmp(name, "cpu4_path", 9) == 0){
+            free(cfg.cpu4.path);
+            cfg.cpu4.path = malloc(sizeof(value) + 1);
+            strcpy(cfg.cpu4.path, value);
+        }
+
+        if (strncmp(name, "gpu_path", 8) == 0){
+            free(cfg.gpu.path);
+            cfg.gpu.path = malloc(sizeof(value) + 1);
+            strcpy(cfg.gpu.path, value);
+        }
+
+        if (!strcmp(name, "cpu1_critical"))
+            cfg.cpu1.critical = atoi(value);
+        if (!strcmp(name, "cpu2_critical"))
+            cfg.cpu2.critical = atoi(value);
+        if (!strcmp(name, "cpu3_critical"))
+            cfg.cpu3.critical = atoi(value);
+        if (!strcmp(name, "cpu4_critical"))
+            cfg.cpu4.critical = atoi(value);
+        if (!strcmp(name, "gpu_critical"))
+            cfg.gpu.critical = atoi(value);
+       
+        if (!strcmp(name, "cpu1_warning"))
+            cfg.cpu1.warning = atoi(value);
+        if (!strcmp(name, "cpu2_warning"))
+            cfg.cpu2.warning = atoi(value);
+        if (!strcmp(name, "cpu3_warning"))
+            cfg.cpu3.warning = atoi(value);
+        if (!strcmp(name, "cpu4_warning"))
+            cfg.cpu4.warning = atoi(value);
+        if (!strcmp(name, "gpu_warning"))
+            cfg.gpu.warning = atoi(value);
+    }
+
+    *conf = cfg;
+    fclose (fp);
+    free(conf_file);
+}
+
+short get_offset(short temp, struct entry *etr){
+    if(temp >= etr->critical){
+        return 7;  // Alert
+    }else if(temp >= etr->warning){
+        return 14; // Warning
+    }else{
+        return 0;  // Normal
+    }
+}
+
+void display_values(int temp, short offset, short core2_offset){
+    char text[5], num1, num2, num3, num4;
+
+    sprintf(text, "%03d", temp);
+    num1 = (text[0] - '0');
+    num2 = (text[1] - '0');
+    num3 = (text[2] - '0');
+    num4 = (text[3] - '0');
+    if(num1)
+        copyXPMArea(5 * num1, 65 + core2_offset, 5, 7, 31, 7 + offset);
+    else
+        copyXPMArea(60, 65 + core2_offset, 5, 7, 31, 7 + offset);
+    copyXPMArea(5 * num2, 65 + core2_offset, 5, 7, 38, 7 + offset);
+    copyXPMArea(5 * num3, 65 + core2_offset, 5, 7, 45, 7 + offset);
+    copyXPMArea(5 * num4, 65 + core2_offset, 5, 7, 51, 7 + offset);
+}
+
+int get_temp(struct entry *etr){
+    int core_temp = 0;
+    read_file_into(etr->path, &core_temp);
+    return core_temp;
+}
+
+void read_file_into(char *filepath, int *output) {
+    // Read an integer from the provided filepath and write it in the address
+    FILE *fp;
+    if((fp = fopen(filepath, "r")) != NULL){
+        if(fscanf(fp, "%d", output) != EOF){
+            *output = *output / 1000;
+            fclose(fp);
+        }
+    }else{
+        *output = 0;
+    }
+}
+
+void draw_cpu_temp(short core_no, core *cpu) {
+    // Copy prepared bitmap for the core. Cores are enumerated from 0. offset
+    // is warning/critical (orange/red) shift in the bitmap
+
+    short y_offset = core_no * 9;
+
+    copyXPMArea(0, 87 + cpu->offset, 23, 7, 4, 7 + y_offset); // "CPU"
+    // number of cpu
+    copyXPMArea(5 + core_no * 5, 65 + cpu->offset, 5, 7, 22, 7 + y_offset);
+    copyXPMArea(66, 65 + cpu->offset, 9, 7, 51, 7 + y_offset); // "°C"
+    display_values(cpu->temp, y_offset, cpu->offset); // temp
+}
+
+void draw_gpu_temp(core *gpu) {
+    copyXPMArea(23, 87 + gpu->offset, 23, 7, 4, 49);
+    copyXPMArea(66, 65 + gpu->offset , 9, 7, 51, 49);
+    display_values(gpu->temp, 42, gpu->offset);
+}
+
+void display_help(char *progname){
+    printf("Dockapp for monitoring CPU and Nvidia GPU temperatures.\n");
+    printf("Usage:\n\t%s [full path for temp in sysfs]\n\n", progname);
+    printf("As an optional parameter you can provide `temp_input' ");
+    printf("full path from sysfs,\ncorresponding to your gfx card ");
+    printf("to read temperature from. Otherwise\nfunctionality of ");
+    printf("nv-control will be used (package nvidia-settings).\n");
+}

src/wmtemp_mask.xbm

@@ -1,6 +1,6 @@
-#define wmtempnv_mask_width 64
-#define wmtempnv_mask_height 64
-static char wmtempnv_mask_bits[] = {
+#define wmtemp_mask_width 64
+#define wmtemp_mask_height 64
+static char wmtemp_mask_bits[] = {
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 
   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 

src/wmtemp_master.xpm

@@ -1,5 +1,5 @@
 /* XPM */
-static char *wmtempnv_master[] = {
+static char *wmtemp_master[] = {
 /* columns rows colors chars-per-pixel */
 "93 122 256 2 ",
 "   c black",

wmgeneral/list.c

@@ -1,169 +0,0 @@
-/* Generic single linked list to keep various information 
-   Copyright (C) 1993, 1994 Free Software Foundation, Inc.
-
-
-Author: Kresten Krab Thorup
-
-Many modifications by Alfredo K. Kojima
- 
-
-This file is part of GNU CC.
-
-GNU CC is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
-any later version.
-
-GNU CC is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GNU CC; see the file COPYING.  If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA.  */
-
-/* As a special exception, if you link this library with files compiled with
-   GCC to produce an executable, this does not cause the resulting executable
-   to be covered by the GNU General Public License. This exception does not
-   however invalidate any other reasons why the executable file might be
-   covered by the GNU General Public License.  */
-
-#include "list.h"
-#ifdef HAVE_SYS_TYPES_H
-# include <sys/types.h>
-#endif
-#include <stdlib.h>
-
-/* Return a cons cell produced from (head . tail) */
-
-INLINE LinkedList* 
-list_cons(void* head, LinkedList* tail)
-{
-  LinkedList* cell;
-
-  cell = (LinkedList*)malloc(sizeof(LinkedList));
-  cell->head = head;
-  cell->tail = tail;
-  return cell;
-}
-
-/* Return the length of a list, list_length(NULL) returns zero */
-
-INLINE int
-list_length(LinkedList* list)
-{
-  int i = 0;
-  while(list)
-    {
-      i += 1;
-      list = list->tail;
-    }
-  return i;
-}
-
-/* Return the Nth element of LIST, where N count from zero.  If N 
-   larger than the list length, NULL is returned  */
-
-INLINE void*
-list_nth(int index, LinkedList* list)
-{
-  while(index-- != 0)
-    {
-      if(list->tail)
-	list = list->tail;
-      else
-	return 0;
-    }
-  return list->head;
-}
-
-/* Remove the element at the head by replacing it by its successor */
-
-INLINE void
-list_remove_head(LinkedList** list)
-{
-  if (!*list) return;  
-  if ((*list)->tail)
-    {
-      LinkedList* tail = (*list)->tail; /* fetch next */
-      *(*list) = *tail;		/* copy next to list head */
-      free(tail);			/* free next */
-    }
-  else				/* only one element in list */
-    {
-      free(*list);
-      (*list) = 0;
-    }
-}
-
-
-/* Remove the element with `car' set to ELEMENT */
-/*
-INLINE void
-list_remove_elem(LinkedList** list, void* elem)
-{
-  while (*list)
-    {
-      if ((*list)->head == elem)
-        list_remove_head(list);
-      *list = (*list ? (*list)->tail : NULL);
-    }
-}*/
-
-INLINE LinkedList *
-list_remove_elem(LinkedList* list, void* elem)
-{
-    LinkedList *tmp;
-    
-    if (list) {
-	if (list->head == elem) {
-	    tmp = list->tail;
-	    free(list);
-	    return tmp;
-	}
-	list->tail = list_remove_elem(list->tail, elem);
-	return list;
-    }
-    return NULL;
-}
-
-
-/* Return element that has ELEM as car */
-
-INLINE LinkedList*
-list_find(LinkedList* list, void* elem)
-{
-  while(list)
-    {
-    if (list->head == elem)
-      return list;
-    list = list->tail;
-    }
-  return NULL;
-}
-
-/* Free list (backwards recursive) */
-
-INLINE void
-list_free(LinkedList* list)
-{
-  if(list)
-    {
-      list_free(list->tail);
-      free(list);
-    }
-}
-
-/* Map FUNCTION over all elements in LIST */
-
-INLINE void
-list_mapcar(LinkedList* list, void(*function)(void*))
-{
-  while(list)
-    {
-      (*function)(list->head);
-      list = list->tail;
-    }
-}

wmgeneral/list.h

@@ -1,59 +0,0 @@
-/* Generic single linked list to keep various information 
-   Copyright (C) 1993, 1994 Free Software Foundation, Inc.
-
-Author: Kresten Krab Thorup
-
-This file is part of GNU CC.
-
-GNU CC is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2, or (at your option)
-any later version.
-
-GNU CC is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with GNU CC; see the file COPYING.  If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA.  */
-
-/* As a special exception, if you link this library with files compiled with
-   GCC to produce an executable, this does not cause the resulting executable
-   to be covered by the GNU General Public License. This exception does not
-   however invalidate any other reasons why the executable file might be
-   covered by the GNU General Public License.  */
-
-#ifndef __LIST_H_
-#define __LIST_H_
-
-#if defined(__GNUC__) && !defined(__STRICT_ANSI__)
-# define INLINE inline
-#else
-# define INLINE
-#endif
-
-typedef struct LinkedList {
-  void *head;
-  struct LinkedList *tail;
-} LinkedList;
-
-INLINE LinkedList* list_cons(void* head, LinkedList* tail);
-
-INLINE int list_length(LinkedList* list);
-
-INLINE void* list_nth(int index, LinkedList* list);
-
-INLINE void list_remove_head(LinkedList** list);
-
-INLINE LinkedList *list_remove_elem(LinkedList* list, void* elem);
-
-INLINE void list_mapcar(LinkedList* list, void(*function)(void*));
-
-INLINE LinkedList*list_find(LinkedList* list, void* elem);
-
-INLINE void list_free(LinkedList* list);
-
-#endif

wmgeneral/misc.c

@@ -1,164 +0,0 @@
-/* dock.c- built-in Dock module for WindowMaker
- * 
- *  WindowMaker window manager
- * 
- *  Copyright (c) 1997 Alfredo K. Kojima
- * 
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#include <stdlib.h>
-#include <string.h>
-#include "list.h"
-#include "misc.h"
-
-/*
- *----------------------------------------------------------------------
- * parse_command--
- * 	Divides a command line into a argv/argc pair.
- *---------------------------------------------------------------------- 
- */
-#define PRC_ALPHA	0
-#define PRC_BLANK	1
-#define PRC_ESCAPE	2
-#define PRC_DQUOTE	3
-#define PRC_EOS		4
-#define PRC_SQUOTE	5
-
-typedef struct {
-    short nstate;
-    short output;
-} DFA;
-
-
-static DFA mtable[9][6] = {
-    {{3,1},{0,0},{4,0},{1,0},{8,0},{6,0}},
-    {{1,1},{1,1},{2,0},{3,0},{5,0},{1,1}},
-    {{1,1},{1,1},{1,1},{1,1},{5,0},{1,1}},
-    {{3,1},{5,0},{4,0},{1,0},{5,0},{6,0}},
-    {{3,1},{3,1},{3,1},{3,1},{5,0},{3,1}},
-    {{-1,-1},{0,0},{0,0},{0,0},{0,0},{0,0}}, /* final state */
-    {{6,1},{6,1},{7,0},{6,1},{5,0},{3,0}},
-    {{6,1},{6,1},{6,1},{6,1},{5,0},{6,1}},
-    {{-1,-1},{0,0},{0,0},{0,0},{0,0},{0,0}}, /* final state */
-};
-
-char*
-next_token(char *word, char **next)
-{
-    char *ptr;
-    char *ret, *t;
-    int state, ctype;
-
-    t = ret = malloc(strlen(word)+1);
-    ptr = word;
-    
-    state = 0;
-    *t = 0;
-    while (1) {
-	if (*ptr==0) 
-	    ctype = PRC_EOS;
-	else if (*ptr=='\\')
-	    ctype = PRC_ESCAPE;
-	else if (*ptr=='"')
-	    ctype = PRC_DQUOTE;
-	else if (*ptr=='\'')
-	    ctype = PRC_SQUOTE;
-	else if (*ptr==' ' || *ptr=='\t')
-	    ctype = PRC_BLANK;
-	else
-	    ctype = PRC_ALPHA;
-
-	if (mtable[state][ctype].output) {
-	    *t = *ptr; t++;
-	    *t = 0;
-	}
-	state = mtable[state][ctype].nstate;
-	ptr++;
-	if (mtable[state][0].output<0) {
-	    break;
-	}
-    }
-
-    if (*ret==0)
-	t = NULL;
-    else
-	t = strdup(ret);
-
-    free(ret);
-    
-    if (ctype==PRC_EOS)
-	*next = NULL;
-    else
-	*next = ptr;
-    
-    return t;
-}
-
-
-extern void
-parse_command(char *command, char ***argv, int *argc)
-{
-    LinkedList *list = NULL;
-    char *token, *line;
-    int count, i;
-
-    line = command;
-    do {
-	token = next_token(line, &line);
-	if (token) {	    
-	    list = list_cons(token, list);
-	}
-    } while (token!=NULL && line!=NULL);
-
-    count = list_length(list);
-    *argv = malloc(sizeof(char*)*count);
-    i = count;
-    while (list!=NULL) {
-	(*argv)[--i] = list->head;
-	list_remove_head(&list);
-    }
-    *argc = count;
-}
-
-extern pid_t
-execCommand(char *command)
-{
-    pid_t pid;
-    char **argv;
-    int argc;
-
-    parse_command(command, &argv, &argc);
-    
-    if (argv==NULL) {
-        return 0;
-    }
-    
-    if ((pid=fork())==0) {
-        char **args;
-        int i;
-        
-        args = malloc(sizeof(char*)*(argc+1));
-        if (!args)
-          exit(10);
-        for (i=0; i<argc; i++) {
-            args[i] = argv[i];
-        }
-        args[argc] = NULL;
-        execvp(argv[0], args);
-        exit(10);
-    }
-    return pid;
-}

wmgeneral/misc.h

@@ -1,9 +0,0 @@
-#ifndef __MISC_H
-#define __MISC_H
-
-#include <unistd.h>
-
-extern void parse_command(char *, char ***, int *);
-
-extern pid_t execCommand(char *);
-#endif /* __MISC_H */

wmgeneral/wmgeneral.c

@@ -1,481 +0,0 @@
-/*
-	Best viewed with vim5, using ts=4
-
-	wmgeneral was taken from wmppp.
-
-	It has a lot of routines which most of the wm* programs use.
-
-	------------------------------------------------------------
-
-	Author: Martijn Pieterse (pieterse@xs4all.nl)
-
-	---
-	CHANGES:
-    ---
-    14/09/1998 (Dave Clark, clarkd@skyia.com)
-        * Updated createXBMfromXPM routine
-        * Now supports >256 colors
-	11/09/1998 (Martijn Pieterse, pieterse@xs4all.nl)
-		* Removed a bug from parse_rcfile. You could
-		  not use "start" in a command if a label was 
-		  also start.
-		* Changed the needed geometry string.
-		  We don't use window size, and don't support
-		  negative positions.
-	03/09/1998 (Martijn Pieterse, pieterse@xs4all.nl)
-		* Added parse_rcfile2
-	02/09/1998 (Martijn Pieterse, pieterse@xs4all.nl)
-		* Added -geometry support (untested)
-	28/08/1998 (Martijn Pieterse, pieterse@xs4all.nl)
-		* Added createXBMfromXPM routine
-		* Saves a lot of work with changing xpm's.
-	02/05/1998 (Martijn Pieterse, pieterse@xs4all.nl)
-		* changed the read_rc_file to parse_rcfile, as suggested by Marcelo E. Magallon
-		* debugged the parse_rc file.
-	30/04/1998 (Martijn Pieterse, pieterse@xs4all.nl)
-		* Ripped similar code from all the wm* programs,
-		  and put them in a single file.
-
-*/
-
-#include <stdlib.h>
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
-#include <ctype.h>
-#include <stdarg.h>
-
-#include <X11/Xlib.h>
-#include <X11/xpm.h>
-#include <X11/extensions/shape.h>
-
-#include "wmgeneral.h"
-
-  /*****************/
- /* X11 Variables */
-/*****************/
-
-Window		Root;
-int			screen;
-int			x_fd;
-int			d_depth;
-XSizeHints	mysizehints;
-XWMHints	mywmhints;
-Pixel		back_pix, fore_pix;
-char		*Geometry = "";
-Window		iconwin, win;
-GC			NormalGC;
-XpmIcon		wmgen;
-Pixmap		pixmask;
-
-  /*****************/
- /* Mouse Regions */
-/*****************/
-
-typedef struct {
-	int		enable;
-	int		top;
-	int		bottom;
-	int		left;
-	int		right;
-} MOUSE_REGION;
-
-MOUSE_REGION	mouse_region[MAX_MOUSE_REGION];
-
-  /***********************/
- /* Function Prototypes */
-/***********************/
-
-static void GetXPM(XpmIcon *, char **);
-static Pixel GetColor(char *);
-void RedrawWindow(void);
-void AddMouseRegion(int, int, int, int, int);
-int CheckMouseRegion(int, int);
-
-/*******************************************************************************\
-|* parse_rcfile																   *|
-\*******************************************************************************/
-
-void parse_rcfile(const char *filename, rckeys *keys) {
-
-	char	*p,*q;
-	char	temp[128];
-	char	*tokens = " :\t\n";
-	FILE	*fp;
-	int		i,key;
-
-	fp = fopen(filename, "r");
-	if (fp) {
-		while (fgets(temp, 128, fp)) {
-			key = 0;
-			q = strdup(temp);
-			q = strtok(q, tokens);
-			while (key >= 0 && keys[key].label) {
-				if ((!strcmp(q, keys[key].label))) {
-					p = strstr(temp, keys[key].label);
-					p += strlen(keys[key].label);
-					p += strspn(p, tokens);
-					if ((i = strcspn(p, "#\n"))) p[i] = 0;
-					free(*keys[key].var);
-					*keys[key].var = strdup(p);
-					key = -1;
-				} else key++;
-			}
-			free(q);
-		}
-		fclose(fp);
-	}
-}
-
-/*******************************************************************************\
-|* parse_rcfile2															   *|
-\*******************************************************************************/
-
-void parse_rcfile2(const char *filename, rckeys2 *keys) {
-
-	char	*p;
-	char	temp[128];
-	char	*tokens = " :\t\n";
-	FILE	*fp;
-	int		i,key;
-	char	*family = NULL;
-
-	fp = fopen(filename, "r");
-	if (fp) {
-		while (fgets(temp, 128, fp)) {
-			key = 0;
-			while (key >= 0 && keys[key].label) {
-				if ((p = strstr(temp, keys[key].label))) {
-					p += strlen(keys[key].label);
-					p += strspn(p, tokens);
-					if ((i = strcspn(p, "#\n"))) p[i] = 0;
-					free(*keys[key].var);
-					*keys[key].var = strdup(p);
-					key = -1;
-				} else key++;
-			}
-		}
-		fclose(fp);
-	}
-	free(family);
-}
-
-
-/*******************************************************************************\
-|* GetXPM																	   *|
-\*******************************************************************************/
-
-static void GetXPM(XpmIcon *wmgen, char *pixmap_bytes[]) {
-
-	XWindowAttributes	attributes;
-	int					err;
-
-	/* For the colormap */
-	XGetWindowAttributes(display, Root, &attributes);
-
-	wmgen->attributes.valuemask |= (XpmReturnPixels | XpmReturnExtensions);
-
-	err = XpmCreatePixmapFromData(display, Root, pixmap_bytes, &(wmgen->pixmap),
-					&(wmgen->mask), &(wmgen->attributes));
-	
-	if (err != XpmSuccess) {
-		fprintf(stderr, "Not enough free colorcells.\n");
-		exit(1);
-	}
-}
-
-/*******************************************************************************\
-|* GetColor																	   *|
-\*******************************************************************************/
-
-static Pixel GetColor(char *name) {
-
-	XColor				color;
-	XWindowAttributes	attributes;
-
-	XGetWindowAttributes(display, Root, &attributes);
-
-	color.pixel = 0;
-	if (!XParseColor(display, attributes.colormap, name, &color)) {
-		fprintf(stderr, "wm.app: can't parse %s.\n", name);
-	} else if (!XAllocColor(display, attributes.colormap, &color)) {
-		fprintf(stderr, "wm.app: can't allocate %s.\n", name);
-	}
-	return color.pixel;
-}
-
-/*******************************************************************************\
-|* flush_expose																   *|
-\*******************************************************************************/
-
-static int flush_expose(Window w) {
-
-	XEvent 		dummy;
-	int			i=0;
-
-	while (XCheckTypedWindowEvent(display, w, Expose, &dummy))
-		i++;
-
-	return i;
-}
-
-/*******************************************************************************\
-|* RedrawWindow																   *|
-\*******************************************************************************/
-
-void RedrawWindow(void) {
-	
-	flush_expose(iconwin);
-	XCopyArea(display, wmgen.pixmap, iconwin, NormalGC, 
-				0,0, wmgen.attributes.width, wmgen.attributes.height, 0,0);
-	flush_expose(win);
-	XCopyArea(display, wmgen.pixmap, win, NormalGC,
-				0,0, wmgen.attributes.width, wmgen.attributes.height, 0,0);
-}
-
-/*******************************************************************************\
-|* RedrawWindowXY															   *|
-\*******************************************************************************/
-
-void RedrawWindowXY(int x, int y) {
-	
-	flush_expose(iconwin);
-	XCopyArea(display, wmgen.pixmap, iconwin, NormalGC, 
-				x,y, wmgen.attributes.width, wmgen.attributes.height, 0,0);
-	flush_expose(win);
-	XCopyArea(display, wmgen.pixmap, win, NormalGC,
-				x,y, wmgen.attributes.width, wmgen.attributes.height, 0,0);
-}
-
-/*******************************************************************************\
-|* AddMouseRegion															   *|
-\*******************************************************************************/
-
-void AddMouseRegion(int index, int left, int top, int right, int bottom) {
-
-	if (index < MAX_MOUSE_REGION) {
-		mouse_region[index].enable = 1;
-		mouse_region[index].top = top;
-		mouse_region[index].left = left;
-		mouse_region[index].bottom = bottom;
-		mouse_region[index].right = right;
-	}
-}
-
-/*******************************************************************************\
-|* CheckMouseRegion															   *|
-\*******************************************************************************/
-
-int CheckMouseRegion(int x, int y) {
-
-	int		i;
-	int		found;
-
-	found = 0;
-
-	for (i=0; i<MAX_MOUSE_REGION && !found; i++) {
-		if (mouse_region[i].enable &&
-			x <= mouse_region[i].right &&
-			x >= mouse_region[i].left &&
-			y <= mouse_region[i].bottom &&
-			y >= mouse_region[i].top)
-			found = 1;
-	}
-	if (!found) return -1;
-	return (i-1);
-}
-
-/*******************************************************************************\
-|* createXBMfromXPM															   *|
-\*******************************************************************************/
-void createXBMfromXPM(char *xbm, char **xpm, int sx, int sy) {
-
-	int		i,j,k;
-	int		width, height, numcol, depth;
-    int 	zero=0;
-	unsigned char	bwrite;
-    int		bcount;
-    int     curpixel;
-	
-	sscanf(*xpm, "%d %d %d %d", &width, &height, &numcol, &depth);
-
-
-    for (k=0; k!=depth; k++)
-    {
-        zero <<=8;
-        zero |= xpm[1][k];
-    }
-        
-	for (i=numcol+1; i < numcol+sy+1; i++) {
-		bcount = 0;
-		bwrite = 0;
-		for (j=0; j<sx*depth; j+=depth) {
-            bwrite >>= 1;
-
-            curpixel=0;
-            for (k=0; k!=depth; k++)
-            {
-                curpixel <<=8;
-                curpixel |= xpm[i][j+k];
-            }
-                
-            if ( curpixel != zero ) {
-				bwrite += 128;
-			}
-			bcount++;
-			if (bcount == 8) {
-				*xbm = bwrite;
-				xbm++;
-				bcount = 0;
-				bwrite = 0;
-			}
-		}
-	}
-}
-
-/*******************************************************************************\
-|* copyXPMArea																   *|
-\*******************************************************************************/
-
-void copyXPMArea(int x, int y, int sx, int sy, int dx, int dy) {
-
-	XCopyArea(display, wmgen.pixmap, wmgen.pixmap, NormalGC, x, y, sx, sy, dx, dy);
-
-}
-
-/*******************************************************************************\
-|* copyXBMArea																   *|
-\*******************************************************************************/
-
-void copyXBMArea(int x, int y, int sx, int sy, int dx, int dy) {
-
-	XCopyArea(display, wmgen.mask, wmgen.pixmap, NormalGC, x, y, sx, sy, dx, dy);
-}
-
-
-/*******************************************************************************\
-|* setMaskXY																   *|
-\*******************************************************************************/
-
-void setMaskXY(int x, int y) {
-
-	 XShapeCombineMask(display, win, ShapeBounding, x, y, pixmask, ShapeSet);
-	 XShapeCombineMask(display, iconwin, ShapeBounding, x, y, pixmask, ShapeSet);
-}
-
-/*******************************************************************************\
-|* openXwindow																   *|
-\*******************************************************************************/
-void openXwindow(int argc, char *argv[], char *pixmap_bytes[], const char *pixmask_bits, int pixmask_width, int pixmask_height) {
-
-	unsigned int	borderwidth = 1;
-	XClassHint		classHint;
-	char			*display_name = NULL;
-	char			*wname = argv[0];
-	XTextProperty	name;
-
-	XGCValues		gcv;
-	unsigned long	gcm;
-
-	char			*geometry = NULL;
-
-	int				dummy=0;
-	int				i, wx, wy;
-
-	for (i=1; argv[i]; i++) {
-		if (!strcmp(argv[i], "-display")) {
-			display_name = argv[i+1];
-			i++;
-		}
-		if (!strcmp(argv[i], "-geometry")) {
-			geometry = argv[i+1];
-			i++;
-		}
-	}
-
-	if (!(display = XOpenDisplay(display_name))) {
-		fprintf(stderr, "%s: can't open display %s\n", 
-						wname, XDisplayName(display_name));
-		exit(1);
-	}
-	screen  = DefaultScreen(display);
-	Root    = RootWindow(display, screen);
-	d_depth = DefaultDepth(display, screen);
-	x_fd    = XConnectionNumber(display);
-
-	/* Convert XPM to XImage */
-	GetXPM(&wmgen, pixmap_bytes);
-
-	/* Create a window to hold the stuff */
-	mysizehints.flags = USSize | USPosition;
-	mysizehints.x = 0;
-	mysizehints.y = 0;
-
-	back_pix = GetColor("white");
-	fore_pix = GetColor("black");
-
-	XWMGeometry(display, screen, Geometry, NULL, borderwidth, &mysizehints,
-				&mysizehints.x, &mysizehints.y,&mysizehints.width,&mysizehints.height, &dummy);
-
-	mysizehints.width = 64;
-	mysizehints.height = 64;
-		
-	win = XCreateSimpleWindow(display, Root, mysizehints.x, mysizehints.y,
-				mysizehints.width, mysizehints.height, borderwidth, fore_pix, back_pix);
-	
-	iconwin = XCreateSimpleWindow(display, win, mysizehints.x, mysizehints.y,
-				mysizehints.width, mysizehints.height, borderwidth, fore_pix, back_pix);
-
-	/* Activate hints */
-	XSetWMNormalHints(display, win, &mysizehints);
-	classHint.res_name = wname;
-	classHint.res_class = wname;
-	XSetClassHint(display, win, &classHint);
-
-	XSelectInput(display, win, ButtonPressMask | ExposureMask | ButtonReleaseMask | PointerMotionMask | StructureNotifyMask);
-	XSelectInput(display, iconwin, ButtonPressMask | ExposureMask | ButtonReleaseMask | PointerMotionMask | StructureNotifyMask);
-
-	if (XStringListToTextProperty(&wname, 1, &name) == 0) {
-		fprintf(stderr, "%s: can't allocate window name\n", wname);
-		exit(1);
-	}
-
-	XSetWMName(display, win, &name);
-
-	/* Create GC for drawing */
-	
-	gcm = GCForeground | GCBackground | GCGraphicsExposures;
-	gcv.foreground = fore_pix;
-	gcv.background = back_pix;
-	gcv.graphics_exposures = 0;
-	NormalGC = XCreateGC(display, Root, gcm, &gcv);
-
-	/* ONLYSHAPE ON */
-
-	pixmask = XCreateBitmapFromData(display, win, pixmask_bits, pixmask_width, pixmask_height);
-
-	XShapeCombineMask(display, win, ShapeBounding, 0, 0, pixmask, ShapeSet);
-	XShapeCombineMask(display, iconwin, ShapeBounding, 0, 0, pixmask, ShapeSet);
-
-	/* ONLYSHAPE OFF */
-
-	mywmhints.initial_state = WithdrawnState;
-	mywmhints.icon_window = iconwin;
-	mywmhints.icon_x = mysizehints.x;
-	mywmhints.icon_y = mysizehints.y;
-	mywmhints.window_group = win;
-	mywmhints.flags = StateHint | IconWindowHint | IconPositionHint | WindowGroupHint;
-
-	XSetWMHints(display, win, &mywmhints);
-
-	XSetCommand(display, win, argv, argc);
-	XMapWindow(display, win);
-
-	if (geometry) {
-		if (sscanf(geometry, "+%d+%d", &wx, &wy) != 2) {
-			fprintf(stderr, "Bad geometry string.\n");
-			exit(1);
-		}
-		XMoveWindow(display, win, wx, wy);
-	}
-}

wmgeneral/wmgeneral.h

@@ -1,59 +0,0 @@
-#ifndef WMGENERAL_H_INCLUDED
-#define WMGENERAL_H_INCLUDED
-
-  /***********/
- /* Defines */
-/***********/
-
-#define MAX_MOUSE_REGION (16)
-
-  /************/
- /* Typedefs */
-/************/
-
-typedef struct _rckeys rckeys;
-
-struct _rckeys {
-	const char	*label;
-	char		**var;
-};
-
-typedef struct _rckeys2 rckeys2;
-
-struct _rckeys2 {
-	const char	*family;
-	const char	*label;
-	char		**var;
-};
-
-typedef struct {
-	Pixmap			pixmap;
-	Pixmap			mask;
-	XpmAttributes	attributes;
-} XpmIcon;
-
-  /*******************/
- /* Global variable */
-/*******************/
-
-Display		*display;
-
-  /***********************/
- /* Function Prototypes */
-/***********************/
-
-void AddMouseRegion(int index, int left, int top, int right, int bottom);
-int CheckMouseRegion(int x, int y);
-
-void openXwindow(int argc, char *argv[], char **, const char *, int, int);
-void RedrawWindow(void);
-void RedrawWindowXY(int x, int y);
-
-void createXBMfromXPM(char *, char **, int, int);
-void copyXPMArea(int, int, int, int, int, int);
-void copyXBMArea(int, int, int, int, int, int);
-void setMaskXY(int, int);
-
-void parse_rcfile(const char *, rckeys *);
-
-#endif

wmtemp_sample

@@ -0,0 +1,17 @@
+# wmtemp conf file
+
+cpu1_path = /sys/devices/platform/coretemp.0/hwmon/hwmon2/temp2_input
+cpu1_critical = 80
+cpu1_warning = 65
+cpu2_path = /sys/devices/platform/coretemp.0/hwmon/hwmon2/temp3_input
+cpu2_critical = 80
+cpu2_warning = 65
+cpu3_path = /sys/devices/platform/coretemp.0/hwmon/hwmon2/temp4_input
+cpu3_critical = 80
+cpu3_warning = 65
+cpu4_path = /sys/devices/platform/coretemp.0/hwmon/hwmon2/temp5_input
+cpu4_critical = 80
+cpu4_warning = 65
+gpu_path = /sys/devices/virtual/hwmon/hwmon1/temp4_input
+gpu_critical = 70
+gpu_warning = 60

wmtempnv/wmtempnv.c

@@ -1,207 +0,0 @@
-/*
- * wmtempnv: a sensor monitor for WindowMaker. this little app is mainly based
- * on wmsensormon and other simple dockapps.
- *
- * version = 0.4
- *
- * requirements: configured lm_sensors, sensor program and
- *               nvidia-settings package
- * licence: gpl
- */
-
-#include <sys/param.h>
-#include <sys/types.h>
-#include "standards.h"
-#include <X11/Xlib.h>
-#include <X11/xpm.h>
-#include <X11/extensions/shape.h>
-#include <string.h>
-#include "../wmgeneral/wmgeneral.h"
-#include "../wmgeneral/misc.h"
-#include "../wmgeneral/misc.h"
-#include "wmtempnv_master.xpm"
-#include "wmtempnv_mask.xbm"
-
-#include <NVCtrl/NVCtrl.h>
-#include <NVCtrl/NVCtrlLib.h>
-
-#define MAXSTRLEN 8
-#define WARN_TEMP 65
-#define CRIT_TEMP 80
-#define WARN_TEMP_GPU 70
-#define CRIT_TEMP_GPU 85
-#define MAXFNAME 50
-
-
-void display_values(int, int, int);
-int get_temp(int core_number, Display*);
-int get_offset(int temp, short cpu);
-void display_help(char* progname);
-int get_gpu_temp(char* path, Display *disp);
-void read_file_into(char *filepath, int *output);
-Display *display;
-
-int main(int argc, char **argv){
-    int core1_temp=0, core2_temp=0, core3_temp=0, core4_temp=0, gpu_temp=0;
-    /* offset is one of 0 (normal), 7 (alert), 14 (warning) */
-    int core1_offset=0, core2_offset=0, core3_offset=0, core4_offset=0,
-        gpu_offset=0;
-    int counter = 0;
-    char* path = "";
-    display = XOpenDisplay(NULL);
-
-    if (argc > 1) {
-        if (argc > 2) {
-            display_help(argv[0]);
-            exit(2);
-        }
-        
-        if (argc == 2 &&
-                (strcmp(argv[1], "--help") == 0 ||
-                 strcmp(argv[1], "-h") == 0)) {
-            display_help(argv[0]);
-            exit(0);
-        }
-
-        path = argv[1];
-    }
-
-    openXwindow(argc, argv, wmtempnv_master, wmtempnv_mask_bits,
-            wmtempnv_mask_width, wmtempnv_mask_height);
-
-    while(TRUE){
-        if (counter < 1){
-            counter = 5;
-
-            // cpu
-            core1_temp = get_temp(0, display);
-            core1_offset = get_offset(core1_temp, 1);
-            core2_temp = get_temp(1, display);
-            core2_offset = get_offset(core2_temp, 1);
-            core3_temp = get_temp(2, display);
-            core3_offset = get_offset(core3_temp, 1);
-            core4_temp = get_temp(3, display);
-            core4_offset = get_offset(core4_temp, 1);
-
-            // gpu
-            gpu_temp = get_gpu_temp(path, display);
-            gpu_offset = get_offset(gpu_temp, 0);
-        }
-
-        // core 1
-        copyXPMArea(0, 87 + core1_offset, 23, 7, 4, 7); // LCD: "CPU"
-        copyXPMArea(5, 65 + core1_offset, 5, 7, 22, 7); // LCD: number of cpu
-        copyXPMArea(66, 65 + core1_offset, 9, 7, 51, 7); // LCD: "°C"
-        display_values(core1_temp, 0, core1_offset);
-
-        // core 2
-        copyXPMArea(0, 87 + core2_offset, 23, 7, 4, 16);
-        copyXPMArea(10, 65 + core2_offset, 5, 7, 22, 16);
-        copyXPMArea(66, 65 + core2_offset, 9, 7, 51, 16);
-        display_values(core2_temp, 9, core2_offset);
-
-        // core 3
-        copyXPMArea(0, 87 + core3_offset, 23, 7, 4, 25);
-        copyXPMArea(15, 65 + core3_offset, 5, 7, 22, 25);
-        copyXPMArea(66, 65 + core3_offset, 9, 7, 51, 25);
-        display_values(core3_temp, 18, core3_offset);
-
-        // core 4
-        copyXPMArea(0, 87 + core4_offset, 23, 7, 4, 34);
-        copyXPMArea(20, 65 + core4_offset, 5, 7, 22, 34);
-        copyXPMArea(66, 65 + core4_offset, 9, 7, 51, 34);
-        display_values(core4_temp, 27, core4_offset);
-
-        // gpu
-        copyXPMArea(23, 87 + gpu_offset, 23, 7, 4, 49);
-        copyXPMArea(66, 65 + gpu_offset , 9, 7, 51, 49);
-        display_values(gpu_temp, 42, gpu_offset);
-        RedrawWindow();
-        counter--;
-        usleep(100000);
-    }
-}
-
-int get_offset(int temp, short cpu){
-    int alt, wrn;
-    if(cpu == 1){
-        wrn = WARN_TEMP;
-        alt = CRIT_TEMP;
-    }else{
-        wrn = WARN_TEMP_GPU;
-        alt = CRIT_TEMP_GPU;
-    }
-    if(temp >= alt){
-        return 7;  // Alert
-    }else if(temp >= wrn){
-        return 14; // Warning
-    }else{
-        return 0;  // Normal
-    }
-}
-
-void display_values(int temp, int offset, int core2_offset){
-    char text[5], num1, num2, num3, num4;
-
-    sprintf(text, "%03d", temp);
-    num1 = (text[0] - '0');
-    num2 = (text[1] - '0');
-    num3 = (text[2] - '0');
-    num4 = (text[3] - '0');
-    if(num1)
-        copyXPMArea(5 * num1, 65 + core2_offset, 5, 7, 31, 7 + offset);
-    else
-        copyXPMArea(60, 65 + core2_offset, 5, 7, 31, 7 + offset);
-    copyXPMArea(5 * num2, 65 + core2_offset, 5, 7, 38, 7 + offset);
-    copyXPMArea(5 * num3, 65 + core2_offset, 5, 7, 45, 7 + offset);
-    copyXPMArea(5 * num4, 65 + core2_offset, 5, 7, 51, 7 + offset);
-}
-
-int get_temp(int core_number, Display *disp){
-    // Core temperature. argument is core number.
-    char filename[MAXFNAME];
-    int core_temp = 0;
-
-    snprintf(filename, MAXFNAME,
-            "/sys/bus/platform/devices/coretemp.0/temp%d_input",
-            core_number + 2);
-    read_file_into(filename, &core_temp);
-    return core_temp;
-}
-
-int get_gpu_temp(char* path, Display *disp){
-    // return GPU temperature. Argument is path in sysfs or empty string.
-    int gpu_temp = 0;
-	Bool res;
-
-    if (strcmp(path, "") == 0){
-		res = XNVCTRLQueryTargetAttribute(disp,
-				NV_CTRL_TARGET_TYPE_GPU, 0, 0,
-				NV_CTRL_GPU_CORE_TEMPERATURE, &gpu_temp);
-
-		if (res == False) gpu_temp = 0;
-    }else{
-        read_file_into(path, &gpu_temp);
-    }
-    return gpu_temp;
-}
-
-void read_file_into(char *filepath, int *output) {
-    // Read an integer from the provided filepath and write it in the address
-    FILE *fp;
-    if((fp = fopen(filepath, "r")) != NULL){
-        if(fscanf(fp, "%d", output) != EOF){
-            *output = *output / 1000;
-            fclose(fp);
-        }
-    }
-}
-
-void display_help(char* progname){
-    printf("Dockapp for monitoring CPU and Nvidia GPU temperatures.\n");
-    printf("Usage:\n\t%s [full path for temp in sysfs]\n\n", progname);
-    printf("As an optional parameter you can provide `temp_input' ");
-    printf("full path from sysfs,\ncorresponding to your gfx card ");
-    printf("to read temperature from. Otherwise\nfunctionality of ");
-    printf("nv-control will be used (package nvidia-settings).\n");
-}