wmaker/WPrefs.app/Font.c

/* Font.c- text/font settings
 *
 *  WPrefs - Window Maker Preferences Program
 *
 *  Copyright (c) 1999-2003 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 *  USA.
 */


#include "WPrefs.h"
#include <X11/Xlocale.h>
#include <ctype.h>

typedef struct _Panel {
    WMBox *box;
    char *sectionName;

    char *description;

    CallbackRec callbacks;

    WMWidget *parent;


    WMLabel *prevL;

	WMFontPanel *fontPanel;

	WMPopUpButton *fontSel;
	WMFrame *multiF;
	WMButton *togMulti;
    WMFrame *langF;
    WMPopUpButton *langP;
	WMFrame *aaF;
	WMButton *togAA;

    /* single byte */
    WMTextField *fontT;
    WMButton *changeB;

    /* multibyte */
    WMLabel *fsetL;
    WMList *fsetLs;

    WMButton *addB;
    WMButton *editB;
    WMButton *remB;

	WMButton *upB;
	WMButton *downB;

    WMColor *white;
    WMColor *black;
    WMColor *light;
    WMColor *dark;

    WMColor *back;
	WMColor *colors[9];

    Pixmap preview;
    WMPixmap *previewPix;
	WMPixmap *hand;
	WMPixmap *up_arrow;
	WMPixmap *down_arrow;
	WMPixmap *alt_up_arrow;
	WMPixmap *alt_down_arrow;

	int oldsection;
	char menuStyle;
	char titleAlignment;
	Bool MultiByteText;

	Bool AntialiasedText;
} _Panel;



#define ICON_FILE	"fonts"

static WMRect previewPositions[] = {
#define WINTITLE	0
	{{30, 10},{190, 20}},
#define DISTITLE	1
	{{30, 35},{90, 64}},
#define PMTITLE		2
	{{30, 105},{90, 20}},
#define PMITEM		3
	{{30, 125},{90, 20*4}},
#define PCLIP		4
	{{156, 35},{64, 64}},
#define PICON		5
	{{156, 105},{64, 64}}
};
#define EVERYTHING 0xff

static char *colorOptions[] = {
#define FTITLE	(1<<0)
	"FTitleColor", "white",
#define DISCOL	(1<<1)			/* Display uses white always */
#define MTITLE	(1<<2)
	"MenuTitleColor", "white",
#define MITEM	(1<<3)
	"MenuTextColor", "black",
#define CLIP	(1<<4)
	"ClipTitleColor", "black",
#define CCLIP	(1<<4)
	"ClipTitleColor", "#454045",
#define ICONT	(1<<5)
	"IconTitleColor", "white",
#define ICONB	(1<<5)
	"IconTitleBack", "black"
};

#define MSTYLE_NORMAL	0
#define MSTYLE_SINGLE	1
#define MSTYLE_FLAT	2


#define RESIZEBAR_BEVEL	-1
#define MENU_BEVEL	-2
#define CLIP_BUTTON_SIZE	23
#define ICON_SIZE	64


static char *textureOptions[] = {
	"FTitleBack",
	NULL,
	"MenuTitleBack",
	"MenuTextBack",
	"IconBack",
	"IconBack"
};

/* XPM */
static char * hand_xpm[] = {
"22 21 19 1",
"       c None",
".      c #030305",
"+      c #7F7F7E",
"@      c #B5B5B6",
"#      c #C5C5C6",
"$      c #969697",
"%      c #FDFDFB",
"&      c #F2F2F4",
"*      c #E5E5E4",
"=      c #ECECEC",
"-      c #DCDCDC",
";      c #D2D2D0",
">      c #101010",
",      c #767674",
"'      c #676767",
")      c #535355",
"!      c #323234",
"~      c #3E3C56",
"{      c #333147",
"                      ",
"       .....          ",
"     ..+@##$.         ",
"    .%%%&@..........  ",
"   .%*%%&#%%%%%%%%%$. ",
"  .*#%%%%%%%%%&&&&==. ",
" .-%%%%%%%%%=*-;;;#$. ",
" .-%%%%%%%%&..>.....  ",
" >-%%%%%%%%%*#+.      ",
" >-%%%%%%%%%*@,.      ",
" >#%%%%%%%%%*@'.      ",
" >$&&%%%%%%=...       ",
" .+@@;=&%%&;$,>       ",
"  .',$@####$+).       ",
"   .!',+$++,'.        ",
"     ..>>>>>.         ",
"                      ",
"     ~~{{{~~          ",
"   {{{{{{{{{{{        ",
"     ~~{{{~~          ",
"                      "};

static char *up_arrow_xpm[] = {
"9 9 3 1",
".		c #acaaac",
"%		c #525552",
"#		c #000000",
"....%....",
"....#....",
"...%#%...",
"...###...",
"..%###%..",
"..#####..",
".%#####%.",
".#######.",
"%#######%"
};

static char *down_arrow_xpm[] = {
"9 9 3 1",
".		c #acaaac",
"%		c #525552",
"#		c #000000",
"%#######%",
".#######.",
".%#####%.",
"..#####..",
"..%###%..",
"...###...",
"...%#%...",
"....#....",
"....%...."
};

static char *alt_up_arrow_xpm[] = {
"9 9 2 1",
".		c #ffffff",
"%		c #525552",
"....%....",
"....%....",
"...%%%...",
"...%%%...",
"..%%%%%..",
"..%%%%%..",
".%%%%%%%.",
".%%%%%%%.",
"%%%%%%%%%"
};

static char *alt_down_arrow_xpm[] = {
"9 9 2 1",
".		c #ffffff",
"%		c #525552",
"%%%%%%%%%",
".%%%%%%%.",
".%%%%%%%.",
"..%%%%%..",
"..%%%%%..",
"...%%%...",
"...%%%...",
"....%....",
"....%...."
};
/* XPM */

static WMPropList *CurrentFontArray = NULL;
//static WMPropList *CurrentMenuTitleFont = NULL;
//static WMPropList *CurrentMenuTextFont = NULL;
//static WMPropList *CurrentIconTitleFont = NULL;
//static WMPropList *CurrentClipTitleFont = NULL;
//static WMPropList *CurrentLargeDisplayFont = NULL;

static WMPropList *DefaultWindowTitleFont = NULL;
static WMPropList *DefaultMenuTitleFont = NULL;
static WMPropList *DefaultMenuTextFont = NULL;
static WMPropList *DefaultIconTitleFont = NULL;
static WMPropList *DefaultClipTitleFont = NULL;
static WMPropList *DefaultLargeDisplayFont = NULL;

static void changePage(WMWidget *w, void *data);
static void setLanguageType(void *data, Bool multiByte);
static void refillFontSetList(void *data);
static void readFontEncodings(void *data);
static void changeLanguageAction(WMWidget *w, void *data);
static void checkListForArrows(void *data);

static char* getFontEncoding(void *data);
static char* getFontSampleString(void *data);

/* note single element */
static WMFont* getFontForPreview(void *data, int element);
static WMFont* getDefaultSystemFont(void *data, int element);

static WMPropList* getDefaultFontProp(void *data, char *encoding, int section);
static WMPropList* getCurrentFontProp(void *data, int section);

static Bool isEncodingMultiByte(void *data);

static void
str2rcolor(RContext *rc, char *name, RColor *color)
{
    XColor xcolor;

    XParseColor(rc->dpy, rc->cmap, name, &xcolor);

    color->alpha = 255;
    color->red = xcolor.red >> 8;
    color->green = xcolor.green >> 8;
    color->blue = xcolor.blue >> 8;
}

static void
drawMenuBevel(RImage *img)
{
    RColor light, dark, mid;
    int i;
    int iheight = img->height / 4;

    light.alpha = 0;
    light.red = light.green = light.blue = 80;

    dark.alpha = 255;
    dark.red = dark.green = dark.blue = 0;

    mid.alpha = 0;
    mid.red = mid.green = mid.blue = 40;

    for (i = 1; i < 4; i++) {
	ROperateLine(img, RSubtractOperation, 0, i*iheight-2,
		     img->width-1, i*iheight-2, &mid);

	RDrawLine(img, 0, i*iheight-1, img->width-1, i*iheight-1, &dark);

	ROperateLine(img, RAddOperation, 1, i*iheight,
		     img->width-2, i*iheight, &light);
    }
}

static void
paintTitle(WMScreen *scr, Drawable d, WMColor *color, WMFont *font,
	  int part, WMAlignment align, char *text)
{
    int l = strlen(text);
	int x = previewPositions[part].pos.x;
	int y = previewPositions[part].pos.y;
	int w = previewPositions[part].size.width;
	int h = previewPositions[part].size.height;

    switch (align) {
     case WALeft:
	x += 5;
	break;
     case WARight:
	x += w - 5 - WMWidthOfString(font, text, l);
	break;
     default:
     case WACenter:
	x += (w - WMWidthOfString(font, text, l))/2;
	break;
    }
    WMDrawString(scr, d, color, font, x,
		 y + (h - WMFontHeight(font))/2, text, l);
}

