another test for cvs notifications

ChangeLog

@@ -123,6 +123,9 @@ Changes since version 0.80.2:
   appicon when a KDE3 application opens a config panel.
 - Updated slovak translation (Jan Tomka <judas@linux.sk>)
 - Added xdnd v3 support in WINGs (Sylvain Reynal <sreynal@nerim.net>)
+- Check whether libXft is at least version 2.1.2 else refuse to compile.
+- Fixed bug in icon chooser dialog that could cause a segmentation fault
+  in some cases (Pascal Hofstee <caelian@gmail.com>)
 
 
 Changes since version 0.80.1:

WINGs/Extras/Makefile.am

@@ -22,6 +22,7 @@ libExtraWINGs_a_SOURCES = 	\
 	wtableview.h \
 	wtabledelegates.h 
 
+AM_CFLAGS = -fno-strict-aliasing
 
 INCLUDES = -I$(top_srcdir)/wrlib -I$(top_srcdir)/WINGs \
 	-DRESOURCE_PATH=\"$(datadir)/WINGs\" @HEADER_SEARCH_PATH@ -DDEBUG

WINGs/Makefile.am

@@ -108,7 +108,9 @@ libWUtil_a_SOURCES = 	\
 	wutil.c
 
 
-AM_CPPFLAGS = @CPPFLAGS@ -DLOCALEDIR=\"$(NLSDIR)\"
+AM_CPPFLAGS = -DLOCALEDIR=\"$(NLSDIR)\"
+
+AM_CFLAGS = -fno-strict-aliasing
 
 INCLUDES = -I$(top_srcdir)/WINGs/WINGs -I$(top_srcdir)/wrlib -I$(top_srcdir)/src \
 	-DRESOURCE_PATH=\"$(datadir)/WINGs\" @XFTFLAGS@ @HEADER_SEARCH_PATH@ -DDEBUG

WINGs/Tests/wtest.c

@@ -116,14 +116,14 @@ testFrame(WMScreen *scr)
 }
 
 
-static void
+/*static void
 resizedWindow(void *self, WMNotification *notif)
 {
     WMView *view = (WMView*)WMGetNotificationObject(notif);
     WMSize size = WMGetViewSize(view);
 
     WMResizeWidget((WMWidget*)self, size.width, size.height);
-}
+}*/
 
 void
 testBox(WMScreen *scr)
@@ -609,7 +609,8 @@ testText(WMScreen *scr)
         WMFont *font, *ifont;
 
         font = WMDefaultSystemFont(scr);
-        ifont = WMCopyFontWithStyle(scr, font, WFSEmphasized);
+        //ifont = WMCopyFontWithStyle(scr, font, WFSEmphasized);
+        ifont = WMCreateFont(scr, "verdana,sans:pixelsize=12:italic");
         if (ifont) {
             WMSetTextDefaultFont(text, ifont);
             WMReleaseFont(ifont);
@@ -619,7 +620,7 @@ testText(WMScreen *scr)
         WMReleaseFont(font);
     }
 