static void
paintItems(WMScreen *scr, Drawable d, WMColor *color, WMFont *font,
		int part, char *text)
{
    int l = strlen(text);
	int x = previewPositions[part].pos.x;
	int y = previewPositions[part].pos.y;
	//int w = previewPositions[part].size.width;
	int h = previewPositions[part].size.height/4;
	int i;
	for( i = 0; i < 4 ; i++) {
		WMDrawString(scr, d, color, font, x+5,
		y+(20*i)+(h - WMFontHeight(font))/2, text, l);
	}
}

static void
paintIcon(WMScreen *scr,Drawable d, WMColor *color, WMColor *Iback,
		WMFont *font, int part, char *text)
{
	Display *dpy = WMScreenDisplay(scr);
    int l = strlen(text);
	int x = previewPositions[part].pos.x+1;
	int y = previewPositions[part].pos.y+1;
	int w = previewPositions[part].size.width-2;
	int h = WMFontHeight(font)+2;

	XFillRectangle(dpy, d, WMColorGC(Iback), x, y, w, h);
	x += (w - WMWidthOfString(font, text, l))/2;
	WMDrawString(scr, d, color, font, x,
					y + (h - WMFontHeight(font))/2, text, l);

}

static void
drawFonts(_Panel *panel, int elements)
{
	WMScreen *scr = WMWidgetScreen(panel->box);
	WMPixmap *pixmap;
	Pixmap d;

	pixmap = WMGetLabelImage(panel->prevL);
	d = WMGetPixmapXID(pixmap);

	if(elements & FTITLE) {
	paintTitle(scr, d, panel->colors[0], getFontForPreview(panel, WINTITLE),
		WINTITLE, panel->titleAlignment, _("Window Title Font"));
		}
	if(elements & DISCOL) {
	paintTitle(scr, d, panel->white, getFontForPreview(panel, DISTITLE),
			DISTITLE, WACenter, _("Display"));
	}
	if(elements & MTITLE) {
	paintTitle(scr, d, panel->colors[1], getFontForPreview(panel, PMTITLE),
		PMTITLE, WALeft, _("Menu Title"));
	}
	if(elements & MITEM) {
	paintItems(scr, d, panel->colors[2], getFontForPreview(panel, PMITEM),
		PMITEM, _("Menu Item"));
	}
	if(elements & CLIP) {
	WMDrawString(scr, d, panel->colors[4],
					getFontForPreview(panel, PCLIP), 169,37, "1",1);
	WMDrawString(scr, d, panel->colors[3],
					getFontForPreview(panel, PCLIP),179, 84, _("Clip title"), 10);
	}
	if(elements & ICONT) {
	paintIcon(scr, d, panel->colors[5], panel->colors[6],
			getFontForPreview(panel, PICON), PICON, _("Icon Title"));
	}
}

static void
dumpRImage(char *path, RImage *image)
{
    FILE *f;
    int channels = (image->format == RRGBAFormat ? 4 : 3);

    f = fopen(path, "w");
    if (!f) {
	wsyserror(path);
	return;
    }
    fprintf(f, "%02x%02x%1x", image->width, image->height, channels);

    fwrite(image->data, 1, image->width * image->height * channels, f);

    if (fclose(f) < 0) {
	wsyserror(path);
    }
}

/*static int
isPixmap(WMPropList *prop)
{
    WMPropList *p;
    char *s;

    p = WMGetFromPLArray(prop, 0);
    s = WMGetFromPLString(p);
    if (strcasecmp(&s[1], "pixmap")==0)
	return 1;
    else
	return 0;
}*/

static Pixmap
renderTexture(WMScreen *scr, WMPropList *texture, int width, int height,
	      char *path, int border)
{
    char *type;
    RImage *image = NULL;
    Pixmap pixmap;
    RContext *rc = WMScreenRContext(scr);
    char *str;
    RColor rcolor;


    type = WMGetFromPLString(WMGetFromPLArray(texture, 0));

    if (strcasecmp(type, "solid")==0) {

	str = WMGetFromPLString(WMGetFromPLArray(texture, 1));

	str2rcolor(rc, str, &rcolor);

	image = RCreateImage(width, height, False);
	RClearImage(image, &rcolor);
    } else if (strcasecmp(type, "igradient")==0) {
	int t1, t2;
	RColor c1[2], c2[2];

	str = WMGetFromPLString(WMGetFromPLArray(texture, 1));
	str2rcolor(rc, str, &c1[0]);
	str = WMGetFromPLString(WMGetFromPLArray(texture, 2));
	str2rcolor(rc, str, &c1[1]);
	str = WMGetFromPLString(WMGetFromPLArray(texture, 3));
	t1 = atoi(str);

	str = WMGetFromPLString(WMGetFromPLArray(texture, 4));
	str2rcolor(rc, str, &c2[0]);
	str = WMGetFromPLString(WMGetFromPLArray(texture, 5));
	str2rcolor(rc, str, &c2[1]);
	str = WMGetFromPLString(WMGetFromPLArray(texture, 6));
	t2 = atoi(str);

	image = RRenderInterwovenGradient(width, height, c1, t1, c2, t2);
    } else if (strcasecmp(&type[1], "gradient")==0) {
	int style;
	RColor rcolor2;

	switch (toupper(type[0])) {
	 case 'V':
	    style = RVerticalGradient;
	    break;
	 case 'H':
	    style = RHorizontalGradient;
	    break;
	 default:
	 case 'D':
	    style = RDiagonalGradient;
	    break;
	}

	str = WMGetFromPLString(WMGetFromPLArray(texture, 1));
	str2rcolor(rc, str, &rcolor);
	str = WMGetFromPLString(WMGetFromPLArray(texture, 2));
	str2rcolor(rc, str, &rcolor2);

	image = RRenderGradient(width, height, &rcolor, &rcolor2, style);
    } else if (strcasecmp(&type[2], "gradient")==0 && toupper(type[0])=='T') {
	int style;
	RColor rcolor2;
	int i;
	RImage *grad, *timage;
	char *path;

	switch (toupper(type[1])) {
	 case 'V':
	    style = RVerticalGradient;
	    break;
	 case 'H':
	    style = RHorizontalGradient;
	    break;
	 default:
	 case 'D':
	    style = RDiagonalGradient;
	    break;
	}

	str = WMGetFromPLString(WMGetFromPLArray(texture, 3));
	str2rcolor(rc, str, &rcolor);
	str = WMGetFromPLString(WMGetFromPLArray(texture, 4));
	str2rcolor(rc, str, &rcolor2);

	str = WMGetFromPLString(WMGetFromPLArray(texture, 1));

	if ((path=wfindfileinarray(GetObjectForKey("PixmapPath"), str))!=NULL)
            timage = RLoadImage(rc, path, 0);

	if (!path || !timage) {
	    wwarning("could not load file '%s': %s", path,
		     RMessageForError(RErrorCode));
	} else {
	    grad = RRenderGradient(width, height, &rcolor, &rcolor2, style);

	    image = RMakeTiledImage(timage, width, height);
	    RReleaseImage(timage);

	    i = atoi(WMGetFromPLString(WMGetFromPLArray(texture, 2)));

	    RCombineImagesWithOpaqueness(image, grad, i);
	    RReleaseImage(grad);
	}
    } else if (strcasecmp(&type[2], "gradient")==0 && toupper(type[0])=='M') {
	int style;
	RColor **colors;
	int i, j;

	switch (toupper(type[1])) {
	 case 'V':
	    style = RVerticalGradient;
	    break;
	 case 'H':
	    style = RHorizontalGradient;
	    break;
	 default:
	 case 'D':
	    style = RDiagonalGradient;
	    break;
	}

	j = WMGetPropListItemCount(texture);

	if (j > 0) {
	    colors = wmalloc(j * sizeof(RColor*));

	    for (i = 2; i < j; i++) {
		str = WMGetFromPLString(WMGetFromPLArray(texture, i));
		colors[i-2] = wmalloc(sizeof(RColor));
		str2rcolor(rc, str, colors[i-2]);
	    }
	    colors[i-2] = NULL;

	    image = RRenderMultiGradient(width, height, colors, style);

	    for (i = 0; colors[i]!=NULL; i++)
		wfree(colors[i]);
	    wfree(colors);
	}
    } else if (strcasecmp(&type[1], "pixmap")==0) {
	RImage *timage = NULL;
	char *path;
	RColor color;

	str = WMGetFromPLString(WMGetFromPLArray(texture, 1));

	if ((path=wfindfileinarray(GetObjectForKey("PixmapPath"), str))!=NULL)
            timage = RLoadImage(rc, path, 0);

	if (!path || !timage) {
	    wwarning("could not load file '%s': %s", path ? path : str,
		     RMessageForError(RErrorCode));
	} else {
	    str = WMGetFromPLString(WMGetFromPLArray(texture, 2));
	    str2rcolor(rc, str, &color);

	    switch (toupper(type[0])) {
	     case 'T':
		image = RMakeTiledImage(timage, width, height);
		RReleaseImage(timage);
		timage = image;
		break;
	     case 'C':
		image = RMakeCenteredImage(timage, width, height, &color);
		RReleaseImage(timage);
		timage = image;
		break;
	     case 'S':
	     case 'M':
		image = RScaleImage(timage, width, height);
		RReleaseImage(timage);
		timage = image;
		break;
	    }

	}
	wfree(path);
    }

    if (!image)
	return None;

    if (path) {
	dumpRImage(path, image);
    }

    if (border < 0) {
	if (border == MENU_BEVEL) {
	    drawMenuBevel(image);
	    RBevelImage(image, RBEV_RAISED2);
	}
    } else if (border) {
	RBevelImage(image, border);
    }

    RConvertImage(rc, image, &pixmap);
    RReleaseImage(image);

    return pixmap;
}

static Pixmap
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);
    GC gc = XCreateGC(dpy, WMWidgetXID(panel->parent), 0, NULL);
    int i;

    switch (panel->menuStyle) {
     case MSTYLE_NORMAL:
	tmp = renderTexture(scr, texture, width, iheight, NULL, RBEV_RAISED2);

	pix = XCreatePixmap(dpy, tmp, width, iheight*4, WMScreenDepth(scr));
	for (i = 0; i < 4; i++) {
	    XCopyArea(dpy, tmp, pix, gc, 0, 0, width, iheight, 0, iheight*i);
	}
	XFreePixmap(dpy, tmp);
	break;
     case MSTYLE_SINGLE:
	pix = renderTexture(scr, texture, width, iheight*4, NULL, MENU_BEVEL);
	break;
     case MSTYLE_FLAT:
	pix = renderTexture(scr, texture, width, iheight*4, NULL, RBEV_RAISED2);
	break;
    }
    XFreeGC(dpy, gc);

    return pix;
}

static void
renderClip(_Panel *panel, GC gc, int part, int relief)
{
    WMScreen *scr = WMWidgetScreen(panel->box);
	Display *dpy = WMScreenDisplay(scr);
    RContext *rc = WMScreenRContext(scr);
    WMPropList *prop;
    Pixmap pix;
	XImage *original;
    XPoint p[4];
    RImage *tile;
    RColor black;
    RColor dark;
    RColor light;
    int pt, tp;
    int as;

	prop = GetObjectForKey(textureOptions[part]);

    pix = renderTexture(scr, prop,
			previewPositions[part].size.width,
			previewPositions[part].size.height,
			NULL, relief);


	original = XGetImage(dpy, pix, 0, 0, 64, 64,
					AllPlanes, ZPixmap);
	if (!original){
	wwarning(_("error capturing \"original\" tile image"),
					RMessageForError(RErrorCode));
	}
	tile = RCreateImageFromXImage(rc, original, NULL);

	XDestroyImage(original);
    XFreePixmap(WMScreenDisplay(scr), pix);

    pt = CLIP_BUTTON_SIZE*ICON_SIZE/64;
    tp = ICON_SIZE-1 - pt;
    as = pt - 15;

    black.alpha = 255;
    black.red = black.green = black.blue = 0;

    dark.alpha = 0;
    dark.red = dark.green = dark.blue = 60;

    light.alpha = 0;
    light.red = light.green = light.blue = 80;


    /* top right */
    ROperateLine(tile, RSubtractOperation, tp, 0, ICON_SIZE-2,
		 pt-1, &dark);
    RDrawLine(tile, tp-1, 0, ICON_SIZE-1, pt+1, &black);
    ROperateLine(tile, RAddOperation, tp, 2, ICON_SIZE-3,
		 pt, &light);

    /* arrow bevel */
    ROperateLine(tile, RSubtractOperation, ICON_SIZE - 7 - as, 4,
                 ICON_SIZE - 5, 4, &dark);
    ROperateLine(tile, RSubtractOperation, ICON_SIZE - 6 - as, 5,
		 ICON_SIZE - 5, 6 + as, &dark);
    ROperateLine(tile, RAddOperation, ICON_SIZE - 5, 4, ICON_SIZE - 5, 6 + as,
		 &light);

    /* bottom left */
    ROperateLine(tile, RAddOperation, 2, tp+2, pt-2,
		 ICON_SIZE-3, &dark);
    RDrawLine(tile, 0, tp-1, pt+1, ICON_SIZE-1, &black);
    ROperateLine(tile, RSubtractOperation, 0, tp-2, pt+1,
		 ICON_SIZE-2, &light);

    /* arrow bevel */
    ROperateLine(tile, RSubtractOperation, 4, ICON_SIZE - 7 - as, 4,
                 ICON_SIZE - 5, &dark);
    ROperateLine(tile, RSubtractOperation, 5, ICON_SIZE - 6 - as,
		 6 + as, ICON_SIZE - 5, &dark);
    ROperateLine(tile, RAddOperation, 4, ICON_SIZE - 5, 6 + as, ICON_SIZE - 5,
		 &light);

	RConvertImage(rc, tile, &pix);

    /* top right arrow */
    p[0].x = p[3].x = ICON_SIZE-5-as;
    p[0].y = p[3].y = 5;
    p[1].x = ICON_SIZE-6;
    p[1].y = 5;
    p[2].x = ICON_SIZE-6;
    p[2].y = 4+as;
    XFillPolygon(dpy, pix, WMColorGC(panel->colors[4]), p, 3, Convex, CoordModeOrigin);
    XDrawLines(dpy, pix, WMColorGC(panel->colors[4]), p, 4, CoordModeOrigin);

    /* bottom left arrow */
    p[0].x = p[3].x = 5;
    p[0].y = p[3].y = ICON_SIZE-5-as;
    p[1].x = 5;
    p[1].y = ICON_SIZE-6;
    p[2].x = 4+as;
    p[2].y = ICON_SIZE-6;
	XFillPolygon(dpy, pix, WMColorGC(panel->colors[4]), p, 3, Convex, CoordModeOrigin);
    XDrawLines(dpy, pix, WMColorGC(panel->colors[4]), p, 4, CoordModeOrigin);

    XCopyArea(dpy, pix, panel->preview, gc, 0, 0,
	      previewPositions[part].size.width,
	      previewPositions[part].size.height,
	      previewPositions[part].pos.x,
	      previewPositions[part].pos.y);

	RReleaseImage(tile);
    XFreePixmap(WMScreenDisplay(scr), pix);
}

static void
renderPreview(_Panel *panel, GC gc, int part, int relief)
{
    WMPropList *prop;
    Pixmap pix;
    WMScreen *scr = WMWidgetScreen(panel->box);

	prop = GetObjectForKey(textureOptions[part]);

    pix = renderTexture(scr, prop,
			previewPositions[part].size.width,
			previewPositions[part].size.height,
			NULL, relief);
    XCopyArea(WMScreenDisplay(scr), pix,
		  panel->preview, gc, 0, 0,
	      previewPositions[part].size.width,
	      previewPositions[part].size.height,
	      previewPositions[part].pos.x,
	      previewPositions[part].pos.y);

    XFreePixmap(WMScreenDisplay(scr), pix);
}