-    if(file) {
+    if (file) {
         char buf[1024];
 
         WMFreezeText(text);

WINGs/WINGs/WINGs.h

@@ -1834,12 +1834,11 @@ void WMShowFontPanel(WMFontPanel *panel);
 
 void WMHideFontPanel(WMFontPanel *panel);
 
+void WMFreeFontPanel(WMFontPanel *panel);
+
 void WMSetFontPanelAction(WMFontPanel *panel, WMAction2 *action, void *data);
 
-void WMSetFontPanelFont(WMFontPanel *panel, WMFont *font);
+void WMSetFontPanelFont(WMFontPanel *panel, char *fontName);
-
-/* you can free the returned string */
-char* WMGetFontPanelFontName(WMFontPanel *panel);
 
 WMFont* WMGetFontPanelFont(WMFontPanel *panel);
 

WINGs/WINGs/WINGsP.h

@@ -22,19 +22,14 @@
 extern "C" {
 #endif /* __cplusplus */
 
-#define DOUBLE_BUFFER
-
 
+#define DOUBLE_BUFFER   1
 
 #define WC_UserWidget	128
 
+#define SCROLLER_WIDTH	20
 
-
+#define XDND_VERSION    4
-#define SCROLLER_WIDTH	 20
-
-
-
-#define XDND_VERSION 4
 
 
 typedef struct W_Application {

WINGs/configuration.c

@@ -14,10 +14,6 @@ _WINGsConfiguration WINGsConfiguration;
 
 #define BOLD_SYSTEM_FONT "-*-helvetica-bold-r-normal-*-%d-*-*-*-*-*-*-*,-*-*-bold-r-*-*-%d-*-*-*-*-*-*-*"
 
-#define XFTSYSTEM_FONT "-*-arial-medium-r-normal-*-%d-*-*-*-*-*-*-*"
-
-#define XFTBOLD_SYSTEM_FONT "-*-arial-bold-r-normal-*-%d-*-*-*-*-*-*-*"
-
 #define FLOPPY_PATH "/floppy"
 
 
@@ -45,6 +41,7 @@ getButtonWithName(const char *name, unsigned defaultButton)
 }
 
 
+// fix this
 static Bool
 missingOrInvalidXLFD(char *xlfd)
 {

WINGs/dragcommon.c

@@ -193,14 +193,15 @@ W_HandleDNDClientMessage(WMView *toplevel, XClientMessageEvent *event)
     WMDraggingInfo *info = &scr->dragInfo;
     Atom messageType = event->message_type;
 
-    char* msgTypeName = XGetAtomName(scr->display, messageType);
-
 #ifdef XDND_DEBUG
+    {
+        char* msgTypeName = XGetAtomName(scr->display, messageType);
 
-    if (msgTypeName != NULL)
+        if (msgTypeName != NULL)
-        printf("event type = %s\n", msgTypeName);
+            printf("event type = %s\n", msgTypeName);
-    else
+        else
-        printf("pb with event type !\n");
+            printf("pb with event type !\n");
+    }
 #endif
 
 

WINGs/dragdestination.c

@@ -79,7 +79,7 @@ createDropDataArray(WMArray *requiredTypes)
 static WMArray*
 getTypesFromTypeList(WMScreen *scr, Window sourceWin)
 {
-    WMDraggingInfo *info = &scr->dragInfo;
+    /* // WMDraggingInfo *info = &scr->dragInfo;*/
     Atom dataType;
     Atom* typeAtomList;
     WMArray* typeList;
@@ -365,7 +365,6 @@ W_DragDestinationStoreEnterMsgInfo(WMDraggingInfo *info,
                                    WMView *toplevel, XClientMessageEvent *event)
 {
     WMScreen *scr = W_VIEW_SCREEN(toplevel);
-    int i,j, typesCount;
 
     if (XDND_DEST_INFO(info) == NULL)
         initDestinationDragInfo(info);
@@ -609,7 +608,7 @@ static void
 sendAllowedAction(WMView *destView, Atom action)
 {
     WMScreen *scr = W_VIEW_SCREEN(destView);
-    WMPoint destPos = WMGetViewScreenPosition(destView);
+    /* // WMPoint destPos = WMGetViewScreenPosition(destView); */
     WMSize destSize = WMGetViewSize(destView);
     int destX, destY;
     Window foo;

WINGs/dragsource.c

@@ -425,6 +425,8 @@ sendEnterMessage(WMDraggingInfo *info)
 }
 
 
+// this functon doesn't return something in all cases.
+// control reaches end of non-void function. fix this -Dan
 static Bool
 sendPositionMessage(WMDraggingInfo *info, WMPoint *mousePos)
 {
@@ -740,7 +742,6 @@ isXdndAware(WMScreen *scr, Window win)
     int format;
     unsigned long count, remain;
     unsigned char *winXdndVersion;
-    unsigned char *proxy;
 
     if (win == None)
         return False;
@@ -876,7 +877,7 @@ initMotionProcess(WMView *view, WMDraggingInfo *info,
 static void
 processMotion(WMDraggingInfo *info, Window windowUnderDrag, WMPoint *mousePos)
 {
-    WMScreen *scr = sourceScreen(info);
+    /* // WMScreen *scr = sourceScreen(info); */
     Window newDestination = findDestination(info, mousePos);
 
     W_DragSourceStopTimer();
@@ -1058,6 +1059,7 @@ traceStatusMsg(Display *dpy, XClientMessageEvent *statusEvent)
 #endif
 
 
+static void
 storeDropAction(WMDraggingInfo *info, Atom destAction)
 {
     WMView* sourceView = XDND_SOURCE_VIEW(info);

WINGs/python/WINGs.py

@@ -26,10 +26,11 @@ class WMTimer:
             self._o = wings.pyWMAddPersistentTimerHandler(milliseconds, (callback, cdata))
         else:
             self._o = wings.pyWMAddTimerHandler(milliseconds, (callback, cdata))
+        self.__WMDeleteTimerHandler = wings.pyWMDeleteTimerHandler
 
     def __del__(self):
-        wings.pyWMDeleteTimerHandler(self._o)
+        self.__WMDeleteTimerHandler(self._o)
-    #delete = __del__
+
 
 class WMPersistentTimer(WMTimer):
     def __init__(self, milliseconds, callback, cdata=None):
@@ -87,13 +88,14 @@ class WMView:
 
 class WMWidget(WMView):
     def __init__(self):
-        self._o = None
         if self.__class__ == WMWidget:
             raise Error, "a WMWidget can't be instantiated directly"
+        self._o = None
+        self.__WMDestroyWidget = wings.WMDestroyWidget
 
     def __del__(self):
-        if (self._o != None):
+        if self._o is not None:
-            wings.WMDestroyWidget(self._o)
+            self.__WMDestroyWidget(self._o)
 
     def resize(self, width, height):
         wings.WMResizeWidget(self._o, width, height)

WINGs/wevent.c

@@ -66,8 +66,8 @@ static WMEventHook *extraEventHandler=NULL;
  *
  */
 void
-    WMCreateEventHandler(WMView *view, unsigned long mask, WMEventProc *eventProc,
+WMCreateEventHandler(WMView *view, unsigned long mask, WMEventProc *eventProc,
-                         void *clientData)
+                     void *clientData)
 {
     W_EventHandler *hPtr;
     WMArrayIterator iter;

WINGs/wfont_noxft.c

@@ -0,0 +1,769 @@
+
+
+#include "wconfig.h"
+
+#ifndef XFT
+
+#include "WINGsP.h"
+
+#include <wraster.h>
+#include <assert.h>
+#include <X11/Xlocale.h>
+
+
+static char *makeFontSetOfSize(char *fontset, int size);
+
+
+/* XLFD pattern matching */
+static char*
+getElementFromXLFD(const char *xlfd, int index)
+{
+    const char *p = xlfd;
+    while (*p != 0) {
+        if (*p == '-' && --index == 0) {
+            const char *end = strchr(p + 1, '-');
+            char *buf;
+            size_t len;
+            if (end == 0) end = p + strlen(p);
+            len = end - (p + 1);
+            buf = wmalloc(len);
+            memcpy(buf, p + 1, len);
+            buf[len] = 0;
+            return buf;
+        }
+        p++;
+    }
+    return strdup("*");
+}
+
+
+/* XLFD pattern matching */
+static char*
+generalizeXLFD(const char *xlfd)
+{
+    char *buf;
+    int len;
+    char *weight = getElementFromXLFD(xlfd, 3);
+    char *slant  = getElementFromXLFD(xlfd, 4);
+    char *pxlsz  = getElementFromXLFD(xlfd, 7);
+
+#define Xstrlen(A) ((A)?strlen(A):0)
+    len = Xstrlen(xlfd)+Xstrlen(weight)+Xstrlen(slant)+Xstrlen(pxlsz)*2+60;
+#undef Xstrlen
+
+    buf = wmalloc(len + 1);
+    snprintf(buf, len + 1, "%s,-*-*-%s-%s-*-*-%s-*-*-*-*-*-*-*,"
+             "-*-*-*-*-*-*-%s-*-*-*-*-*-*-*,*",
+             xlfd, weight, slant, pxlsz, pxlsz);
+
+    wfree(pxlsz);
+    wfree(slant);
+    wfree(weight);
+
+    return buf;
+}
+
+/* XLFD pattern matching */
+static XFontSet
+W_CreateFontSetWithGuess(Display *dpy, char *xlfd, char ***missing,
+                         int *nmissing, char **def_string)
+{
+    XFontSet fs = XCreateFontSet(dpy, xlfd, missing, nmissing, def_string);
+
+    if (fs != NULL && *nmissing == 0) return fs;
+
+    /* for non-iso8859-1 language and iso8859-1 specification
+     (this fontset is only for pattern analysis) */
+    if (fs == NULL) {
+        if (*nmissing != 0) XFreeStringList(*missing);
+        setlocale(LC_CTYPE, "C");
+        fs = XCreateFontSet(dpy, xlfd, missing, nmissing, def_string);
+        setlocale(LC_CTYPE, "");
+    }
+
+    /* make XLFD font name for pattern analysis */
+    if (fs != NULL) {
+        XFontStruct **fontstructs;
+        char **fontnames;
+        if (XFontsOfFontSet(fs, &fontstructs, &fontnames) > 0)
+            xlfd = fontnames[0];
+    }
+
+    xlfd = generalizeXLFD(xlfd);
+
+    if (*nmissing != 0) XFreeStringList(*missing);
+    if (fs != NULL) XFreeFontSet(dpy, fs);
+
+    fs = XCreateFontSet(dpy, xlfd, missing, nmissing, def_string);
+
+    wfree(xlfd);
+    return fs;
+}
+
+
+static char*
+xlfdFromFontName(char *fontName)
+{
+    char *systemFont, *boldSystemFont;
+    char *font;
+    int size;
+
+    systemFont = WINGsConfiguration.systemFont;
+    boldSystemFont = WINGsConfiguration.boldSystemFont;
+
+    size = WINGsConfiguration.defaultFontSize;
+
+    if (strcmp(fontName, "SystemFont")==0) {
+        font = systemFont;
+    } else if (strncmp(fontName, "SystemFont-", 11)==0) {
+        font = systemFont;
+        if (sscanf(&fontName[11], "%i", &size)!=1) {
+            size = WINGsConfiguration.defaultFontSize;
+            wwarning(_("Invalid size specification '%s' in %s. "
+                       "Using default %d\n"), &fontName[11], fontName, size);
+        }
+    } else if (strcmp(fontName, "BoldSystemFont")==0) {
+        font = boldSystemFont;
+    } else if (strncmp(fontName, "BoldSystemFont-", 15)==0) {
+        font = boldSystemFont;
+        if (sscanf(&fontName[15], "%i", &size)!=1) {
+            size = WINGsConfiguration.defaultFontSize;
+            wwarning(_("Invalid size specification '%s' in %s. "
+                       "Using default %d\n"), &fontName[15], fontName, size);
+        }
+    } else {
+        font = NULL;
+    }
+
+    return (font!=NULL ? makeFontSetOfSize(font, size) : wstrdup(fontName));
+}
+
+
+WMFont*
+WMCreateFontSet(WMScreen *scrPtr, char *fontName)
+{
+    WMFont *font;
+    Display *display = scrPtr->display;
+    char **missing;
+    int nmissing = 0;
+    char *defaultString;
+    char *fname;
+    XFontSetExtents *extents;
+
+    fname = xlfdFromFontName(fontName);
+
+    font = WMHashGet(scrPtr->fontSetCache, fname);
+    if (font) {
+        WMRetainFont(font);
+        wfree(fname);
+        return font;
+    }
+
+    font = wmalloc(sizeof(WMFont));
+    memset(font, 0, sizeof(WMFont));
+
+    font->notFontSet = 0;
+
+    font->screen = scrPtr;
+
+    font->font.set = W_CreateFontSetWithGuess(display, fname, &missing,
+                                              &nmissing, &defaultString);
+    if (nmissing > 0 && font->font.set) {
+        int i;
+
+        wwarning(_("the following character sets are missing in %s:"), fname);
+        for (i = 0; i < nmissing; i++) {
+            wwarning(missing[i]);
+        }
+        XFreeStringList(missing);
+        if (defaultString)
+            wwarning(_("the string \"%s\" will be used in place of any characters from those sets."),
+                     defaultString);
+    }
+    if (!font->font.set) {
+        wfree(font);
+        wfree(fname);
+        return NULL;
+    }
+
+    extents = XExtentsOfFontSet(font->font.set);
+
+    font->height = extents->max_logical_extent.height;
+    font->y = font->height - (font->height + extents->max_logical_extent.y);
+
+    font->refCount = 1;
+
+    font->name = fname;
+
+    assert(WMHashInsert(scrPtr->fontSetCache, font->name, font)==NULL);
+
+    return font;
+}
+
+
+
+WMFont*
+WMCreateNormalFont(WMScreen *scrPtr, char *fontName)
+{
+    WMFont *font;
+    Display *display = scrPtr->display;
+    char *fname, *ptr;
+
+    fontName = xlfdFromFontName(fontName);
+
+    if ((ptr = strchr(fontName, ','))) {
+        fname = wmalloc(ptr - fontName + 1);
+        strncpy(fname, fontName, ptr - fontName);
+        fname[ptr - fontName] = 0;
+    } else {
+        fname = wstrdup(fontName);
+    }
+
+    wfree(fontName);
+
+    font = WMHashGet(scrPtr->fontCache, fname);
+    if (font) {
+        WMRetainFont(font);
+        wfree(fname);
+        return font;
+    }
+
+    font = wmalloc(sizeof(WMFont));
+    memset(font, 0, sizeof(WMFont));
+
+    font->notFontSet = 1;
+
+    font->screen = scrPtr;
+
+    font->font.normal = XLoadQueryFont(display, fname);
+    if (!font->font.normal) {
+        wfree(font);
+        wfree(fname);
+        return NULL;
+    }
+    font->height = font->font.normal->ascent+font->font.normal->descent;
+    font->y = font->font.normal->ascent;
+
+    font->refCount = 1;
+
+    font->name = fname;
+
+    assert(WMHashInsert(scrPtr->fontCache, font->name, font)==NULL);
+
+    return font;
+}
+
+
+WMFont*
+WMCreateFont(WMScreen *scrPtr, char *fontName)
+{
+    return WMCreateFontWithFlags(scrPtr, fontName, WFDefaultFont);
+}
+
+
+WMFont*
+WMCreateFontWithFlags(WMScreen *scrPtr, char *fontName, WMFontFlags flags)
+{
+    Bool multiByte = scrPtr->useMultiByte;
+    WMFont *font;
+
+    if (flags & WFFontSet) {
+        multiByte = True;
+    } else if (flags & WFNormalFont) {
+        multiByte = False;
+    }
+
+    } else if (multiByte) {
+        font = WMCreateFontSet(scrPtr, fontName);
+    } else {
+        font = WMCreateNormalFont(scrPtr, fontName);
+    }
+
+    return font;
+}
+
+
+WMFont*
+WMRetainFont(WMFont *font)
+{
+    wassertrv(font!=NULL, NULL);
+
+    font->refCount++;
+
+    return font;
+}
+
+
+void
+WMReleaseFont(WMFont *font)
+{
+    wassertr(font!=NULL);
+
+    font->refCount--;
+    if (font->refCount < 1) {
+        if (font->notFontSet) {
+            XFreeFont(font->screen->display, font->font.normal);
+        } else {
+            XFreeFontSet(font->screen->display, font->font.set);
+        }
+
+        if (font->name) {
+            if (font->notFontSet) {
+                WMHashRemove(font->screen->fontCache, font->name);
+            } else {
+                WMHashRemove(font->screen->fontSetCache, font->name);
+            }
+            wfree(font->name);
+        }
+        wfree(font);
+    }
+}
+
+
+Bool
+WMIsAntialiasingEnabled(WMScreen *scrPtr)
+{
+    return False;
+}
+
+
+unsigned int
+WMFontHeight(WMFont *font)
+{
+    wassertrv(font!=NULL, 0);
+
+    return font->height;
+}
+
+
+char*
+WMGetFontName(WMFont *font)
+{
+    wassertrv(font!=NULL, NULL);
+
+    return font->name;
+}
+
+
+WMFont*
+WMDefaultSystemFont(WMScreen *scrPtr)
+{
+    return WMRetainFont(scrPtr->normalFont);
+}
+
+
+WMFont*
+WMDefaultBoldSystemFont(WMScreen *scrPtr)
+{
+    return WMRetainFont(scrPtr->boldFont);
+}
+
+
+static WMFont*
+makeSystemFontOfSize(WMScreen *scrPtr, int size, Bool bold)
+{
+    WMFont *font;
+    char *fontSpec;
+
+#define WConf WINGsConfiguration
+    if (bold) {
+        fontSpec = makeFontSetOfSize(WConf.boldSystemFont, size);
+    } else {
+        fontSpec = makeFontSetOfSize(WConf.systemFont, size);
+    }
+#undef WConf
+
+    if (scrPtr->useMultiByte) {
+        font = WMCreateFontSet(scrPtr, fontSpec);
+    } else {
+        font = WMCreateNormalFont(scrPtr, fontSpec);
+    }
+
+    if (!font) {
+        if (scrPtr->useMultiByte) {
+            wwarning(_("could not load font set %s. Trying fixed."), fontSpec);
+            font = WMCreateFontSet(scrPtr, "fixed");
+            if (!font) {
+                font = WMCreateFontSet(scrPtr, "-*-fixed-medium-r-normal-*-14-*-*-*-*-*-*-*");
+            }
+        } else {
+            wwarning(_("could not load font %s. Trying fixed."), fontSpec);
+            font = WMCreateNormalFont(scrPtr, "fixed");
+        }
+        if (!font) {
+            wwarning(_("could not load fixed font!"));
+            wfree(fontSpec);
+            return NULL;
+        }
+    }
+    wfree(fontSpec);
+
+    return font;
+}
+
+
+WMFont*
+WMSystemFontOfSize(WMScreen *scrPtr, int size)
+{
+    return makeSystemFontOfSize(scrPtr, size, False);
+}
+
+
+WMFont*
+WMBoldSystemFontOfSize(WMScreen *scrPtr, int size)
+{
+    return makeSystemFontOfSize(scrPtr, size, True);
+}
+
+
+XFontSet
+WMGetFontFontSet(WMFont *font)
+{
+    wassertrv(font!=NULL, NULL);
+
+    if (!font->notFontSet && !font->antialiased)
+        return font->font.set;
+
+    return NULL;
+}
+
+
+int
+WMWidthOfString(WMFont *font, char *text, int length)
+{
+    wassertrv(font!=NULL, 0);
+    wassertrv(text!=NULL, 0);
+
+    if (font->notFontSet) {
+        return XTextWidth(font->font.normal, text, length);
+    } else {
+        XRectangle rect;
+        XRectangle AIXsucks;
+
+        XmbTextExtents(font->font.set, text, length, &AIXsucks, &rect);
+
+        return rect.width;
+    }
+}
+
+
+
+void
+WMDrawString(WMScreen *scr, Drawable d, WMColor *color, WMFont *font,
+             int x, int y, char *text, int length)
+{
+    wassertr(font!=NULL);
+
+    if (font->notFontSet) {
+        XSetFont(scr->display, scr->drawStringGC, font->font.normal->fid);
+        XSetForeground(scr->display, scr->drawStringGC, W_PIXEL(color));
+        XDrawString(scr->display, d, scr->drawStringGC, x, y + font->y,
+                    text, length);
+    } else {
+        XSetForeground(scr->display, scr->drawStringGC, W_PIXEL(color));
+        XmbDrawString(scr->display, d, font->font.set, scr->drawStringGC,
+                      x, y + font->y, text, length);
+    }
+}
+
+
+void
+WMDrawImageString(WMScreen *scr, Drawable d, WMColor *color, WMColor *background,
+                  WMFont *font, int x, int y, char *text, int length)
+{
+    wassertr(font!=NULL);
+
+    if (font->notFontSet) {
+        XSetForeground(scr->display, scr->drawImStringGC, W_PIXEL(color));
+        XSetBackground(scr->display, scr->drawImStringGC, W_PIXEL(background));
+        XSetFont(scr->display, scr->drawImStringGC, font->font.normal->fid);
+        XDrawImageString(scr->display, d, scr->drawImStringGC,
+                         x, y + font->y, text, length);
+    } else {
+        XSetForeground(scr->display, scr->drawImStringGC, W_PIXEL(color));
+        XSetBackground(scr->display, scr->drawImStringGC, W_PIXEL(background));
+        XmbDrawImageString(scr->display, d, font->font.set, scr->drawImStringGC,
+                           x, y + font->y, text, length);
+    }
+}
+
+
+
+
+static char*
+makeFontSetOfSize(char *fontset, int size)
+{
+    char font[300], *f;
+    char *newfs = NULL;
+    char *ptr;
+
+    do {
+        char *tmp;
+        int end;
+
+
+        f = fontset;
+        ptr = strchr(fontset, ',');
+        if (ptr) {
+            int count = ptr-fontset;
+
+            if (count > 255) {
+                wwarning(_("font description %s is too large."), fontset);
+            } else {
+                memcpy(font, fontset, count);
+                font[count] = 0;
+                f = (char*)font;
+            }
+        }
+
+        if (newfs)
+            end = strlen(newfs);
+        else
+            end = 0;
+
+        tmp = wmalloc(end + strlen(f) + 8);
+        if (end != 0) {
+            sprintf(tmp, "%s,", newfs);
+            sprintf(tmp + end + 1, f, size);
+        } else {
+            sprintf(tmp + end, f, size);
+        }
+
+        if (newfs)
+            wfree(newfs);
+        newfs = tmp;
+
+        fontset = ptr+1;
+    } while (ptr!=NULL);
+
+    return newfs;
+}
+
+
+#define FONT_PROPS 14
+
+typedef struct {
+    char *props[FONT_PROPS];
+} W_FontAttributes;
+
+
+static void
+changeFontProp(char *buf, char *newprop, int position)
+{
+    char buf2[512];
+    char *ptr, *pptr, *rptr;
+    int count;
+
+    if (buf[0]!='-') {
+        /* // remove warning later. or maybe not */
+        wwarning(_("Invalid font specification: '%s'\n"), buf);
+        return;
+    }
+
+    ptr = pptr = rptr = buf;
+    count = 0;
+    while (*ptr && *ptr!=',') {
+        if (*ptr == '-') {
+            count++;
+            if (count-1==position+1) {
+                rptr = ptr;
+                break;
+            }
+            if (count-1==position) {
+                pptr = ptr+1;
+            }
+        }
+        ptr++;
+    }
+    if (position==FONT_PROPS-1) {
+        rptr = ptr;
+    }
+
+    *pptr = 0;
+    snprintf(buf2, 512, "%s%s%s", buf, newprop, rptr);
+    strcpy(buf, buf2);
+}
+
+
+static WMArray*
+getOptions(char *options)
+{
+    char *ptr, *ptr2, *str;
+    WMArray *result;
+    int count;
+
+    result = WMCreateArrayWithDestructor(2, (WMFreeDataProc*)wfree);
+
+    ptr = options;
+    while (1) {
+        ptr2 = strchr(ptr, ',');
+        if (!ptr2) {
+            WMAddToArray(result, wstrdup(ptr));
+            break;
+        } else {
+            count = ptr2 - ptr;
+            str = wmalloc(count+1);
+            memcpy(str, ptr, count);
+            str[count] = 0;
+            WMAddToArray(result, str);
+            ptr = ptr2 + 1;
+        }
+    }
+
+    return result;
+}
+
+
+#define WFAUnchanged (NULL)
+/* Struct for font change operations */
+typedef struct WMFontAttributes {
+    char *foundry;
+    char *family;
+    char *weight;
+    char *slant;
+    char *setWidth;
+    char *addStyle;
+    char *pixelSize;
+    char *pointSize;
+    char *resolutionX;
+    char *resolutionY;
+    char *spacing;
+    char *averageWidth;
+    char *registry;
+    char *encoding;
+} WMFontAttributes;
+
+WMFont*
+WMCopyFontWithChanges(WMScreen *scrPtr, WMFont *font,
+                      const WMFontAttributes *changes)
+{
+    int index[FONT_PROPS], count[FONT_PROPS];
+    int totalProps, i, j, carry;
+    char fname[512];
+    WMFontFlags fFlags;
+    WMBag *props;
+    WMArray *options;
+    WMFont *result;
+    char *prop;
+
+    snprintf(fname, 512, "%s", font->name);
+
+    fFlags = (font->antialiased ? WFAntialiased : WFNotAntialiased);
+    fFlags |= (font->notFontSet ? WFNormalFont : WFFontSet);
+
+    props = WMCreateBagWithDestructor(1, (WMFreeDataProc*)WMFreeArray);
+
+    totalProps = 0;
+    for (i=0; i<FONT_PROPS; i++) {
+        prop = ((W_FontAttributes*)changes)->props[i];
+        count[i] = index[i] = 0;
+        if (!prop) {
+            /* No change for this property */
+            continue;
+        } else if (strchr(prop, ',')==NULL) {
+            /* Simple option */
+            changeFontProp(fname, prop, i);
+        } else {
+            /* Option with fallback alternatives */
+            if ((changes==WFAEmphasized || changes==WFABoldEmphasized) &&
+                font->antialiased && strcmp(prop, "o,i")==0) {
+                options = getOptions("i,o");
+            } else {
+                options = getOptions(prop);
+            }
+            WMInsertInBag(props, i, options);
+            count[i] = WMGetArrayItemCount(options);
+            if (totalProps==0)
+                totalProps = 1;
+            totalProps = totalProps * count[i];
+        }
+    }
+
+    if (totalProps == 0) {
+        /* No options with fallback alternatives at all */
+        WMFreeBag(props);
+        return WMCreateFontWithFlags(scrPtr, fname, fFlags);
+    }
+
+    for (i=0; i<totalProps; i++) {
+        for (j=0; j<FONT_PROPS; j++) {
+            if (count[j]!=0) {
+                options = WMGetFromBag(props, j);
+                prop = WMGetFromArray(options, index[j]);
+                if (prop) {
+                    changeFontProp(fname, prop, j);
+                }
+            }
+        }
+        result = WMCreateFontWithFlags(scrPtr, fname, fFlags);
+        if (result) {
+            WMFreeBag(props);
+            return result;
+        }
+        for (j=FONT_PROPS-1, carry=1; j>=0; j--) {
+            if (count[j]!=0) {
+                index[j] += carry;
+                carry = (index[j]==count[j]);
+                index[j] %= count[j];
+            }
+        }
+    }
+
+    WMFreeBag(props);
+
+    return NULL;
+}
+
+// should WFANormal also set "normal" or leave it alone?
+static const WMFontAttributes W_FANormal = {
+    WFAUnchanged, WFAUnchanged, "medium,normal,regular", "r", "normal",
+    WFAUnchanged, WFAUnchanged, WFAUnchanged, WFAUnchanged, WFAUnchanged,
+    WFAUnchanged, WFAUnchanged, WFAUnchanged, WFAUnchanged
+};
+
+
+static const WMFontAttributes W_FABold = {
+    WFAUnchanged, WFAUnchanged, "bold", WFAUnchanged,
+    WFAUnchanged, WFAUnchanged, WFAUnchanged, WFAUnchanged, WFAUnchanged,
+    WFAUnchanged, WFAUnchanged, WFAUnchanged, WFAUnchanged, WFAUnchanged
+};
+
+
+static const WMFontAttributes W_FANotBold = {
+    WFAUnchanged, WFAUnchanged, "medium,normal,regular", WFAUnchanged,
+    WFAUnchanged, WFAUnchanged, WFAUnchanged, WFAUnchanged, WFAUnchanged,
+    WFAUnchanged, WFAUnchanged, WFAUnchanged, WFAUnchanged, WFAUnchanged
+};
+
+
+static const WMFontAttributes W_FAEmphasized = {
+    WFAUnchanged, WFAUnchanged, WFAUnchanged, "o,i",
+    WFAUnchanged, WFAUnchanged, WFAUnchanged, WFAUnchanged, WFAUnchanged,
+    WFAUnchanged, WFAUnchanged, WFAUnchanged, WFAUnchanged, WFAUnchanged
+};
+
+
+static const WMFontAttributes W_FANotEmphasized = {
+    WFAUnchanged, WFAUnchanged, WFAUnchanged, "r",
+    WFAUnchanged, WFAUnchanged, WFAUnchanged, WFAUnchanged, WFAUnchanged,
+    WFAUnchanged, WFAUnchanged, WFAUnchanged, WFAUnchanged, WFAUnchanged
+};
+
+
+static const WMFontAttributes W_FABoldEmphasized = {
+    WFAUnchanged, WFAUnchanged, "bold", "o,i",
+    WFAUnchanged, WFAUnchanged, WFAUnchanged, WFAUnchanged, WFAUnchanged,
+    WFAUnchanged, WFAUnchanged, WFAUnchanged, WFAUnchanged, WFAUnchanged
+};
+
+
+const WMFontAttributes *WFANormal         = &W_FANormal;
+const WMFontAttributes *WFABold           = &W_FABold;
+const WMFontAttributes *WFANotBold        = &W_FANotBold;
+const WMFontAttributes *WFAEmphasized     = &W_FAEmphasized;
+const WMFontAttributes *WFANotEmphasized  = &W_FANotEmphasized;
+const WMFontAttributes *WFABoldEmphasized = &W_FABoldEmphasized;
+
+
+#endif
+

WINGs/widgets.c

@@ -12,6 +12,8 @@
 #include <X11/keysym.h>
 #include <X11/cursorfont.h>
 
+#include <X11/Xlocale.h>
+
 /********** data ************/
 
 
@@ -591,6 +593,7 @@ WMCreateScreenWithRContext(Display *display, int screen, RContext *context)
         "WM_STATE"
     };
     Atom atoms[sizeof(atomNames)/sizeof(char*)];
+    char *locale;
     int i;
 
     if (!initialized) {
@@ -756,16 +759,20 @@ WMCreateScreenWithRContext(Display *display, int screen, RContext *context)
     scrPtr->stipple = stipple;
 
     scrPtr->useMultiByte = WINGsConfiguration.useMultiByte;
+    scrPtr->useMultiByte = 0;
 
-    scrPtr->useWideChar = 1;
+    locale = setlocale(LC_CTYPE, NULL);
+    //printf("LC_CTYPE=%s\n", locale);
+    if (!locale || strcmp(locale, "C")==0 || strcmp(locale, "POSIX")==0)
+        scrPtr->useWideChar = 0;
+    else
+        scrPtr->useWideChar = 1;
 
     scrPtr->antialiasedText = WINGsConfiguration.antialiasedText;
 
-    scrPtr->normalFont = WMSystemFontOfSize(scrPtr,
+    scrPtr->normalFont = WMSystemFontOfSize(scrPtr, 0);
-                                            WINGsConfiguration.defaultFontSize);
 
-    scrPtr->boldFont = WMBoldSystemFontOfSize(scrPtr,
+    scrPtr->boldFont = WMBoldSystemFontOfSize(scrPtr, 0);
-                                              WINGsConfiguration.defaultFontSize);
 
     if (!scrPtr->boldFont)
         scrPtr->boldFont = scrPtr->normalFont;

WINGs/winputmethod.c

@@ -22,7 +22,8 @@ typedef struct W_ICContext {
 
 
 
-Bool W_InitIMStuff(WMScreen *scr)
+Bool
+W_InitIMStuff(WMScreen *scr)
 {
     WMIMContext *ctx;
     
@@ -38,7 +39,8 @@ Bool W_InitIMStuff(WMScreen *scr)
 }
 
 
-void W_CloseIMStuff(WMScreen *scr)
+void
+W_CloseIMStuff(WMScreen *scr)
 {
     if (!scr->imctx) 
 	return;
@@ -51,7 +53,8 @@ void W_CloseIMStuff(WMScreen *scr)
 
 
 
-WMICContext *W_CreateIC(WMView *view)
+WMICContext*
+W_CreateIC(WMView *view)
 {
     WMScreen *scr = W_VIEW_SCREEN(view);
     WMICContext *ctx;
@@ -60,11 +63,12 @@ WMICContext *W_CreateIC(WMView *view)
     ctx->next = scr->imctx->icList;
     if (scr->imctx->icList)
 	scr->imctx->icList->prev = ctx;
-    scr->imctx = ctx;
+    //scr->imctx = ctx;
 }
 
 
-void W_DestroyIC(WMICContext *ctx)
+void
+W_DestroyIC(WMICContext *ctx)
 {
     XDestroyIC(ctx->xic);
     
@@ -72,8 +76,9 @@ void W_DestroyIC(WMICContext *ctx)
 }
 
 
-int W_LookupString(WMView *view, XKeyEvent *event,
+int
-		   char buffer, int bufsize, KeySym ksym)
+W_LookupString(WMView *view, XKeyEvent *event,
+               char buffer, int bufsize, KeySym ksym)
 {
     
 }

WINGs/wmisc.c

@@ -120,6 +120,7 @@ fitText(char *text, WMFont *font, int width, int wrap)
 		i = j;
 	}
     } else {
+        //i = strcspn(text, "\n\r");
 	while (text[i]!='\n' && text[i]!=0)
 	    i++;
     }

WINGs/wscroller.c

@@ -309,7 +309,6 @@ paintArrow(WMScroller *sPtr, Drawable d, int part)
 
 
     if (sPtr->flags.horizontal) {
-	    
 	/* paint button */
 #ifndef DOUBLE_BUFFER
 	XFillRectangle(scr->display, d, gc,

WPrefs.app/Expert.c

@@ -84,7 +84,7 @@ createPanel(Panel *p)
     WMSetButtonText(panel->swi[7], _("Smooth font edges (needs restart)."));
 
     //if (!WMHasAntialiasingSupport(WMWidgetScreen(panel->box)))
-        WMSetButtonEnabled(panel->swi[7], False);
+        WMSetButtonEnabled(panel->swi[7], True);
 
     WMRealizeWidget(panel->box);
     WMMapSubwidgets(panel->box);

WPrefs.app/Font.c

@@ -23,7 +23,7 @@
 
 #include "WPrefs.h"
 #include <X11/Xlocale.h>
-
+#include <ctype.h>
 
 typedef struct _Panel {
     WMBox *box;
@@ -358,7 +358,7 @@ paintItems(WMScreen *scr, Drawable d, WMColor *color, WMFont *font,
     int l = strlen(text);
 	int x = previewPositions[part].pos.x;
 	int y = previewPositions[part].pos.y;
-	int w = previewPositions[part].size.width;
+	//int w = previewPositions[part].size.width;
 	int h = previewPositions[part].size.height/4;
 	int i;
 	for( i = 0; i < 4 ; i++) {
@@ -443,7 +443,7 @@ dumpRImage(char *path, RImage *image)
     }
 }
 
-static int
+/*static int
 isPixmap(WMPropList *prop)
 {
     WMPropList *p;
@@ -455,7 +455,7 @@ isPixmap(WMPropList *prop)
 	return 1;
     else
 	return 0;
-}
+}*/
 
 static Pixmap
 renderTexture(WMScreen *scr, WMPropList *texture, int width, int height,
@@ -669,7 +669,7 @@ renderMenu(_Panel *panel, WMPropList *texture, int width, int iheight)
     WMScreen *scr = WMWidgetScreen(panel->parent);
     Display *dpy = WMScreenDisplay(scr);
     Pixmap pix, tmp;
-    RContext *rc = WMScreenRContext(scr);
+    //RContext *rc = WMScreenRContext(scr);
     GC gc = XCreateGC(dpy, WMWidgetXID(panel->parent), 0, NULL);
     int i;
 
@@ -835,7 +835,7 @@ paintPreviewBox(Panel *panel, int elements)
 {
     WMScreen *scr = WMWidgetScreen(panel->parent);
     Display *dpy = WMScreenDisplay(scr);
-	int refresh = 0;
+	//int refresh = 0;
 	GC gc;
 	WMColor *black = WMBlackColor(scr);
 	Pixmap mitem;
@@ -926,7 +926,7 @@ static void
 paintTextField(void *data, int section)
 {
 	_Panel *panel = (_Panel*)data;
-	char *sample = NULL;
+	//char *sample = NULL;
 	int encoding;
 	encoding = WMGetPopUpButtonSelectedItem(panel->langP);
 	WMSetTextFieldFont(panel->fontT, getFontForPreview(panel, section));
@@ -1072,7 +1072,7 @@ refillFontSetList(void *data)
 	char *encoding = getFontEncoding(panel);
 	int section = WMGetPopUpButtonSelectedItem(panel->fontSel);
 	int i;
-	int pos;
+	//int pos;
 	WMClearList(panel->fsetLs);
 	if(!encoding) {
 	array = getCurrentFontProp(panel, section);
@@ -1259,7 +1259,7 @@ static void
 changeLanguageAction(WMWidget *w, void *data)
 {
     Panel *panel = (Panel*)data;
-    WMScreen *scr = WMWidgetScreen(panel->box);
+    //WMScreen *scr = WMWidgetScreen(panel->box);
 	int section;
 
 	section = WMGetPopUpButtonSelectedItem(w);
@@ -1314,7 +1314,7 @@ static char*
 getFontSampleString(void *data)
 {
 	_Panel *panel = (_Panel*)data;
-    WMScreen *scr = WMWidgetScreen(panel->box);
+    //WMScreen *scr = WMWidgetScreen(panel->box);
     WMMenuItem *mi;
     WMPropList *pl;
 	int section;
@@ -1336,7 +1336,7 @@ static char*
 getFontEncoding(void *data)
 {
 	_Panel *panel = (_Panel*)data;
-    WMScreen *scr = WMWidgetScreen(panel->box);
+    //WMScreen *scr = WMWidgetScreen(panel->box);
     WMMenuItem *mi;
     WMPropList *pl;
 	int section;
@@ -1358,7 +1358,7 @@ static Bool
 isEncodingMultiByte(void *data)
 {
 	_Panel *panel = (_Panel*)data;
-    WMScreen *scr = WMWidgetScreen(panel->box);
+    //WMScreen *scr = WMWidgetScreen(panel->box);
     WMMenuItem *mi;
     WMPropList *pl;
 	int section;
@@ -1473,26 +1473,20 @@ getDefaultSystemFont(void *data, int element)
 {
     _Panel *panel = (_Panel*)data;
     WMScreen *scr = WMWidgetScreen(panel->box);
-	switch(element) {
+
-		case 0:
+    switch(element) {
-			return WMBoldSystemFontOfSize(scr, 12);
+    case 0:
-			break;
+    case 2:
-		case 1:
+        return WMBoldSystemFontOfSize(scr, 12);
-			return WMBoldSystemFontOfSize(scr, 24);
+    case 1:
-			break;
+        return WMBoldSystemFontOfSize(scr, 24);
-		case 2:
+    case 4:
-			return WMBoldSystemFontOfSize(scr, 12);
+    case 5:
-			break;
+        return WMSystemFontOfSize(scr, 8);
-		case 3:
+    case 3:
-			return WMSystemFontOfSize(scr, 12);
+    default:
-			break;
+        return WMSystemFontOfSize(scr, 12);
-		case 4:
+    }
-			return WMSystemFontOfSize(scr, 8);
-			break;
-		case 5:
-			return WMSystemFontOfSize(scr, 8);
-			break;
-	}
 }
 
 static void
@@ -1515,7 +1509,7 @@ static void
 toggleAA(WMWidget *w, void *data)
 {
 	_Panel *panel = (_Panel*)data;
-	int section;
+	//int section;
 	if(panel->AntialiasedText)
 		panel->AntialiasedText = False;
 	else
@@ -1622,7 +1616,7 @@ addButtonAction(WMWidget *w, void *data)
 	array = getDefaultFontProp(panel, encoding, section);
 
 	WMHideFontPanel(panel->fontPanel);
-	chosenFont = WMGetFontPanelFontName(panel->fontPanel);
+	chosenFont = WMGetFontName(WMGetFontPanelFont(panel->fontPanel));
 	string = WMCreatePLString(chosenFont);
 	pos = WMGetListSelectedItemRow(panel->fsetLs);
 	WMInsertListItem(panel->fsetLs, pos+1, chosenFont);
@@ -1651,7 +1645,7 @@ changeButtonAction(WMWidget *w, void *data)
 
 	WMHideFontPanel(panel->fontPanel);
 
-	chosenFont = WMGetFontPanelFontName(panel->fontPanel);
+	chosenFont = WMGetFontName(WMGetFontPanelFont(panel->fontPanel));
 	string = WMCreatePLString(chosenFont);
 
 	pos = WMGetListSelectedItemRow(panel->fsetLs);
@@ -1720,7 +1714,7 @@ removeButtonClick(WMWidget *w, void *data)
 static void
 showData(_Panel *panel)
 {
-    WMScreen *scr = WMWidgetScreen(panel->parent);
+    //WMScreen *scr = WMWidgetScreen(panel->parent);
     char *str;
 	int i;
 

WPrefs.app/Makefile.am

@@ -42,7 +42,9 @@ WPrefs_SOURCES = \
 	imagebrowser.h \
 	xmodifier.c
 
-AM_CPPFLAGS = @CPPFLAGS@ -DLOCALEDIR=\"$(NLSDIR)\"
+AM_CPPFLAGS = -DLOCALEDIR=\"$(NLSDIR)\"
+
+AM_CFLAGS = -fno-strict-aliasing
 
 INCLUDES = -I$(top_srcdir)/wrlib -I$(top_srcdir)/WINGs @HEADER_SEARCH_PATH@ 
 

acinclude.m4

@@ -24,6 +24,42 @@ CPPFLAGS="$CPPFLAGS_old"
 ])
 
 
+dnl
+dnl WM_CHECK_XFT_VERSION(MIN_VERSION, [ACTION-IF-FOUND [,ACTION-IF-NOT-FOUND]])
+dnl
+dnl # $XFTFLAGS should be defined before calling this macro,
+dnl # else it will not be able to find Xft.h
+dnl
+AC_DEFUN(WM_CHECK_XFT_VERSION,
+[
+CPPFLAGS_old="$CPPFLAGS"
+CPPFLAGS="$CPPFLAGS $XFTFLAGS $inc_search_path"
+xft_major_version=`echo $1 | sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\1/'`
+xft_minor_version=`echo $1 | sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\2/'`
+xft_micro_version=`echo $1 | sed 's/\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\)/\3/'`
+AC_MSG_CHECKING([whether libXft is at least version $1])
+AC_CACHE_VAL(ac_cv_lib_xft_version_ok,
+[AC_TRY_LINK(
+[/* Test version of libXft we have */
+#include <X11/Xft/Xft.h>
+
+#if !defined(XFT_VERSION) || XFT_VERSION < $xft_major_version*10000 + $xft_minor_version*100 + $xft_micro_version
+#error libXft on this system is too old. Consider upgrading to at least $1
+#endif
+], [], 
+eval "ac_cv_lib_xft_version_ok=yes", 
+eval "ac_cv_lib_xft_version_ok=no")])
+if eval "test \"`echo '$ac_cv_lib_xft_version_ok'`\" = yes"; then
+  AC_MSG_RESULT(yes)
+  ifelse([$2], , :, [$2])
+else
+  AC_MSG_RESULT(no)
+  ifelse([$3], , , [$3])
+fi
+CPPFLAGS="$CPPFLAGS_old"
+])
+
+
 dnl
 dnl WM_CHECK_REDCRAP_BUGS(prefix,bindir,libdir)
 dnl

configure.ac

@@ -15,7 +15,7 @@ AC_INIT(src/WindowMaker.h)
 
 
 
-AM_INIT_AUTOMAKE(WindowMaker, 0.90.0)
+AM_INIT_AUTOMAKE(WindowMaker, 0.85.0)
 
 AC_PROG_LIBTOOL
 
@@ -519,35 +519,54 @@ fi
 
 dnl Xft antialiased font support
 dnl ============================
+
 xft=yes
 XFTLIBS=""
-AC_ARG_ENABLE(xft, 
-[  --disable-xft           disable Xft antialiased font support],
-		xft=$enableval, xft=yes)
 
-if test "$xft" = yes; then
+if test "x$PKGCONFIG" != x -a "`$PKGCONFIG xft; echo $?`" = 0; then
-	if test "x$PKGCONFIG" != x -a "`$PKGCONFIG xft; echo $?`" = 0; then
+        XFTCONFIG="$PKGCONFIG xft"
-		XFTCONFIG="$PKGCONFIG xft"
+        pkgconfig_xft=yes
-		pkgconfig_xft=yes
+else
-	else
+        AC_CHECK_PROG(XFTCONFIG, xft-config, xft-config)
-		AC_CHECK_PROG(XFTCONFIG, xft-config, xft-config)
-	fi
-	AC_MSG_CHECKING([for the Xft2 library])
-	if test "x$XFTCONFIG" != x; then
-		XFTLIBS=`$XFTCONFIG --libs`
-		XFTFLAGS=`$XFTCONFIG --cflags`
-		AC_MSG_RESULT([found])
-	else
-		xft=no
-		AC_MSG_RESULT([not found])
-	fi
-	if test "$xft" = yes; then
-		AC_SUBST(XFTFLAGS)
-		AC_SUBST(XFTLIBS)
-		AC_DEFINE(XFT, 1, [define if you want support for antialiased fonts (set by configure)])
-	fi
 fi
 
+AC_MSG_CHECKING([for the Xft2 library])
+
+if test "x$XFTCONFIG" != x; then
+        XFTLIBS=`$XFTCONFIG --libs`
+        XFTFLAGS=`$XFTCONFIG --cflags`
+        AC_MSG_RESULT([found])
+else
+        AC_MSG_RESULT([not found])
+        echo
+        echo "ERROR!!! libXft2 is not installed or could not be found."
+        echo "         Xft2 is a requirement for building Window Maker."
+        echo "         Please install it (along with fontconfig) before continuing."
+        echo
+        exit 1
+fi
+
+minXFT="2.1.2"
+goodxft="no"
+
+dnl
+dnl The macro below will use $XFTFLAGS (defined above) to find Xft.h
+dnl
+WM_CHECK_XFT_VERSION($minXFT, goodxft=yes, goodxft=no)
+
+if test "$goodxft" = no; then
+        echo
+        echo "ERROR!!! libXft on this system is an old version."
+        echo "         Please consider upgrading to at least version ${minXFT}."
+        echo
+        exit 1
+fi
+
+AC_SUBST(XFTFLAGS)
+AC_SUBST(XFTLIBS)
+AC_DEFINE(XFT, 1, [define if you want support for antialiased fonts (set by configure)])
+
+
 dnl XINERAMA support
 dnl ================
 xinerama=no

src/Makefile.am

@@ -104,7 +104,9 @@ wmaker_SOURCES = 	\
 	text.h 
 
 
-AM_CPPFLAGS = @CPPFLAGS@ $(DFLAGS) -DLOCALEDIR=\"$(NLSDIR)\"
+AM_CPPFLAGS = $(DFLAGS) -DLOCALEDIR=\"$(NLSDIR)\"
+
+AM_CFLAGS = -fno-strict-aliasing
 
 
 INCLUDES = \

src/appicon.c

@@ -407,7 +407,7 @@ setIconCallback(WMenu *menu, WMenuEntry *entry)
     result = wIconChooserDialog(scr, &file, icon->wm_instance, icon->wm_class);
 
     if (result && !icon->destroyed) {
-	if (file[0]==0) {
+	if (file && *file==0) {
 	    wfree(file);
 	    file = NULL;
 	}

src/cycling.c

@@ -198,7 +198,9 @@ StartWindozeCycle(WWindow *wwin, XEvent *event, Bool next)
     if (hasModifier) {
 	keymap = XGetModifierMapping(dpy);
 
-    
+#ifdef DEBUG
+        printf("Grabbing keyboard\n");
+#endif
 	XGrabKeyboard(dpy, scr->root_win, False, GrabModeAsync, GrabModeAsync, 
 		      CurrentTime);
     }
@@ -223,11 +225,6 @@ StartWindozeCycle(WWindow *wwin, XEvent *event, Bool next)
     wWindowFocus(newFocused, scr->focused_window);
     oldFocused = newFocused;
 
-    if (hasModifier)
-	done = False;
-    else
-	done = True;
-    
 #if 0
     if (wPreferences.popup_switchmenu && 
 	(!scr->switch_menu || !scr->switch_menu->flags.mapped)) {
@@ -236,8 +233,9 @@ StartWindozeCycle(WWindow *wwin, XEvent *event, Bool next)
 	openedSwitchMenu = True;
     }
 #endif
-    while (!done) {
+
-	WMMaskEvent(dpy,KeyPressMask|KeyReleaseMask|ExposureMask, &ev);
+    while (hasModifier && !done) {
+	WMMaskEvent(dpy, KeyPressMask|KeyReleaseMask|ExposureMask, &ev);
 
 	if (ev.type != KeyRelease && ev.type != KeyPress) {
 	    WMHandleEvent(&ev);
@@ -247,7 +245,10 @@ StartWindozeCycle(WWindow *wwin, XEvent *event, Bool next)
 	modifiers = ev.xkey.state & ValidModMask;
 
 	if (ev.type == KeyPress) {
-	    if (wKeyBindings[WKBD_FOCUSNEXT].keycode == ev.xkey.keycode
+#ifdef DEBUG
+            printf("Got key press\n");
+#endif
+            if (wKeyBindings[WKBD_FOCUSNEXT].keycode == ev.xkey.keycode
 		&& wKeyBindings[WKBD_FOCUSNEXT].modifier == modifiers) {
 
 		newFocused = nextToFocusAfter(newFocused);
@@ -274,12 +275,18 @@ StartWindozeCycle(WWindow *wwin, XEvent *event, Bool next)
 		}
 
 	    } else {
+#ifdef DEBUG
+                printf("Got something else\n");
+#endif
 		somethingElse = True;
 		done = True;
 	    }
 	} else if (ev.type == KeyRelease) {
 	    int i;
 
+#ifdef DEBUG
+            printf("Got key release\n");
+#endif
 	    for (i = 0; i < 8 * keymap->max_keypermod; i++) {
 		if (keymap->modifiermap[i] == ev.xkey.keycode &&
 		    wKeyBindings[WKBD_FOCUSNEXT].modifier 
@@ -294,6 +301,9 @@ StartWindozeCycle(WWindow *wwin, XEvent *event, Bool next)
 	XFreeModifiermap(keymap);
 
     if (hasModifier) {
+#ifdef DEBUG
+        printf("Ungrabbing keyboard\n");
+#endif
 	XUngrabKeyboard(dpy, CurrentTime);
     }
     wSetFocusTo(scr, newFocused);

src/dialog.c

@@ -636,6 +636,7 @@ wIconChooserDialog(WScreen *scr, char **file, char *instance, char *class)
     IconPanel *panel;
     WMColor *color;
     WMFont *boldFont;
+    Bool result;
 
     panel = wmalloc(sizeof(IconPanel));
     memset(panel, 0, sizeof(IconPanel));
@@ -784,7 +785,7 @@ wIconChooserDialog(WScreen *scr, char **file, char *instance, char *class)
 	/* check if the file the user selected is not the one that
 	 * would be loaded by default with the current search path */
 	*file = WMGetListSelectedItem(panel->iconList)->text;
-	if ((*file)[0]==0) {
+	if (**file==0) {
 	    wfree(*file);
 	    *file = NULL;
 	} else {
@@ -803,6 +804,8 @@ wIconChooserDialog(WScreen *scr, char **file, char *instance, char *class)
 	*file = NULL;
     }
 
+    result = panel->result;
+
     WMReleaseFont(panel->normalfont);
 
     WMUnmapWidget(panel->win);
@@ -815,7 +818,7 @@ wIconChooserDialog(WScreen *scr, char **file, char *instance, char *class)
 
     XDestroyWindow(dpy, parent);
 
-    return panel->result;
+    return result;
 }
 
 
@@ -862,6 +865,10 @@ typedef struct {
      "Copyright \xa9 1997-2003 Alfredo K. Kojima <kojima@windowmaker.org>\n"\
      "Copyright \xa9 1998-2003 Dan Pascu <dan@windowmaker.org>"
 
+#define COPYRIGHT_TEXT_UTF8  \
+     "Copyright \xc2\xa9 1997-2003 Alfredo K. Kojima <kojima@windowmaker.org>\n"\
+     "Copyright \xc2\xa9 1998-2003 Dan Pascu <dan@windowmaker.org>"
+
 
 
 static InfoPanel *thePanel = NULL;
@@ -1310,7 +1317,7 @@ wShowInfoPanel(WScreen *scr)
     WMResizeWidget(panel->copyrL, 360, 40);
     WMMoveWidget(panel->copyrL, 15, 185);
     WMSetLabelTextAlignment(panel->copyrL, WALeft);
-    WMSetLabelText(panel->copyrL, COPYRIGHT_TEXT);
+    WMSetLabelText(panel->copyrL, COPYRIGHT_TEXT_UTF8);
     /* we want the (c) character in the font, so don't use a FontSet here */
     // fix this -Dan font = WMCreateFontWithFlags(scr->wmscreen, "SystemFont-11", WFNormalFont);
     font = WMSystemFontOfSize(scr->wmscreen, 11);

src/event.c

@@ -478,7 +478,7 @@ handleMapRequest(XEvent *ev)
     Window window = ev->xmaprequest.window;
 
 #ifdef DEBUG
-    L("got map request for %x\n", (unsigned)window);
+    printf("got map request for %x\n", (unsigned)window);
 #endif
     if ((wwin = wWindowFor(window))) {
 	if (wwin->flags.shaded) {
@@ -553,7 +553,7 @@ handleDestroyNotify(XEvent *event)
     int index;
 
 #ifdef DEBUG
-    L("got destroy notify");
+    printf("got destroy notify\n");
 #endif
     wwin = wWindowFor(window);
     if (wwin) {
@@ -607,7 +607,7 @@ handleExpose(XEvent *event)
     XEvent ev;
 
 #ifdef DEBUG
-    L("got expose");
+    printf("got expose\n");
 #endif
     while (XCheckTypedWindowEvent(dpy, event->xexpose.window, Expose, &ev));
 
@@ -662,7 +662,7 @@ handleButtonPress(XEvent *event)
     WScreen *scr;
     
 #ifdef DEBUG
-    L("got button press");
+    printf("got button press\n");
 #endif
     scr = wScreenForRootWindow(event->xbutton.root);
     
@@ -749,7 +749,7 @@ handleMapNotify(XEvent *event)
 {
     WWindow *wwin;
 #ifdef DEBUG
-    L("got map");
+    printf("got map\n");
 #endif
     wwin = wWindowFor(event->xmap.event);
     if (wwin && wwin->client_win == event->xmap.event) {
@@ -772,7 +772,7 @@ handleUnmapNotify(XEvent *event)
     XEvent ev;
     Bool withdraw = False;
 #ifdef DEBUG
-    L("got unmap");
+    printf("got unmap\n");
 #endif
     /* only process windows with StructureNotify selected 
      * (ignore SubstructureNotify) */
@@ -824,7 +824,7 @@ handleConfigureRequest(XEvent *event)
 {
     WWindow *wwin;
 #ifdef DEBUG
-    L("got configure request");
+    printf("got configure request\n");
 #endif
     if (!(wwin=wWindowFor(event->xconfigurerequest.window))) {
 	/*
@@ -847,7 +847,7 @@ handlePropertyNotify(XEvent *event)
     unsigned int ju;
     WScreen *scr;
 #ifdef DEBUG
-    L("got property notify");
+    printf("got property notify\n");
 #endif
     if ((wwin=wWindowFor(event->xproperty.window))) {
 	if (!XGetGeometry(dpy, wwin->client_win, &jr, &ji, &ji,
@@ -876,7 +876,7 @@ handleClientMessage(XEvent *event)
     WWindow *wwin;
     WObjDescriptor *desc;
 #ifdef DEBUG
-    L("got client message");
+    printf("got client message\n");
 #endif
     /* handle transition from Normal to Iconic state */
     if (event->xclient.message_type == _XA_WM_CHANGE_STATE
@@ -1038,7 +1038,7 @@ handleEnterNotify(XEvent *event)
     XEvent ev;
     WScreen *scr = wScreenForRootWindow(event->xcrossing.root);
 #ifdef DEBUG
-    L("got enter notify");
+    printf("got enter notify\n");
 #endif
 
 #ifdef VIRTUAL_DESKTOP
@@ -1178,7 +1178,7 @@ handleShapeNotify(XEvent *event)
     WWindow *wwin;
     XEvent ev;
 #ifdef DEBUG
-    L("got shape notify");
+    printf("got shape notify\n");
 #endif
     while (XCheckTypedWindowEvent(dpy, shev->window, event->type, &ev)) {
 	XShapeEvent *sev = (XShapeEvent*)&ev;
@@ -1739,7 +1739,7 @@ handleMotionNotify(XEvent *event)
 	    p.y >= (rect.pos.y + rect.size.height - 2)) {
     	    WMenu *menu;
 #ifdef DEBUG
-            L("pointer at screen edge");
+            printf("pointer at screen edge\n");
 #endif
             menu = wMenuUnderPointer(scr);
             if (menu!=NULL)

src/main.c

@@ -717,22 +717,25 @@ main(int argc, char **argv)
     }
 
 
-    if (!Locale) {
+    if (Locale) {
-	Locale = getenv("LC_ALL");
+        /* return of wstrconcat should not be free-ed! read putenv man page */
-    }
+        putenv(wstrconcat("LANG=", Locale));
-    if (!Locale) {
+    } else {
-    	Locale = getenv("LANG");
+        Locale = getenv("LC_ALL");
+        if (!Locale) {
+            Locale = getenv("LANG");
+        }
     }
 
     setlocale(LC_ALL, "");
 
     if (!Locale || strcmp(Locale, "C")==0 || strcmp(Locale, "POSIX")==0) 
-      Locale = NULL;
+        Locale = NULL;
 #ifdef I18N
     if (getenv("NLSPATH"))
-      bindtextdomain("WindowMaker", getenv("NLSPATH"));
+        bindtextdomain("WindowMaker", getenv("NLSPATH"));
     else
-      bindtextdomain("WindowMaker", LOCALEDIR);
+        bindtextdomain("WindowMaker", LOCALEDIR);
     textdomain("WindowMaker");
 
     if (!XSupportsLocale()) {

src/placement.c

@@ -349,7 +349,7 @@ smartPlaceWindow(WWindow *wwin, int *x_ret, int *y_ret,
                  unsigned int width, unsigned int height,
 		 WArea usableArea)
 {
-    WScreen *scr = wwin->screen_ptr;
+    //WScreen *scr = wwin->screen_ptr;
     int test_x = 0, test_y = Y_ORIGIN(scr);
     int from_x, to_x, from_y, to_y;
     int sx;

src/text.c

@@ -28,6 +28,7 @@
 #include <X11/Xutil.h>
 #include <X11/keysym.h>
 #include <stdlib.h>
+#include <string.h>
 #include <ctype.h>
 
 #include "WindowMaker.h"
@@ -42,14 +43,14 @@
 #endif
 
 
-#if 0
+#ifdef DEBUG
 #  define  ENTER(X)  fprintf(stderr,"Entering:  %s()\n", X);
 #  define  LEAVE(X)  fprintf(stderr,"Leaving:   %s()\n", X);
-#  define  DEBUG(X)  fprintf(stderr,"debug:     %s()\n", X);
+#  define  PDEBUG(X)  fprintf(stderr,"debug:     %s()\n", X);
 #else
 #  define  ENTER(X)
 #  define  LEAVE(X)
-#  define  DEBUG(X)
+#  define  PDEBUG(X)
 #endif
 
 extern Cursor wCursor[WCUR_LAST];
@@ -582,32 +583,32 @@ textEventHandler( WObjDescriptor *desc, XEvent *event )
        * text so we can wTextRefresh() */
       if( event->xmotion.state & (Button1Mask|Button3Mask|Button2Mask) )
       {
-      DEBUG("MotionNotify");
+      PDEBUG("MotionNotify");
       handled = True;
       wtext->text.endPos = textXtoPos( wtext, event->xmotion.x );
       }
       break;
 
     case ButtonPress:
-      DEBUG("ButtonPress");
+      PDEBUG("ButtonPress");
       handled = True;
       wtext->text.startPos = textXtoPos( wtext, event->xbutton.x );
       wtext->text.endPos   = wtext->text.startPos;
       break;
 
     case ButtonRelease:
-      DEBUG("ButtonRelease");
+      PDEBUG("ButtonRelease");
       handled = True;
       wtext->text.endPos = textXtoPos( wtext, event->xbutton.x );
       break;
 
     case KeyPress:
-      DEBUG("KeyPress");
+      PDEBUG("KeyPress");
       handled = handleKeyPress( wtext, &event->xkey );
       break;
 
     case EnterNotify:
-      DEBUG("EnterNotify");
+      PDEBUG("EnterNotify");
       handled = True;
 #if 0
       if (!wtext->magic) 
@@ -621,7 +622,7 @@ textEventHandler( WObjDescriptor *desc, XEvent *event )
       break;
 
     case LeaveNotify:
-      DEBUG("LeaveNotify");
+      PDEBUG("LeaveNotify");
       handled = True;
 #if 0
       wtext->blinking = 0;

src/xdnd.c

@@ -86,7 +86,7 @@ void wXDNDMakeAwareness(Window window) {
 }
 
 void wXDNDClearAwareness(Window window) {
-    long int xdnd_version = 3;
+    //long int xdnd_version = 3;
     XDeleteProperty (dpy, window, _XA_XdndAware);
 }
 

src/xutil.c

@@ -24,6 +24,7 @@
 #include <X11/Xutil.h>
 #include <X11/Xatom.h>
 #include <stdio.h>
+#include <string.h>
 
 #include "wconfig.h"
 

test/wtest.c

@@ -9,6 +9,7 @@
  */
 
 #include <stdio.h>
+#include <stdlib.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/Xproto.h>

util/Makefile.am

@@ -3,9 +3,10 @@ AUTOMAKE_OPTIONS = no-dependencies
 
 pkgdatadir  = $(datadir)/@PACKAGE@
 
-bin_PROGRAMS = wxcopy wxpaste wdwrite wdread getstyle setstyle seticons geticonset wmsetbg wmsetup wmagnify
+bin_PROGRAMS = wxcopy wxpaste wdwrite wdread getstyle setstyle convertfonts \
+	seticons geticonset wmsetbg wmsetup wmagnify
 
-bin_SCRIPTS = wmaker.inst wm-oldmenu2new wsetfont wmchlocale wkdemenu.pl\
+bin_SCRIPTS = wmaker.inst wm-oldmenu2new wsetfont wmchlocale wkdemenu.pl \
 	wcopy wpaste
 
 EXTRA_DIST = wmaker.inst.in bughint wm-oldmenu2new wsetfont directjpeg.c \
@@ -31,6 +32,8 @@ setstyle_LDADD = \
 	$(top_builddir)/WINGs/libWUtil.a \
 	@XLFLAGS@ @XLIBS@ $(liblist)
 
+convertfonts_LDADD = $(top_builddir)/WINGs/libWUtil.a $(liblist)
+
 seticons_LDADD= $(top_builddir)/WINGs/libWUtil.a $(liblist)
 
 geticonset_LDADD= $(top_builddir)/WINGs/libWUtil.a $(liblist)

util/convertfonts.c

@@ -0,0 +1,317 @@
+/* convertfonts.c - converts fonts in a style file to fontconfig format
+ *
+ *  WindowMaker window manager
+ *
+ *  Copyright (c) 2004 Dan Pascu
+ *
+ *  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., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
+ *  USA.
+ */
+
+
+#define PROG_VERSION "convertfonts (Window Maker) 1.0"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/stat.h>
+#include <string.h>
+#include <WINGs/WUtil.h>
+
+#include "../src/wconfig.h"
+
+#define DEFAULT_FONT "sans-serif:pixelsize=12"
+
+char *FontOptions[] = {
+    "IconTitleFont",
+    "ClipTitleFont",
+    "DisplayFont",
+    "LargeDisplayFont",
+    "MenuTextFont",
+    "MenuTitleFont",
+    "WindowTitleFont",
+    "SystemFont",
+    "BoldSystemFont",
+    NULL
+};
+
+
+char *ProgName;
+
+
+static int
+countChar(char *str, char c)
+{
+    int count = 0;
+
+    if (!str)
+        return 0;
+
+    for (; *str!=0; str++) {
+        if (*str == c) {
+            count++;
+        }
+    }
+
+    return count;
+}
+
+
+typedef struct str {
+    char *str;
+    int len;
+} str;
+
+#define XLFD_TOKENS 14
+
+
+static str*
+getXLFDTokens(char *xlfd)
+{
+    static str tokens[XLFD_TOKENS];
+    int i, len, size;
+    char *ptr;
+
+    if (!xlfd || *xlfd!='-' || countChar(xlfd, '-')<XLFD_TOKENS)
+        return NULL;
+
+    memset(tokens, 0, sizeof(str)*XLFD_TOKENS);
+
+    len  = strlen(xlfd);
+
+    for (ptr=xlfd, i=0; i<XLFD_TOKENS && len>0; i++) {
+        /* skip one '-' */
+        ptr++;
+        len--;
+        if (len <= 0)
+            break;
+        size = strcspn(ptr, "-");
+        tokens[i].str = ptr;
+        tokens[i].len = size;
+        ptr += size;
+        len -= size;
+    }
+
+    return tokens;
+}
+
+
+static int
+strToInt(str *token)
+{
+    int res=0, pos, c;
+
+    if (token->len==0 || token->str[0]=='*') {
+        return -1;
+    } else {
+        for (res=0, pos=0; pos<token->len; pos++) {
+            c = token->str[pos] - '0';
+            if (c<0 || c>9)
+                break;
+            res = res*10 + c;
+        }
+    }
+    return res;
+}
+
+
+static char*
+mapSlantToName(str *slant)
+{
+    if (slant->len==0 || slant->str[0]=='*')
+        return "roman";
+
+    switch(slant->str[0]) {
+    case 'i':
+        return "italic";
+    case 'o':
+        return "oblique";
+    case 'r':
+    default:
+        return "roman";
+    }
+}
+
+
+char*
+xlfdToFc(char *xlfd, char *useFamily, Bool keepXLFD)
+{
+    str *tokens, *family, *weight, *slant;
+    char *name, buf[512];
+    int size, pixelsize;
+
+    tokens = getXLFDTokens(xlfd);
+    if (!tokens)
+        return wstrdup(DEFAULT_FONT);
+
+    family = &(tokens[1]);
+    weight = &(tokens[2]);
+    slant  = &(tokens[3]);
+
+    if (useFamily) {
+        name = wstrdup(useFamily);
+    } else {
+        if (family->len==0 || family->str[0]=='*')
+            return wstrdup(DEFAULT_FONT);
+
+        sprintf(buf, "%.*s", family->len, family->str);
+        name = wstrdup(buf);
+    }
+
+    pixelsize = strToInt(&tokens[6]);
+    size = strToInt(&tokens[7]);
+
+    if (size<=0 && pixelsize<=0) {
+        name = wstrappend(name, ":pixelsize=12");
+    } else if (pixelsize>0) {
+        /* if pixelsize is present size will be ignored so we skip it */
+        sprintf(buf, ":pixelsize=%d", pixelsize);
+        name = wstrappend(name, buf);
+    } else {
+        sprintf(buf, "-%d", size/10);
+        name = wstrappend(name, buf);
+    }
+
+    if (weight->len>0 && weight->str[0]!='*') {
+        sprintf(buf, ":weight=%.*s", weight->len, weight->str);
+        name = wstrappend(name, buf);
+    }
+
+    if (slant->len>0 && slant->str[0]!='*') {
+        sprintf(buf, ":slant=%s", mapSlantToName(slant));
+        name = wstrappend(name, buf);
+    }
+
+    if (keepXLFD) {
+        name = wstrappend(name, ":xlfd=");
+        name = wstrappend(name, xlfd);
+    }
+
+    return name;
+}
+
+
+/* return converted font (if conversion is needed) else the original font */
+static char*
+convertFont(char *font, Bool keepXLFD)
+{
+    if (font[0]=='-') {
+        if (!strchr(font, ',')) {
+            return xlfdToFc(font, NULL, keepXLFD);
+        } else {
+            return xlfdToFc(font, "sans-serif", keepXLFD);
+        }
+    } else {
+        return font;
+    }
+}
+
+
+void
+print_help()
+{
+    printf("\nUsage: %s <style_file>\n\n", ProgName);
+    puts("Converts fonts in a style file into fontconfig format");
+    puts("");
+    puts("  --help       display this help and exit");
+    puts("  --version    output version information and exit");
+    puts("  --keep-xlfd  preserve the original xlfd by appending a ':xlfd=<xlfd>' hint");
+    puts("               to the font name. This property is not used by the fontconfig");
+    puts("               matching engine to find the font, but it is useful as a hint");
+    puts("               about what the original font was to allow hand tuning the");
+    puts("               result or restoring the xlfd. The default is to not add it");
+    puts("               as it results in long, unreadable and confusing names.");
+    puts("  --sets-too   try to approximate fontsets by using their first complete xlfd.");
+    puts("               This only works for singlebyte languages. The default is to");
+    puts("               replace the fontset with the default: 'sans-serif:pixelsize=12'");
+    puts("               which should display properly for any language.");
+    puts("");
+}
+
+// replace --sets-too with something better
+int
+main(int argc, char **argv)
+{
+    WMPropList *style, *key, *val;
+    char *file = NULL, *oldfont, *newfont;
+    struct stat statbuf;
+    Bool keepXLFD = False;
+    int i;
+
+    ProgName = argv[0];
+
+    if (argc<2) {
+        print_help();
+        exit(0);
+    }
+
+    for (i=1; i < argc; i++) {
+        if (strcmp("--version", argv[i])==0) {
+            puts(PROG_VERSION);
+            exit(0);
+        } else if (strcmp("--help", argv[i])==0) {
+            print_help();
+            exit(0);
+        } else if (strcmp("--keep-xlfd", argv[i])==0) {
+            keepXLFD = True;;
+        } else if (argv[i][0]=='-') {
+            printf("%s: invalid argument '%s'\n", ProgName, argv[i]);
+            printf("Try '%s --help' for more information\n", ProgName);
+            exit(1);
+        } else {
+            file = argv[i];
+        }
+    }
+
+    WMPLSetCaseSensitive(False);
+
+    if (stat(file, &statbuf) < 0) {
+        perror(file);
+        exit(1);
+    }
+
+    style = WMReadPropListFromFile(file);
+    if (!style) {
+        perror(file);
+        printf("%s: could not load style file.\n", ProgName);
+        exit(1);
+    }
+
+    if (!WMIsPLDictionary(style)) {
+        printf("%s: '%s' is not a well formatted style file\n", ProgName, file);
+        exit(1);
+    }
+
+    for (i=0; FontOptions[i]!=NULL; i++) {
+        key = WMCreatePLString(FontOptions[i]);
+        val = WMGetFromPLDictionary(style, key);
+        if (val) {
+            oldfont = WMGetFromPLString(val);
+            newfont = convertFont(oldfont, keepXLFD);
+            if (oldfont != newfont) {
+                val = WMCreatePLString(newfont);
+                WMPutInPLDictionary(style, key, val);
+                WMReleasePropList(val);
+                wfree(newfont);
+            }
+        }
+        WMReleasePropList(key);
+    }
+
+    WMWritePropListToFile(style, file, True);
+
+    exit(0);
+}
+
+

util/getstyle.c

@@ -467,7 +467,7 @@ strToInt(str *token)
     int res=0, pos, c;
 
     if (token->len==0 || token->str[0]=='*') {
-	return -1;
+        return -1;
     } else {
         for (res=0, pos=0; pos<token->len; pos++) {
             c = token->str[pos] - '0';
@@ -589,7 +589,7 @@ findCopyFile(char *dir, char *file)
     if (!fullPath) {
         char buffer[4000];
 
-        sprintf(buffer, "coould not find file %s", file);
+        sprintf(buffer, "could not find file %s", file);
         abortar(buffer);
     }
     copyFile(dir, fullPath);
@@ -776,7 +776,7 @@ main(int argc, char **argv)
 
                 oldfont = WMGetFromPLString(val);
                 newfont = convertFont(oldfont);
-                /* font is a reference to old if conversion is not needed */
+                /* newfont is a reference to old if conversion is not needed */
                 if (newfont != oldfont) {
                     WMReleasePropList(val);
                     val = WMCreatePLString(newfont);

util/wmagnify.c

@@ -10,6 +10,7 @@
 
 #include <WINGs/WINGs.h>
 #include <stdlib.h>
+#include <string.h>
 #include <stdio.h>
 
 /*

util/wmsetbg.c

@@ -495,7 +495,7 @@ parseTexture(RContext *rc, char *text)
 	XColor color;
 	Pixmap pixmap = None;
 	RImage *image = NULL;
-	int w, h;
+	//int w, h;
 	int iwidth, iheight;
 	RColor rcolor;
 

wmlib/app.c

@@ -21,6 +21,7 @@
 
 #include <X11/Xlib.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "WMaker.h"
 #include "app.h"

wrlib/convert.c

@@ -678,7 +678,8 @@ image2StandardPseudoColor(RContext *ctx, RImage *image)
 	int x1, ofs;
 
 #ifdef DEBUG
-        printf("pseudo color dithering with %d colors per channel\n", cpc);
+        printf("pseudo color dithering with %d colors per channel\n",
+               ctx->attribs->colors_per_channel);
 #endif
 	err = (short*)malloc(3*(image->width+2)*sizeof(short));
 	nerr = (short*)malloc(3*(image->width+2)*sizeof(short));