static void
paintPreviewBox(Panel *panel, int elements)
{
    WMScreen *scr = WMWidgetScreen(panel->parent);
    Display *dpy = WMScreenDisplay(scr);
	//int refresh = 0;
	GC gc;
	WMColor *black = WMBlackColor(scr);
	Pixmap mitem;

	gc = XCreateGC(dpy, WMWidgetXID(panel->parent), 0, NULL);

    if (panel->preview == None) {
	WMPixmap *pix;

	panel->preview = XCreatePixmap(dpy, WMWidgetXID(panel->parent),
				       240-4, 190-4, WMScreenDepth(scr));

	pix = WMCreatePixmapFromXPixmaps(scr, panel->preview, None,
					 240-4, 190-4, WMScreenDepth(scr));

	WMSetLabelImage(panel->prevL, pix);
	WMReleasePixmap(pix);
    }
    XFillRectangle(dpy, panel->preview, WMColorGC(panel->back),
		   0, 0, 240-4, 190-4);

    if (elements & (1<<WINTITLE)) {
	renderPreview(panel, gc, WINTITLE, RBEV_RAISED2);
	XDrawRectangle(dpy, panel->preview, WMColorGC(black),
		       previewPositions[WINTITLE].pos.x-1,
		       previewPositions[WINTITLE].pos.y-1,
		       previewPositions[WINTITLE].size.width,
		       previewPositions[WINTITLE].size.height);
    }
    if (elements & (1<<DISTITLE)) {
	XDrawRectangle(dpy, panel->preview, WMColorGC(panel->back),
		       previewPositions[DISTITLE].pos.x-1,
		       previewPositions[DISTITLE].pos.y-1,
		       previewPositions[DISTITLE].size.width,
		       previewPositions[DISTITLE].size.height);
    }
    if (elements & (1<<PMTITLE)) {
	renderPreview(panel, gc, PMTITLE, RBEV_RAISED2);
	XDrawRectangle(dpy, panel->preview, WMColorGC(black),
		       previewPositions[PMTITLE].pos.x-1,
		       previewPositions[PMTITLE].pos.y-1,
		       previewPositions[PMTITLE].size.width,
		       previewPositions[PMTITLE].size.height);
    }
   if (elements & (1<<PMITEM)) {
	WMPropList *prop;

	prop = GetObjectForKey(textureOptions[PMITEM]);
	mitem = renderMenu(panel, prop,
			 previewPositions[PMITEM].size.width,
			 previewPositions[PMITEM].size.height/4);

	XCopyArea(dpy, mitem, panel->preview, gc, 0, 0,
		  previewPositions[PMITEM].size.width,
		  previewPositions[PMITEM].size.height,
		  previewPositions[PMITEM].pos.x,
		  previewPositions[PMITEM].pos.y);

	XFreePixmap(dpy, mitem);
    }
    if (elements & (1<<PMITEM|1<<PMTITLE)) {
	XDrawLine(dpy, panel->preview, gc, 29, 125, 29, 125+20*4+25);
	XDrawLine(dpy, panel->preview, gc, 119, 125, 119, 125+20*4+25);
    }
    if (elements & (1<<PCLIP)) {
	renderClip(panel, gc, PCLIP, RBEV_RAISED3);
	XDrawRectangle(dpy, panel->preview, WMColorGC(black),
		       previewPositions[PCLIP].pos.x-1,
		       previewPositions[PCLIP].pos.y-1,
		       previewPositions[PCLIP].size.width,
		       previewPositions[PCLIP].size.height);
    }
    if (elements & (1<<PICON)) {
	renderPreview(panel, gc, PICON, RBEV_RAISED3);
	XDrawRectangle(dpy, panel->preview, WMColorGC(black),
		       previewPositions[PICON].pos.x-1,
		       previewPositions[PICON].pos.y-1,
		       previewPositions[PICON].size.width,
		       previewPositions[PICON].size.height);
    }
	drawFonts(panel, elements);
    WMRedisplayWidget(panel->prevL);
	XFreeGC(dpy, gc);
	WMReleaseColor(black);
}

static void
paintTextField(void *data, int section)
{
	_Panel *panel = (_Panel*)data;
	//char *sample = NULL;
	int encoding;
	encoding = WMGetPopUpButtonSelectedItem(panel->langP);
	WMSetTextFieldFont(panel->fontT, getFontForPreview(panel, section));
	switch(encoding) {
		case 0:  /* Current Font in theme */
			WMSetTextFieldText(panel->fontT,
					"ABCDEFGHIKLMNOPQRSTUVXYWZabcdefghiklmnopqrstuvxywz0123456789\x00e0\x00e6\x00e7\x00eb\x00ee\x00f0\x00f1\x00f3\x00f9\x00fd\x00c0\x00c6\x00c7\x00cb\x00ce\x00d0\x00d1\x00d3\x00d9\x00dd");
			break;
		case 1:  /* default */
			WMSetTextFieldText(panel->fontT, getFontSampleString(panel));
				//	"ABCDEFGHIKLMNOPQRSTUVXYWZabcdefghiklmnopqrstuvxywz0123456789\x00e0\x00e6\x00e7\x00eb\x00ee\x00f0\x00f1\x00f3\x00f9\x00fd\x00c0\x00c6\x00c7\x00cb\x00ce\x00d0\x00d1\x00d3\x00d9\x00dd");
			break;
		case 2:  /* latin1 iso8859-1 */
			WMSetTextFieldText(panel->fontT, getFontSampleString(panel));
				//  "ABCDEFGHIKLMNOPQRSTUVXYWZabcdefghiklmnopqrstuvxywz0123456789\x00e0\x00e6\x00e7\x00eb\x00ee\x00f0\x00f1\x00f3\x00f9\x00fd\x00c0\x00c6\x00c7\x00cb\x00ce\x00d0\x00d1\x00d3\x00d9\x00dd");
			break;
		case 3:  /* latin2 iso8859-2 */
			WMSetTextFieldText(panel->fontT, getFontSampleString(panel));
			//		"ABCDEFGHIKLMNOPQRSTUVXYWZabcdefghiklmnopqrstuvxywz0123456789\x00e0\x00e6\x00e7\x00eb\x00ee\x00f0\x00f1\x00f3\x00f9\x00fd\x00c0\x00c6\x00c7\x00cb\x00ce\x00d0\x00d1\x00d3\x00d9\x00dd");
			break;
		case 4:  /* Greek iso8859-7 */
			WMSetTextFieldText(panel->fontT, getFontSampleString(panel));
			//		"ABCDEFGHIKLMNOPQRSTUVXYWZabcdefghiklmnopqrstuvxywz0123456789\x00e0\x00e6\x00e7\x00eb\x00ee\x00f0\x00f1\x00f3\x00f9\x00fd\x00c0\x00c6\x00c7\x00cb\x00ce\x00d0\x00d1\x00d3\x00d9\x00dd");
			break;
/* luckily all these happen to have the MultiByte chars in the same places */
		case 5:  /* Japanese jisx0208.1983 */
			WMSetTextFieldText(panel->fontT, getFontSampleString(panel));
			//		"Window Maker <20><><EFBFBD><EFBFBD><EFBFBD>桼<EFBFBD>ƥ<EFBFBD><C6A5><EFBFBD><EFBFBD>ƥ<EFBFBD>");
			break;
		case 6:  /* Korean ksc5601.1987 */
			WMSetTextFieldText(panel->fontT, getFontSampleString(panel));
			//		"<22><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>Ŀ <20><><EFBFBD><EFBFBD>");
			break;
		case 7:  /* korean2 daewoo */
			WMSetTextFieldText(panel->fontT, getFontSampleString(panel));
			//		"<22><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> <20><><EFBFBD><EFBFBD>Ŀ <20><><EFBFBD><EFBFBD>");
			break;
		case 8:  /* Russian koi8-r */
			WMSetTextFieldText(panel->fontT, getFontSampleString(panel));
			//		"<22><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD> Window Maker");
			break;
		case 9:  /* Ukranian koi8-u */
			WMSetTextFieldText(panel->fontT, getFontSampleString(panel));
			//		"ABCDEFGHIKLMNOPQRSTUVXYWZabcdefghiklmnopqrstuvxywz0123456789\x00e0\x00e6\x00e7\x00eb\x00ee\x00f0\x00f1\x00f3\x00f9\x00fd\x00c0\x00c6\x00c7\x00cb\x00ce\x00d0\x00d1\x00d3\x00d9\x00dd");
			break;
	}
}

static void
previewClick(XEvent *event, void *clientData)
{
    _Panel *panel = (_Panel*)clientData;
    int i;

	for (i = 0; i < sizeof(previewPositions)/sizeof(WMRect); i++) {
	    if (event->xbutton.x >= previewPositions[i].pos.x
		&& event->xbutton.y >= previewPositions[i].pos.y
		&& event->xbutton.x < previewPositions[i].pos.x
		+ previewPositions[i].size.width
		&& event->xbutton.y < previewPositions[i].pos.y
		+ previewPositions[i].size.height) {

		WMSetPopUpButtonSelectedItem(panel->fontSel, i);
		changePage(panel->fontSel, panel);
		return;
		}
	}
}

static void
changePage(WMWidget *w, void *data)
{
    _Panel *panel = (_Panel*)data;
    int section;
    WMScreen *scr = WMWidgetScreen(panel->box);
    RContext *rc = WMScreenRContext(scr);
    static WMPoint positions[] = {
	{5, 15},
	{5, 62},
	{5, 110},
	{5, 140},
	{130, 62},
	{130, 132}
    };

    if (w) {
	section = WMGetPopUpButtonSelectedItem(panel->fontSel);
    }
    {
	WMColor *color;

	color = WMCreateRGBColor(scr, 0x5100, 0x5100, 0x7100, True);
	XFillRectangle(rc->dpy, panel->preview, WMColorGC(color),
		       positions[panel->oldsection].x,
		       positions[panel->oldsection].y, 22, 22);
	WMReleaseColor(color);
    }
    if (w) {
	panel->oldsection = section;
	WMDrawPixmap(panel->hand, panel->preview, positions[section].x,
		     positions[section].y);
    }
    WMRedisplayWidget(panel->prevL);
	paintTextField(panel, section);
	refillFontSetList(panel);
}

static void
setLanguageType(void *data, Bool multiByte)
{
	_Panel *p = (_Panel*)data;

    if (multiByte) {
	WMMapWidget(p->fsetL);
	WMMapWidget(p->fsetLs);
	WMMapWidget(p->addB);
	WMMapWidget(p->editB);
	WMMapWidget(p->remB);
	WMMapWidget(p->upB);
	WMMapWidget(p->downB);

	WMUnmapWidget(p->fontT);
	WMUnmapWidget(p->changeB);
    } else {
	WMUnmapWidget(p->fsetL);
	WMUnmapWidget(p->fsetLs);
	WMUnmapWidget(p->addB);
	WMUnmapWidget(p->editB);
	WMUnmapWidget(p->remB);
	WMUnmapWidget(p->upB);
	WMUnmapWidget(p->downB);

	WMMapWidget(p->fontT);
	WMMapWidget(p->changeB);
    }
}

static void
refillFontSetList(void *data)
{
	_Panel *panel = (_Panel*)data;
	WMPropList *array;
	char *encoding = getFontEncoding(panel);
	int section = WMGetPopUpButtonSelectedItem(panel->fontSel);
	int i;
	//int pos;
	WMClearList(panel->fsetLs);
	if(!encoding) {
	array = getCurrentFontProp(panel, section);
	} else {
	array = getDefaultFontProp(panel, encoding, section);
	}
	if(!array){
		wwarning("error not Font prop given");
	} else {
	for (i = 0; i < WMGetPropListItemCount(array); i++) {
		WMGetFromPLArray(array, i);
		WMAddListItem( panel->fsetLs,
				WMGetFromPLString(
					WMGetFromPLArray(array, i)));
	}
	WMReleasePropList(array);
	WMSelectListItem(panel->fsetLs, 0);
	}

	checkListForArrows(panel);
}

static void
insertCurrentFont(char *data, char *type)
{
	WMPropList *key;
	WMPropList *array;
	char *tmp, *str;

	key = WMCreatePLString(type);
	array = WMCreatePLArray(NULL);

	str = wstrdup(data);
	tmp = strtok(str, ",");
	while(tmp) {
		WMAddToPLArray(array, WMCreatePLString(tmp));
		tmp = strtok(NULL, ",");
	}
	wfree(str);


	WMPutInPLDictionary(CurrentFontArray, key, array);
}

static void
readFontEncodings(void *data)
{
	_Panel *panel = (_Panel*)data;
    WMPropList *pl = NULL;
    char *path;
    char *msg;

    path = WMPathForResourceOfType("font.data", NULL);
    if (!path) {
	msg = _("Could not locate font information file WPrefs.app/font.data");
	goto error;
    }

    pl = WMReadPropListFromFile(path);
    if (!pl) {
	msg = _("Could not read font information file WPrefs.app/font.data");
	goto error;
    } else {
	int i;
	WMPropList *key = WMCreatePLString("Encodings");
	WMPropList *array;
	WMMenuItem *mi;

	array = WMGetFromPLDictionary(pl, key);
	WMReleasePropList(key);
	if (!array || !WMIsPLArray(array)) {
	    msg = _("Invalid data in font information file WPrefs.app/font.data.\n"
		    "Encodings data not found.");
	    goto error;
	}

	WMAddPopUpButtonItem(panel->langP, _("Current"));

	for (i = 0; i < WMGetPropListItemCount(array); i++) {
	    WMPropList *item, *str;

	    item = WMGetFromPLArray(array, i);
	    str = WMGetFromPLArray(item, 0);
	    mi = WMAddPopUpButtonItem(panel->langP, WMGetFromPLString(str));
	    WMSetMenuItemRepresentedObject(mi, WMRetainPropList(item));
	}
	WMSetPopUpButtonSelectedItem(panel->langP, 0);


	key = WMCreatePLString("WindowTitleFont");
	DefaultWindowTitleFont = WMRetainPropList(WMGetFromPLDictionary(pl, key));
	WMReleasePropList(key);

	key = WMCreatePLString("MenuTitleFont");
	DefaultMenuTitleFont = WMRetainPropList(WMGetFromPLDictionary(pl, key));
	WMReleasePropList(key);

	key = WMCreatePLString("MenuTextFont");
	DefaultMenuTextFont = WMRetainPropList(WMGetFromPLDictionary(pl, key));
	WMReleasePropList(key);

	key = WMCreatePLString("IconTitleFont");
	DefaultIconTitleFont = WMRetainPropList(WMGetFromPLDictionary(pl, key));
	WMReleasePropList(key);

	key = WMCreatePLString("ClipTitleFont");
	DefaultClipTitleFont = WMRetainPropList(WMGetFromPLDictionary(pl, key));
	WMReleasePropList(key);

	key = WMCreatePLString("LargeDisplayFont");
	DefaultLargeDisplayFont = WMRetainPropList(WMGetFromPLDictionary(pl, key));
	WMReleasePropList(key);
    }

    WMReleasePropList(pl);
    return;
error:
    if (pl)
	WMReleasePropList(pl);

    WMRunAlertPanel(WMWidgetScreen(panel->parent), panel->parent,
		    _("Error"), msg, _("OK"), NULL, NULL);
}

static void
checkListForArrows(void *data)
{
	_Panel *panel = (_Panel*)data;
	int list;
	list = WMGetListNumberOfRows(panel->fsetLs);

	if(list > 1)
	{
		if(WMGetListSelectedItemRow(panel->fsetLs) == 0) {
			WMSetButtonEnabled(panel->upB, False);
			WMSetButtonEnabled(panel->downB, True);
		} else if(WMGetListSelectedItemRow(panel->fsetLs) == list-1) {
			WMSetButtonEnabled(panel->downB, False);
			WMSetButtonEnabled(panel->upB, True);
		} else {
			WMSetButtonEnabled(panel->upB, True);
			WMSetButtonEnabled(panel->downB, True);
		}

	} else {
		WMSetButtonEnabled(panel->upB, False);
		WMSetButtonEnabled(panel->downB, False);
	}
	/* added to control the Remove button */
	if(list > 1)
		WMSetButtonEnabled(panel->remB, True);
	else
		WMSetButtonEnabled(panel->remB, False);
}

static char*
fontOfLang(void *data, char *encoding, int section)
{
	_Panel *panel = (_Panel*)data;
	WMPropList *array;
	char *buf = NULL;
	int i;

	if(!encoding)
	array = getCurrentFontProp(panel, section);
	else
	array = getDefaultFontProp(panel, encoding, section);

	if(!array) {
		wwarning("error no font prop given");
		return NULL;
	} else {
	for(i=0; i<WMGetPropListItemCount(array); i++)
	{
		if(buf) buf = wstrconcat(buf, ",");
		buf = wstrconcat(buf, WMGetFromPLString(WMGetFromPLArray(array, i)));
	}
	WMReleasePropList(array);
	return wstrdup(buf);
	}
}

static void
changeLanguageAction(WMWidget *w, void *data)
{
    Panel *panel = (Panel*)data;
    //WMScreen *scr = WMWidgetScreen(panel->box);
	int section;

	section = WMGetPopUpButtonSelectedItem(w);

	if(isEncodingMultiByte(panel)) {
		setLanguageType(panel, True);
	} else {
		if(panel->MultiByteText) setLanguageType(panel, True);
		else setLanguageType(panel, False);
	}

	paintPreviewBox(panel, EVERYTHING);
	changePage(panel->fontSel, panel);
}

static WMFont*
getFontForPreview(void *data, int element)
{
    _Panel *panel = (_Panel*)data;
	WMFont *font;
	char *fname;
    WMScreen *scr = WMWidgetScreen(panel->box);
	char *encoding = getFontEncoding(panel);
	fname = fontOfLang(panel, encoding, element);
	//if (WMHasAntialiasingSupport(scr)) {
		if(panel->AntialiasedText) {
            // fix this -Dan font = WMCreateFontWithFlags(scr, fname, WFAntialiased);
            font = WMCreateFont(scr, fname);
		} else {
			font = WMCreateFont(scr, fname);
		}
	//} else {
	//	font = WMCreateFont(scr, fname);
	//}
	if(!font) {
		char *msg;
		int length;
		length = strlen("\"")+
			strlen(fname)+strlen("\" was not loaded correctly.  Make sure the font is available for that encoding.\nLoadind default system font.");
		msg = wmalloc(length +1);
		snprintf(msg, length + 1,
				"\"%s\" was not loaded correctly.  Make sure the font is available for that encoding.\nLoading default system font.",
				fname);
		WMRunAlertPanel(WMWidgetScreen(panel->parent),panel->parent,
				_("Warning"), msg, _("OK"), NULL, NULL);
		font = getDefaultSystemFont(panel, element);
	}
	return font;
}

static char*
getFontSampleString(void *data)
{
	_Panel *panel = (_Panel*)data;
    //WMScreen *scr = WMWidgetScreen(panel->box);
    WMMenuItem *mi;
    WMPropList *pl;
	int section;

	section = WMGetPopUpButtonSelectedItem(panel->langP);
	mi = WMGetPopUpButtonMenuItem(panel->langP, section);
	pl = WMGetMenuItemRepresentedObject(mi);

	if (!pl) {
		return NULL;
	} else {
		char *sample;
		sample = WMGetFromPLString(WMGetFromPLArray(pl,3));
		return sample;
    }
}

static char*
getFontEncoding(void *data)
{
	_Panel *panel = (_Panel*)data;
    //WMScreen *scr = WMWidgetScreen(panel->box);
    WMMenuItem *mi;
    WMPropList *pl;
	int section;

	section = WMGetPopUpButtonSelectedItem(panel->langP);
	mi = WMGetPopUpButtonMenuItem(panel->langP, section);
	pl = WMGetMenuItemRepresentedObject(mi);

	if (!pl) {
		return NULL;
	} else {
		char *encoding;
		encoding = WMGetFromPLString(WMGetFromPLArray(pl,2));
		return encoding;
    }
}

static Bool
isEncodingMultiByte(void *data)
{
	_Panel *panel = (_Panel*)data;
    //WMScreen *scr = WMWidgetScreen(panel->box);
    WMMenuItem *mi;
    WMPropList *pl;
	int section;

	section = WMGetPopUpButtonSelectedItem(panel->langP);
	mi = WMGetPopUpButtonMenuItem(panel->langP, section);
	pl = WMGetMenuItemRepresentedObject(mi);

	if (!pl) {
		return False;
	} else {
		char *multiByte;
		int res;
		multiByte = WMGetFromPLString(WMGetFromPLArray(pl,1));
		res = atoi(multiByte);
		if(res)
			return True;
		else
			return False;
    }
}

static WMPropList*
getCurrentFontProp(void *data, int section)
{
	WMPropList *array;
	switch (section) {
		case 0:
			array = WMRetainPropList(
					WMGetFromPLDictionary(CurrentFontArray,
						WMCreatePLString("WindowTitleFont")));
			break;
		case 1:
			array = WMRetainPropList(
					WMGetFromPLDictionary(CurrentFontArray,
						WMCreatePLString("LargeDisplayFont")));
			break;
		case 2:
			array = WMRetainPropList(
					WMGetFromPLDictionary(CurrentFontArray,
						WMCreatePLString("MenuTitleFont")));
			break;
		case 3:
			array = WMRetainPropList(
					WMGetFromPLDictionary(CurrentFontArray,
						WMCreatePLString("MenuTextFont")));
			break;
		case 4:
			array = WMRetainPropList(
					WMGetFromPLDictionary(CurrentFontArray,
						WMCreatePLString("ClipTitleFont")));
			break;
		case 5:
			array = WMRetainPropList(
					WMGetFromPLDictionary(CurrentFontArray,
						WMCreatePLString("IconTitleFont")));
			break;
	}
	if(!WMIsPLArray(array)) {
		return NULL;
	} else {
		return array;
	}
}

static WMPropList*
getDefaultFontProp(void *data, char *encoding, int section)
{
	WMPropList *array;
	WMPropList *key = WMCreatePLString(encoding);
	switch (section) {
		case 0:
			array = WMRetainPropList(
					WMGetFromPLDictionary(DefaultWindowTitleFont, key));
			WMReleasePropList(key);
			break;
		case 1:
			array = WMRetainPropList(
					WMGetFromPLDictionary(DefaultLargeDisplayFont, key));
			WMReleasePropList(key);
			break;
		case 2:
			array = WMRetainPropList(
					WMGetFromPLDictionary(DefaultMenuTitleFont, key));
			WMReleasePropList(key);
			break;
		case 3:
			array = WMRetainPropList(
					WMGetFromPLDictionary(DefaultMenuTextFont, key));
			WMReleasePropList(key);
			break;
		case 4:
			array = WMRetainPropList(
					WMGetFromPLDictionary(DefaultClipTitleFont, key));
			WMReleasePropList(key);
			break;
		case 5:
			array = WMRetainPropList(
					WMGetFromPLDictionary(DefaultIconTitleFont, key));
			WMReleasePropList(key);
			break;
	}
	if(!WMIsPLArray(array)) {
		return NULL;
	} else {
		return array;
	}
}

static WMFont*
getDefaultSystemFont(void *data, int element)
{
    _Panel *panel = (_Panel*)data;
    WMScreen *scr = WMWidgetScreen(panel->box);

    switch(element) {
    case 0:
    case 2:
        return WMBoldSystemFontOfSize(scr, 12);
    case 1:
        return WMBoldSystemFontOfSize(scr, 24);
    case 4:
    case 5:
        return WMSystemFontOfSize(scr, 8);
    case 3:
    default:
        return WMSystemFontOfSize(scr, 12);
    }
}

static void
multiClick(WMWidget *w, void *data)
{
	_Panel *panel = (_Panel*)data;
	if(!panel->MultiByteText) {
		WMSetButtonText(panel->togMulti, _("Yes"));
		setLanguageType(panel, True);
		panel->MultiByteText = True;
	} else {
		WMSetButtonText(panel->togMulti, _("Auto"));
		if(isEncodingMultiByte(panel)) setLanguageType(panel, True);
		else setLanguageType(panel, False);
		panel->MultiByteText = False;
	}
}

static void
toggleAA(WMWidget *w, void *data)
{
	_Panel *panel = (_Panel*)data;
	//int section;
	if(panel->AntialiasedText)
		panel->AntialiasedText = False;
	else
		panel->AntialiasedText = True;
	/* hmm now i gotta redraw all the fonts in the preview section
	 * and the text field
	 */
	paintPreviewBox(panel, EVERYTHING);
	changePage(panel->fontSel, panel);
	if(isEncodingMultiByte(panel)) setLanguageType(panel, True);
}

static void
listClick(WMWidget *w, void *data)
{
	_Panel *panel = (_Panel*)data;

	checkListForArrows(panel);
}

static void
moveUpListItem(WMWidget *w, void *data)
{
	_Panel *panel = (_Panel*)data;
	WMListItem *tmp;
	int pos;
	char *listtext;
	WMPropList *array;
	WMPropList *string;
	char *encoding = getFontEncoding(panel);
	int section = WMGetPopUpButtonSelectedItem(panel->fontSel);

	if(!encoding)
	array = getCurrentFontProp(panel, section);
	else
	array = getDefaultFontProp(panel, encoding, section);

	pos = WMGetListSelectedItemRow(panel->fsetLs);

	tmp = WMGetListItem(panel->fsetLs, pos);
	listtext = wstrdup(tmp->text);
	string = WMCreatePLString(listtext);

	WMRemoveListItem(panel->fsetLs, pos);
	WMDeleteFromPLArray(array, pos);
	WMInsertListItem(panel->fsetLs, pos-1, listtext);
	WMInsertInPLArray(array, pos-1, string);

	paintPreviewBox(panel, EVERYTHING);
	changePage(panel->fontSel, panel);

	WMSelectListItem(panel->fsetLs, pos-1);
	checkListForArrows(panel);
}

static void
moveDownListItem(WMWidget *w, void *data)
{
	_Panel *panel = (_Panel*)data;
	WMListItem *tmp;
	int pos;
	char *listtext;
	WMPropList *array;
	WMPropList *string;
	char *encoding = getFontEncoding(panel);
	int section = WMGetPopUpButtonSelectedItem(panel->fontSel);

	if(!encoding)
	array = getCurrentFontProp(panel, section);
	else
	array = getDefaultFontProp(panel, encoding, section);

	pos = WMGetListSelectedItemRow(panel->fsetLs);

	tmp = WMGetListItem(panel->fsetLs, pos);
	listtext = wstrdup(tmp->text);
	string = WMCreatePLString(listtext);
	WMRemoveListItem(panel->fsetLs, pos);
	WMDeleteFromPLArray(array, pos);
	WMInsertListItem(panel->fsetLs, pos+1, listtext);
	WMInsertInPLArray(array, pos+1, string);

	paintPreviewBox(panel, EVERYTHING);
	changePage(panel->fontSel, panel);

	WMSelectListItem(panel->fsetLs, pos+1);
	checkListForArrows(panel);
}

static void
addButtonAction(WMWidget *w, void *data)
{
	_Panel *panel = (_Panel*)data;
	char *chosenFont;
	int pos;
	WMPropList *array;
	WMPropList *string;
	char *encoding = getFontEncoding(panel);
	int section = WMGetPopUpButtonSelectedItem(panel->fontSel);

	if(!encoding)
	array = getCurrentFontProp(panel, section);
	else
	array = getDefaultFontProp(panel, encoding, section);

	WMHideFontPanel(panel->fontPanel);
	chosenFont = WMGetFontName(WMGetFontPanelFont(panel->fontPanel));
	string = WMCreatePLString(chosenFont);
	pos = WMGetListSelectedItemRow(panel->fsetLs);
	WMInsertListItem(panel->fsetLs, pos+1, chosenFont);
	WMInsertInPLArray(array, pos+1, string);
	WMSelectListItem(panel->fsetLs, pos+1);

	paintPreviewBox(panel, EVERYTHING);
	changePage(panel->fontSel, panel);
}

static void
changeButtonAction(WMWidget *w, void *data)
{
	_Panel *panel = (_Panel*)data;
	char *chosenFont;
	int pos;
	WMPropList *array;
	WMPropList *string;
	char *encoding = getFontEncoding(panel);
	int section = WMGetPopUpButtonSelectedItem(panel->fontSel);

	if(!encoding)
	array = getCurrentFontProp(panel, section);
	else
	array = getDefaultFontProp(panel, encoding, section);

	WMHideFontPanel(panel->fontPanel);

	chosenFont = WMGetFontName(WMGetFontPanelFont(panel->fontPanel));
	string = WMCreatePLString(chosenFont);

	pos = WMGetListSelectedItemRow(panel->fsetLs);
	WMRemoveListItem(panel->fsetLs, pos);
	WMDeleteFromPLArray(array, pos);
	WMInsertListItem(panel->fsetLs, pos, chosenFont);
	WMInsertInPLArray(array, pos, string);
	WMSelectListItem(panel->fsetLs, pos);

	paintPreviewBox(panel, EVERYTHING);
	changePage(panel->fontSel, panel);
}

static void
changeButtonClick(WMWidget *w, void *data)
{
	_Panel *panel = (_Panel*)data;

	WMSetFontPanelAction(panel->fontPanel, changeButtonAction, panel);
	WMShowFontPanel(panel->fontPanel);
}

static void
addButtonClick(WMWidget *w, void *data)
{
	_Panel *panel = (_Panel*)data;

	WMSetFontPanelAction(panel->fontPanel, addButtonAction, panel);
	WMShowFontPanel(panel->fontPanel);
}

static void
removeButtonClick(WMWidget *w, void *data)
{
	_Panel *panel = (_Panel*)data;
	int pos;
	int list;
	WMPropList *array;
	char *encoding = getFontEncoding(panel);
	int section = WMGetPopUpButtonSelectedItem(panel->fontSel);

	if(!encoding)
	array = getCurrentFontProp(panel, section);
	else
	array = getDefaultFontProp(panel, encoding, section);

	pos = WMGetListSelectedItemRow(panel->fsetLs);
	WMRemoveListItem(panel->fsetLs, pos);
	WMDeleteFromPLArray(array, pos);

	list = WMGetListNumberOfRows(panel->fsetLs);
	if(list != 0) {
	if(list > pos)
		WMSelectListItem(panel->fsetLs, pos);
	else if(list == pos)
		WMSelectListItem(panel->fsetLs, list-1);
	else
		WMSelectListItem(panel->fsetLs, 0);
	}
	checkListForArrows(panel);

	paintPreviewBox(panel, EVERYTHING);
	changePage(panel->fontSel, panel);
}

static void
showData(_Panel *panel)
{
    //WMScreen *scr = WMWidgetScreen(panel->parent);
    char *str;
	int i;

	CurrentFontArray = WMCreatePLDictionary(NULL, NULL);

    str = GetStringForKey("WindowTitleFont");
	insertCurrentFont(wstrdup(str), "WindowTitleFont");

	str = GetStringForKey("LargeDisplayFont");
	insertCurrentFont(wstrdup(str), "LargeDisplayFont");

    str = GetStringForKey("MenuTitleFont");
	insertCurrentFont(wstrdup(str), "MenuTitleFont");

    str = GetStringForKey("MenuTextFont");
	insertCurrentFont(wstrdup(str), "MenuTextFont");

	str = GetStringForKey("ClipTitleFont");
	insertCurrentFont(wstrdup(str), "ClipTitleFont");

	str = GetStringForKey("IconTitleFont");
	insertCurrentFont(wstrdup(str), "IconTitleFont");

	/* i put this here cause it needs to be known before we paint */
    readFontEncodings(panel);

    str = GetStringForKey("MenuStyle");
    if (str && strcasecmp(str, "flat")==0) {
	panel->menuStyle = MSTYLE_FLAT;
    } else if (str && strcasecmp(str, "singletexture")==0) {
	panel->menuStyle = MSTYLE_SINGLE;
    } else {
	panel->menuStyle = MSTYLE_NORMAL;
    }

    str = GetStringForKey("TitleJustify");
    if (str && strcasecmp(str, "left")==0) {
	panel->titleAlignment = WALeft;
    } else if (str && strcasecmp(str, "right")==0) {
	panel->titleAlignment = WARight;
    } else {
	panel->titleAlignment = WACenter;
    }
    for (i = 0; i < sizeof(colorOptions)/(2*sizeof(char*)); i++) {
	WMColor *color;

	str = GetStringForKey(colorOptions[i*2]);
	if (!str)
	    str = colorOptions[i*2+1];

	if (!(color = WMCreateNamedColor(WMWidgetScreen(panel->box), str, False))) {
	    color = WMCreateNamedColor(WMWidgetScreen(panel->box), "#000000", False);
	}
	panel->colors[i] = color;
    }

	str = GetStringForKey("MultiByteText");
	if (str)
	{
		if (strcasecmp(str, "YES")==0) {
			setLanguageType(panel, True);
			WMSetButtonText(panel->togMulti, "Yes");
			printf("yes multi\n");
			panel->MultiByteText = True;
		} else if (strcasecmp(str, "AUTO") == 0) {
			char *locale;
			locale = setlocale(LC_CTYPE, NULL);
			if(locale != NULL
				&& (strncmp(locale, "ja", 2) == 0
				|| strncmp(locale, "zh", 2) == 0
				|| strncmp(locale, "ko", 2) == 0)) {
				setLanguageType(panel, True);
				WMSetButtonText(panel->togMulti, "Auto");
				printf("auto multi\n");
				panel->MultiByteText = True;
			} else {
				setLanguageType(panel, False);
				WMSetButtonText(panel->togMulti, "Auto");
				panel->MultiByteText = False;
			}
		}
	} else {
		char *locale;
		locale = setlocale(LC_CTYPE, NULL);
		if(locale != NULL
		&& (strncmp(locale, "ja", 2) == 0
		|| strncmp(locale, "zh", 2) == 0
		|| strncmp(locale, "ko", 2) == 0)) {
			setLanguageType(panel, True);
			WMSetButtonText(panel->togMulti, "Auto");
			printf("auto multi\n");
			panel->MultiByteText = True;
		} else {
			setLanguageType(panel, False);
			WMSetButtonText(panel->togMulti, "Auto");
			panel->MultiByteText = False;
		}
	}
	/* gotta check for Antialiasing AFTER MultiByte incase the use has both
	 * to maintain behavior in Current Fonts set or i could add another if
	 * statement to setLanguageType =) */
	//if (WMHasAntialiasingSupport(scr)) {
		WMMapWidget(panel->togAA);
		if(GetBoolForKey("AntialiasedText")){
		WMSetButtonSelected(panel->togAA, True);
		panel->AntialiasedText = True;
		} else {
		WMSetButtonSelected(panel->togAA, False);
		panel->AntialiasedText = False;
		}
	//} else {
	//	WMUnmapWidget(panel->togAA);
	//}


    paintPreviewBox(panel, EVERYTHING);
}

static void
createPanel(Panel *p)
{
    _Panel *panel = (_Panel*)p;
    WMScreen *scr = WMWidgetScreen(panel->parent);


    panel->box = WMCreateBox(panel->parent);
    WMSetViewExpandsToParent(WMWidgetView(panel->box), 2, 2, 2, 2);

	panel->hand = WMCreatePixmapFromXPMData(scr, hand_xpm);
	panel->up_arrow = WMCreatePixmapFromXPMData(scr, up_arrow_xpm);
	panel->down_arrow = WMCreatePixmapFromXPMData(scr, down_arrow_xpm);
	panel->alt_up_arrow = WMCreatePixmapFromXPMData(scr, alt_up_arrow_xpm);
	panel->alt_down_arrow = WMCreatePixmapFromXPMData(scr, alt_down_arrow_xpm);

    panel->prevL = WMCreateLabel(panel->box);
    WMResizeWidget(panel->prevL, 240, FRAME_HEIGHT - 45);
    WMMoveWidget(panel->prevL, 15, 35);
    WMSetLabelRelief(panel->prevL, WRSunken);
    WMSetLabelImagePosition(panel->prevL, WIPImageOnly);

	WMCreateEventHandler(WMWidgetView(panel->prevL), ButtonPressMask,
					previewClick, panel);

	/* Widget Selection */
	panel->fontSel = WMCreatePopUpButton(panel->box);
	WMResizeWidget(panel->fontSel, 135, 20);
	WMMoveWidget(panel->fontSel, 15, 10);
	WMAddPopUpButtonItem(panel->fontSel, _("Window Title Font"));
	WMAddPopUpButtonItem(panel->fontSel, _("Large Display Font"));
	WMAddPopUpButtonItem(panel->fontSel, _("Menu Title Font"));
	WMAddPopUpButtonItem(panel->fontSel, _("Menu Item Font" ));
	WMAddPopUpButtonItem(panel->fontSel, _("Clip Title Font"));
	WMAddPopUpButtonItem(panel->fontSel, _("Icon Title Font"));

	WMSetPopUpButtonSelectedItem(panel->fontSel, 0);

	WMSetPopUpButtonAction(panel->fontSel, changePage, panel);

	/* MultiByteText toggle */
	panel->multiF = WMCreateFrame(panel->box);
	WMResizeWidget(panel->multiF, 70, 50);
	WMMoveWidget(panel->multiF, 440, 10);
	WMSetFrameTitle(panel->multiF, _("MultiByte"));


	panel->togMulti = WMCreateCommandButton(panel->multiF);
	WMResizeWidget(panel->togMulti, 40, 20);
	WMMoveWidget(panel->togMulti, 15, 20);
	WMSetButtonAction(panel->togMulti, multiClick, panel);

	WMMapSubwidgets(panel->multiF);

    /* language selection */
    panel->langF = WMCreateFrame(panel->box);
    WMResizeWidget(panel->langF, 165, 50);
    WMMoveWidget(panel->langF, 265, 10);
    WMSetFrameTitle(panel->langF, _("Default Font Encodings"));

    panel->langP = WMCreatePopUpButton(panel->langF);
    WMResizeWidget(panel->langP, 135, 20);
    WMMoveWidget(panel->langP, 15, 20);

	WMSetPopUpButtonAction(panel->langP, changeLanguageAction, panel);

    WMMapSubwidgets(panel->langF);

	/* Antialiasing */
	//if (WMHasAntialiasingSupport(scr)) {
        panel->togAA = WMCreateSwitchButton(panel->box);
        WMResizeWidget(panel->togAA, 110, 20);
        WMMoveWidget(panel->togAA, 155, 10);
        WMSetButtonText(panel->togAA, _("Smooth Fonts"));
        WMSetBalloonTextForView(_("Smooth Font edges for the eye candy\n"
                                  "requires a restart after saving"),
                                WMWidgetView(panel->togAA));
        WMSetButtonAction(panel->togAA, toggleAA, panel);
	//}
    /* multibyte */
    panel->fsetL = WMCreateLabel(panel->box);
    WMResizeWidget(panel->fsetL, 245, 20);
    WMMoveWidget(panel->fsetL, 265, 70);
    WMSetLabelText(panel->fsetL, _("Font Set"));
    WMSetLabelRelief(panel->fsetL, WRSunken);
    WMSetLabelTextAlignment(panel->fsetL, WACenter);
    {
	WMFont *font;
	WMColor *color;

	color = WMDarkGrayColor(scr);
	font = WMBoldSystemFontOfSize(scr, 12);

	WMSetWidgetBackgroundColor(panel->fsetL, color);
	WMSetLabelFont(panel->fsetL, font);

	WMReleaseFont(font);
	WMReleaseColor(color);

	color = WMWhiteColor(scr);
	WMSetLabelTextColor(panel->fsetL, color);
	WMReleaseColor(color);
    }

    panel->fsetLs = WMCreateList(panel->box);
    WMResizeWidget(panel->fsetLs, 245, 86);
    WMMoveWidget(panel->fsetLs, 265, 92);
	WMSetListAction(panel->fsetLs, listClick, panel);
	WMSetListDoubleAction(panel->fsetLs, changeButtonClick, panel);

    panel->addB = WMCreateCommandButton(panel->box);
    WMResizeWidget(panel->addB, 78, 24);
    WMMoveWidget(panel->addB, 265, 201);
    WMSetButtonText(panel->addB, _("Add..."));
	WMSetButtonAction(panel->addB, addButtonClick, panel);

    panel->editB = WMCreateCommandButton(panel->box);
    WMResizeWidget(panel->editB, 78, 24);
    WMMoveWidget(panel->editB, 348, 201);
    WMSetButtonText(panel->editB, _("Change..."));
	WMSetButtonAction(panel->editB, changeButtonClick, panel);

    panel->remB = WMCreateCommandButton(panel->box);
    WMResizeWidget(panel->remB, 78, 24);
    WMMoveWidget(panel->remB, 431, 201);
    WMSetButtonText(panel->remB, _("Remove"));
	WMSetButtonAction(panel->remB, removeButtonClick, panel);

	/* happy Up/Down buttons */
	panel->upB = WMCreateCommandButton(panel->box);
	WMResizeWidget(panel->upB, 16, 16);
	WMMoveWidget(panel->upB, 265, 182);
	WMSetButtonImage(panel->upB, panel->up_arrow);
	WMSetButtonAltImage(panel->upB, panel->alt_up_arrow);
	WMSetButtonImagePosition(panel->upB, WIPImageOnly);
	WMSetButtonImageDimsWhenDisabled(panel->upB, True);
	WMSetButtonAction(panel->upB, moveUpListItem, panel);

	panel->downB = WMCreateCommandButton(panel->box);
	WMResizeWidget(panel->downB, 16, 16);
	WMMoveWidget(panel->downB, 286, 182);
	WMSetButtonImage(panel->downB, panel->down_arrow);
	WMSetButtonAltImage(panel->downB, panel->alt_down_arrow);
	WMSetButtonImagePosition(panel->downB, WIPImageOnly);
	WMSetButtonImageDimsWhenDisabled(panel->downB, True);
	WMSetButtonAction(panel->downB, moveDownListItem, panel);

    /* single byte */
    panel->fontT = WMCreateTextField(panel->box);
    WMResizeWidget(panel->fontT, 245, 30);
    WMMoveWidget(panel->fontT, 265, 120);

    panel->changeB = WMCreateCommandButton(panel->box);
    WMResizeWidget(panel->changeB, 104, 24);
    WMMoveWidget(panel->changeB, 335, 160);
    WMSetButtonText(panel->changeB, _("Change..."));
	WMSetButtonAction(panel->changeB, changeButtonClick, panel);


    panel->black = WMBlackColor(scr);
    panel->white = WMWhiteColor(scr);
    panel->light = WMGrayColor(scr);
    panel->dark = WMDarkGrayColor(scr);
    panel->back = WMCreateRGBColor(scr, 0x5100, 0x5100, 0x7100, True);

	/* Font Panel !!!!! */
	panel->fontPanel = WMGetFontPanel(scr);

#if 0
    for (i = 0; Languages[i].language != NULL; i++) {
	WMAddPopUpButtonItem(panel->langP, Languages[i].language);
    }

    for (i = 0; Options[i].description != NULL; i++) {
	WMAddListItem(panel->settingLs, Options[i].description);
    }
#endif
    WMRealizeWidget(panel->box);
    WMMapSubwidgets(panel->box);

    showData(panel);
	changePage(panel->fontSel, panel);
}

static void
storeData(Panel *p)
{
	_Panel *panel = (_Panel*)p;
	int i;

	char *encoding = getFontEncoding(panel);

	for(i=0;i < 6; i++)
	{
		switch(i) {
			case 0:
				SetStringForKey(fontOfLang(panel, encoding, i),
						"WindowTitleFont");
				break;
			case 1:
				SetStringForKey(fontOfLang(panel, encoding, i),
						"LargeDisplayFont");
				break;
			case 2:
				SetStringForKey(fontOfLang(panel, encoding, i),
						"MenuTitleFont");
				break;
			case 3:
				SetStringForKey(fontOfLang(panel, encoding, i),
						"MenuTextFont");
				break;
			case 4:
				SetStringForKey(fontOfLang(panel, encoding, i),
						"ClipTitleFont");
				break;
			case 5:
				SetStringForKey(fontOfLang(panel, encoding, i),
						"IconTitleFont");
				break;
		}
	}

	//if (WMHasAntialiasingSupport(WMWidgetScreen(panel->box)))
		SetBoolForKey(WMGetButtonSelected(panel->togAA), "AntialiasedText");

	if(panel->MultiByteText)
		SetStringForKey("YES", "MultiByteText");
	else {
		if(isEncodingMultiByte(panel)) SetStringForKey("YES", "MultiByteText");
		else SetStringForKey("AUTO", "MultiByteText");
	}
}

static void
prepClosure(Panel *p)
{
    _Panel *panel = (_Panel*)p;
	WMFreeFontPanel(panel->fontPanel);
	WMReleasePropList(CurrentFontArray);
	/* and what ever else i've forgotten or overlooked
	 * maybe someone will add them */
}

Panel*
InitFont(WMScreen *scr, WMWidget *parent)
{
    _Panel *panel;

    panel = wmalloc(sizeof(_Panel));
    memset(panel, 0, sizeof(_Panel));

    panel->sectionName = _("Font Preferences");
    panel->description = _("Font Configurations for Windows, Menus etc");

    panel->parent = parent;

    panel->callbacks.createWidgets = createPanel;
	panel->callbacks.updateDomain = storeData;
	panel->callbacks.prepareForClose = prepClosure;

    AddSection(panel, ICON_FILE);

    return panel;
}