mirror of
https://github.com/gryf/wmaker.git
synced 2025-12-20 21:08:08 +01:00
655 lines
15 KiB
C
655 lines
15 KiB
C
|
|
|
|
|
|
|
|
#include "WINGsP.h"
|
|
|
|
#include <strings.h>
|
|
|
|
|
|
typedef struct W_FontPanel {
|
|
WMWindow *win;
|
|
|
|
WMFrame *upperF;
|
|
WMLabel *sampleL;
|
|
|
|
WMSplitView *split;
|
|
|
|
WMFrame *lowerF;
|
|
WMLabel *famL;
|
|
WMList *famLs;
|
|
WMLabel *typL;
|
|
WMList *typLs;
|
|
WMLabel *sizL;
|
|
WMTextField *sizT;
|
|
WMList *sizLs;
|
|
|
|
WMFrame *xlfdF;
|
|
WMTextField *xlfdT;
|
|
|
|
WMFrame *encF;
|
|
WMPopUpButton *encP;
|
|
|
|
WMButton *revertB;
|
|
WMButton *previewB;
|
|
WMButton *setB;
|
|
|
|
proplist_t fdb;
|
|
} FontPanel;
|
|
|
|
|
|
#define MIN_UPPER_HEIGHT 20
|
|
#define MIN_LOWER_HEIGHT 140
|
|
|
|
|
|
#define MAX_FONTS_TO_RETRIEVE 2000
|
|
|
|
|
|
#define MIN_WIDTH 250
|
|
#define MIN_HEIGHT MIN_UPPER_HEIGHT+MIN_LOWER_HEIGHT+70
|
|
|
|
/*
|
|
static char *scalableFontSizes[] = {
|
|
"8",
|
|
"10",
|
|
"11",
|
|
"12",
|
|
"14",
|
|
"16",
|
|
"18",
|
|
"20",
|
|
"24",
|
|
"36",
|
|
"48",
|
|
"64"
|
|
};
|
|
*/
|
|
|
|
|
|
|
|
|
|
static void arrangeLowerFrame(FontPanel *panel);
|
|
|
|
static proplist_t createFontDatabase(WMScreen *scr);
|
|
|
|
static void listFamilies(proplist_t fdb, WMList *list);
|
|
|
|
static void
|
|
splitViewConstrainCallback(WMSplitView *sPtr, int divIndex, int *min, int *max)
|
|
{
|
|
*min = MIN_UPPER_HEIGHT;
|
|
*max = WMWidgetHeight(sPtr)-WMGetSplitViewDividerThickness(sPtr)-MIN_LOWER_HEIGHT;
|
|
}
|
|
|
|
|
|
static void
|
|
notificationObserver(void *self, WMNotification *notif)
|
|
{
|
|
WMFontPanel *panel = (WMFontPanel*)self;
|
|
void *object = WMGetNotificationObject(notif);
|
|
|
|
if (WMGetNotificationName(notif) == WMViewSizeDidChangeNotification) {
|
|
if (object == WMWidgetView(panel->win)) {
|
|
int h = WMWidgetHeight(panel->win);
|
|
int w = WMWidgetWidth(panel->win);
|
|
|
|
WMResizeWidget(panel->split, w, h-40);
|
|
|
|
WMMoveWidget(panel->setB, w-80, h-35);
|
|
WMMoveWidget(panel->previewB, w-160, h-35);
|
|
WMMoveWidget(panel->revertB, w-240, h-35);
|
|
} else if (object == WMWidgetView(panel->upperF)) {
|
|
WMResizeWidget(panel->sampleL, WMWidgetWidth(panel->upperF)-20,
|
|
WMWidgetHeight(panel->upperF)-10);
|
|
} else if (object == WMWidgetView(panel->lowerF)) {
|
|
|
|
if (WMWidgetHeight(panel->lowerF) < MIN_LOWER_HEIGHT) {
|
|
int h;
|
|
|
|
h = WMWidgetHeight(panel->split)-MIN_LOWER_HEIGHT
|
|
- WMGetSplitViewDividerThickness(panel->split);
|
|
|
|
WMResizeWidget(panel->upperF, WMWidgetWidth(panel->upperF), h);
|
|
|
|
WMMoveWidget(panel->lowerF, 0, WMWidgetHeight(panel->upperF)
|
|
+ WMGetSplitViewDividerThickness(panel->split));
|
|
WMResizeWidget(panel->lowerF, WMWidgetWidth(panel->lowerF),
|
|
MIN_LOWER_HEIGHT);
|
|
} else {
|
|
arrangeLowerFrame(panel);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
static void
|
|
familyClick(WMWidget *w, void *data)
|
|
{
|
|
WMList *lPtr = (WMList*)w;
|
|
FontPanel *panel = (FontPanel*)data;
|
|
|
|
|
|
|
|
}
|
|
*/
|
|
|
|
WMFontPanel*
|
|
WMGetFontPanel(WMScreen *scr)
|
|
{
|
|
FontPanel *panel;
|
|
WMColor *dark, *white;
|
|
WMFont *font;
|
|
int divThickness;
|
|
|
|
if (scr->sharedFontPanel)
|
|
return scr->sharedFontPanel;
|
|
|
|
|
|
panel = wmalloc(sizeof(FontPanel));
|
|
memset(panel, 0, sizeof(FontPanel));
|
|
|
|
panel->win = WMCreateWindow(scr, "fontPanel");
|
|
WMResizeWidget(panel->win, 320, 370);
|
|
WMSetWindowMinSize(panel->win, MIN_WIDTH, MIN_HEIGHT);
|
|
WMSetViewNotifySizeChanges(WMWidgetView(panel->win), True);
|
|
|
|
panel->split = WMCreateSplitView(panel->win);
|
|
WMResizeWidget(panel->split, 320, 330);
|
|
WMSetSplitViewConstrainProc(panel->split, splitViewConstrainCallback);
|
|
|
|
divThickness = WMGetSplitViewDividerThickness(panel->split);
|
|
|
|
panel->upperF = WMCreateFrame(panel->win);
|
|
WMSetFrameRelief(panel->upperF, WRFlat);
|
|
WMSetViewNotifySizeChanges(WMWidgetView(panel->upperF), True);
|
|
panel->lowerF = WMCreateFrame(panel->win);
|
|
WMSetFrameRelief(panel->lowerF, WRFlat);
|
|
WMSetViewNotifySizeChanges(WMWidgetView(panel->lowerF), True);
|
|
|
|
WMAddSplitViewSubview(panel->split, W_VIEW(panel->upperF));
|
|
WMAddSplitViewSubview(panel->split, W_VIEW(panel->lowerF));
|
|
|
|
WMResizeWidget(panel->upperF, 320, 60);
|
|
WMResizeWidget(panel->lowerF, 320, 330-60-divThickness);
|
|
WMMoveWidget(panel->lowerF, 0, 60+divThickness);
|
|
|
|
white = WMWhiteColor(scr);
|
|
dark = WMDarkGrayColor(scr);
|
|
|
|
panel->sampleL = WMCreateLabel(panel->upperF);
|
|
WMResizeWidget(panel->sampleL, 300, 50);
|
|
WMMoveWidget(panel->sampleL, 10, 10);
|
|
WMSetWidgetBackgroundColor(panel->sampleL, white);
|
|
WMSetLabelRelief(panel->sampleL, WRSunken);
|
|
WMSetLabelText(panel->sampleL, "It is not yet completed!!!");
|
|
|
|
font = WMBoldSystemFontOfSize(scr, 12);
|
|
|
|
panel->famL = WMCreateLabel(panel->lowerF);
|
|
WMSetWidgetBackgroundColor(panel->famL, dark);
|
|
WMSetLabelText(panel->famL, "Family");
|
|
WMSetLabelFont(panel->famL, font);
|
|
WMSetLabelTextColor(panel->famL, white);
|
|
WMSetLabelRelief(panel->famL, WRSunken);
|
|
WMSetLabelTextAlignment(panel->famL, WACenter);
|
|
|
|
panel->famLs = WMCreateList(panel->lowerF);
|
|
|
|
panel->typL = WMCreateLabel(panel->lowerF);
|
|
WMSetWidgetBackgroundColor(panel->typL, dark);
|
|
WMSetLabelText(panel->typL, "Typeface");
|
|
WMSetLabelFont(panel->typL, font);
|
|
WMSetLabelTextColor(panel->typL, white);
|
|
WMSetLabelRelief(panel->typL, WRSunken);
|
|
WMSetLabelTextAlignment(panel->typL, WACenter);
|
|
|
|
panel->typLs = WMCreateList(panel->lowerF);
|
|
|
|
panel->sizL = WMCreateLabel(panel->lowerF);
|
|
WMSetWidgetBackgroundColor(panel->sizL, dark);
|
|
WMSetLabelText(panel->sizL, "Size");
|
|
WMSetLabelFont(panel->sizL, font);
|
|
WMSetLabelTextColor(panel->sizL, white);
|
|
WMSetLabelRelief(panel->sizL, WRSunken);
|
|
WMSetLabelTextAlignment(panel->sizL, WACenter);
|
|
|
|
panel->sizT = WMCreateTextField(panel->lowerF);
|
|
|
|
panel->sizLs = WMCreateList(panel->lowerF);
|
|
|
|
WMReleaseFont(font);
|
|
WMReleaseColor(white);
|
|
WMReleaseColor(dark);
|
|
|
|
panel->encF = WMCreateFrame(panel->lowerF);
|
|
WMSetFrameTitle(panel->encF, "Encoding");
|
|
WMResizeWidget(panel->encF, 130, 50);
|
|
|
|
panel->encP = WMCreatePopUpButton(panel->encF);
|
|
WMMoveWidget(panel->encP, 10, 20);
|
|
WMResizeWidget(panel->encP, 112, 20);
|
|
|
|
WMMapSubwidgets(panel->encF);
|
|
|
|
panel->xlfdF = WMCreateFrame(panel->lowerF);
|
|
WMSetFrameTitle(panel->xlfdF, "Xtra Long Font Description");
|
|
|
|
panel->xlfdT = WMCreateTextField(panel->xlfdF);
|
|
WMMoveWidget(panel->xlfdT, 10, 20);
|
|
|
|
WMMapSubwidgets(panel->xlfdF);
|
|
|
|
arrangeLowerFrame(panel);
|
|
|
|
panel->setB = WMCreateCommandButton(panel->win);
|
|
WMResizeWidget(panel->setB, 70, 24);
|
|
WMMoveWidget(panel->setB, 240, 335);
|
|
WMSetButtonText(panel->setB, "Set");
|
|
|
|
panel->previewB = WMCreateCommandButton(panel->win);
|
|
WMResizeWidget(panel->previewB, 70, 24);
|
|
WMMoveWidget(panel->previewB, 160, 335);
|
|
WMSetButtonText(panel->previewB, "Preview");
|
|
|
|
panel->revertB = WMCreateCommandButton(panel->win);
|
|
WMResizeWidget(panel->revertB, 70, 24);
|
|
WMMoveWidget(panel->revertB, 80, 335);
|
|
WMSetButtonText(panel->revertB, "Revert");
|
|
|
|
WMRealizeWidget(panel->win);
|
|
|
|
WMMapSubwidgets(panel->upperF);
|
|
WMMapSubwidgets(panel->lowerF);
|
|
WMMapSubwidgets(panel->split);
|
|
WMMapSubwidgets(panel->win);
|
|
|
|
scr->sharedFontPanel = panel;
|
|
|
|
|
|
/* register notification observers */
|
|
WMAddNotificationObserver(notificationObserver, panel,
|
|
WMViewSizeDidChangeNotification,
|
|
WMWidgetView(panel->win));
|
|
WMAddNotificationObserver(notificationObserver, panel,
|
|
WMViewSizeDidChangeNotification,
|
|
WMWidgetView(panel->upperF));
|
|
WMAddNotificationObserver(notificationObserver, panel,
|
|
WMViewSizeDidChangeNotification,
|
|
WMWidgetView(panel->lowerF));
|
|
|
|
panel->fdb = createFontDatabase(scr);
|
|
listFamilies(panel->fdb, panel->famLs);
|
|
|
|
return panel;
|
|
}
|
|
|
|
|
|
void
|
|
WMFreeFontPanel(WMFontPanel *panel)
|
|
{
|
|
if (panel == WMWidgetScreen(panel->win)->sharedFontPanel) {
|
|
WMWidgetScreen(panel->win)->sharedFontPanel = NULL;
|
|
}
|
|
WMRemoveNotificationObserver(panel);
|
|
WMUnmapWidget(panel->win);
|
|
WMDestroyWidget(panel->win);
|
|
free(panel);
|
|
}
|
|
|
|
|
|
void
|
|
WMShowFontPanel(WMFontPanel *panel)
|
|
{
|
|
WMMapWidget(panel->win);
|
|
}
|
|
|
|
void
|
|
WMHideFontPanel(WMFontPanel *panel)
|
|
{
|
|
WMUnmapWidget(panel->win);
|
|
}
|
|
|
|
|
|
void
|
|
WMSetFontPanelFont(WMFontPanel *panel, WMFont *font)
|
|
{
|
|
}
|
|
|
|
|
|
WMFont*
|
|
WMGetFontPanelFont(WMFontPanel *panel)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
|
|
char*
|
|
WMGetFontPanelFontName(WMFontPanel *panel)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
arrangeLowerFrame(FontPanel *panel)
|
|
{
|
|
int width = WMWidgetWidth(panel->lowerF) - 55 - 30;
|
|
int height = WMWidgetHeight(panel->lowerF);
|
|
int oheight = 330-60-WMGetSplitViewDividerThickness(panel->split);
|
|
int fw, tw, sw;
|
|
int h;
|
|
|
|
height -= 20 + 3 + 10 + 50;
|
|
oheight -= 20 + 3 + 10 + 50;
|
|
|
|
fw = (125*width) / 235;
|
|
tw = (110*width) / 235;
|
|
sw = 55;
|
|
|
|
h = (174*height) / oheight;
|
|
|
|
WMMoveWidget(panel->famL, 10, 0);
|
|
WMResizeWidget(panel->famL, fw, 20);
|
|
|
|
WMMoveWidget(panel->famLs, 10, 23);
|
|
WMResizeWidget(panel->famLs, fw, h);
|
|
|
|
WMMoveWidget(panel->typL, 10+fw+3, 0);
|
|
WMResizeWidget(panel->typL, tw, 20);
|
|
|
|
WMMoveWidget(panel->typLs, 10+fw+3, 23);
|
|
WMResizeWidget(panel->typLs, tw, h);
|
|
|
|
WMMoveWidget(panel->sizL, 10+fw+3+tw+3, 0);
|
|
WMResizeWidget(panel->sizL, sw+4, 20);
|
|
|
|
WMMoveWidget(panel->sizT, 10+fw+3+tw+3, 23);
|
|
WMResizeWidget(panel->sizT, sw+4, 20);
|
|
|
|
WMMoveWidget(panel->sizLs, 10+fw+3+tw+3, 46);
|
|
WMResizeWidget(panel->sizLs, sw+4, h-22);
|
|
|
|
WMMoveWidget(panel->encF, 10, WMWidgetHeight(panel->lowerF)-55);
|
|
|
|
WMMoveWidget(panel->xlfdF, 145, WMWidgetHeight(panel->lowerF)-55);
|
|
WMResizeWidget(panel->xlfdF, WMWidgetWidth(panel->lowerF)-155, 50);
|
|
|
|
WMResizeWidget(panel->xlfdT, WMWidgetWidth(panel->lowerF)-155-20, 20);
|
|
}
|
|
|
|
|
|
|
|
|
|
#define ALL_FONTS_MASK "-*-*-*-*-*-*-*-*-*-*-*-*-*-*"
|
|
|
|
#define FOUNDRY 0
|
|
#define FAMILY 1
|
|
#define WEIGHT 2
|
|
#define SLANT 3
|
|
#define SETWIDTH 4
|
|
#define ADD_STYLE 5
|
|
#define PIXEL_SIZE 6
|
|
#define POINT_SIZE 7
|
|
#define RES_X 8
|
|
#define RES_Y 9
|
|
#define SPACING 10
|
|
#define AV_WIDTH 11
|
|
#define REGISTRY 12
|
|
#define ENCODING 13
|
|
|
|
#define NUM_FIELDS 14
|
|
|
|
|
|
static Bool
|
|
parseFont(char *font, char **values)
|
|
{
|
|
char *ptr;
|
|
int part;
|
|
char buffer[256], *bptr;
|
|
|
|
part = FOUNDRY;
|
|
ptr = font;
|
|
ptr++; /* skip first - */
|
|
bptr = buffer;
|
|
while (*ptr) {
|
|
if (*ptr == '-') {
|
|
*bptr = 0;
|
|
values[part]=wstrdup(buffer);
|
|
bptr = buffer;
|
|
part++;
|
|
} else {
|
|
*bptr++ = *ptr;
|
|
}
|
|
ptr++;
|
|
}
|
|
*bptr = 0;
|
|
values[part]=wstrdup(buffer);
|
|
|
|
return True;
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
isXLFD(char *font, int *length_ret)
|
|
{
|
|
int c = 0;
|
|
|
|
*length_ret = 0;
|
|
while (*font) {
|
|
(*length_ret)++;
|
|
if (*font++ == '-')
|
|
c++;
|
|
}
|
|
|
|
return c==NUM_FIELDS;
|
|
}
|
|
|
|
|
|
|
|
|
|
static proplist_t foundryKey = NULL;
|
|
static proplist_t typeKey = NULL;
|
|
static proplist_t sizeKey, encKey, xlfdKey;
|
|
|
|
|
|
static void
|
|
addSizeToEnc(proplist_t enc, char **fields)
|
|
{
|
|
proplist_t sizel;
|
|
|
|
sizel = PLGetDictionaryEntry(enc, sizeKey);
|
|
if (!sizel) {
|
|
sizel = PLMakeArrayFromElements(PLMakeString(fields[PIXEL_SIZE]),NULL);
|
|
PLInsertDictionaryEntry(enc, sizeKey, sizel);
|
|
} else {
|
|
PLAppendArrayElement(sizel, PLMakeString(fields[PIXEL_SIZE]));
|
|
}
|
|
}
|
|
|
|
|
|
static proplist_t
|
|
addTypefaceToFont(proplist_t font, char **fields)
|
|
{
|
|
proplist_t face, encod, facedic, encodic;
|
|
char buffer[256];
|
|
|
|
strcpy(buffer, fields[WEIGHT]);
|
|
|
|
if (strcasecmp(fields[SLANT], "R")==0)
|
|
strcat(buffer, " Roman ");
|
|
else if (strcasecmp(fields[SLANT], "I")==0)
|
|
strcat(buffer, " Italic ");
|
|
else if (strcasecmp(fields[SLANT], "O")==0)
|
|
strcat(buffer, " Oblique ");
|
|
else if (strcasecmp(fields[SLANT], "RI")==0)
|
|
strcat(buffer, " Reverse Italic ");
|
|
else if (strcasecmp(fields[SLANT], "RO")==0)
|
|
strcat(buffer, " Reverse Oblique ");
|
|
else if (strcasecmp(fields[SLANT], "OT")==0)
|
|
strcat(buffer, " ? ");
|
|
/* else
|
|
* polymorphic fonts
|
|
*/
|
|
strcat(buffer, fields[SETWIDTH]);
|
|
strcat(buffer, " ");
|
|
strcat(buffer, fields[ADD_STYLE]);
|
|
|
|
face = PLMakeString(buffer);
|
|
|
|
facedic = PLGetDictionaryEntry(font, face);
|
|
if (!facedic) {
|
|
facedic = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
|
|
PLInsertDictionaryEntry(font, face, facedic);
|
|
PLRelease(facedic);
|
|
}
|
|
PLRelease(face);
|
|
|
|
strcpy(buffer, fields[REGISTRY]);
|
|
strcat(buffer, "-");
|
|
strcat(buffer, fields[ENCODING]);
|
|
encod = PLMakeString(buffer);
|
|
|
|
encodic = PLGetDictionaryEntry(facedic, encod);
|
|
if (!encodic) {
|
|
proplist_t tmp;
|
|
sprintf(buffer, "-%s-%s-%s-%s-%s-%s-%%d-0-%s-%s-%s-%s-%s-%s",
|
|
fields[FOUNDRY], fields[FAMILY], fields[WEIGHT],
|
|
fields[SLANT], fields[SETWIDTH], fields[ADD_STYLE],
|
|
fields[RES_X], fields[RES_Y], fields[SPACING],
|
|
fields[AV_WIDTH], fields[REGISTRY], fields[ENCODING]);
|
|
tmp = PLMakeString(buffer);
|
|
|
|
encodic = PLMakeDictionaryFromEntries(xlfdKey, tmp, NULL);
|
|
PLRelease(tmp);
|
|
PLInsertDictionaryEntry(facedic, encod, encodic);
|
|
PLRelease(encodic);
|
|
}
|
|
addSizeToEnc(encodic, fields);
|
|
return font;
|
|
}
|
|
|
|
|
|
static proplist_t
|
|
makeFontEntry(char **fields)
|
|
{
|
|
proplist_t font;
|
|
proplist_t value;
|
|
proplist_t tmp;
|
|
value = PLMakeString(fields[FOUNDRY]);
|
|
|
|
tmp = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
|
|
|
|
font = PLMakeDictionaryFromEntries(foundryKey, value,
|
|
typeKey, tmp,
|
|
NULL);
|
|
PLRelease(value);
|
|
PLRelease(tmp);
|
|
|
|
addTypefaceToFont(font, fields);
|
|
|
|
return font;
|
|
}
|
|
|
|
|
|
static proplist_t
|
|
createFontDatabase(WMScreen *scr)
|
|
{
|
|
char **fontList;
|
|
int count;
|
|
char *fields[NUM_FIELDS];
|
|
int font_name_length;
|
|
char buffer[256];
|
|
int i;
|
|
proplist_t fdb;
|
|
proplist_t font;
|
|
proplist_t family;
|
|
proplist_t foundry;
|
|
proplist_t tmp;
|
|
|
|
if (!foundryKey) {
|
|
foundryKey = PLMakeString("Foundry");
|
|
typeKey = PLMakeString("Typeface");
|
|
encKey = PLMakeString("Encoding");
|
|
sizeKey = PLMakeString("Sizes");
|
|
xlfdKey = PLMakeString("XLFD");
|
|
}
|
|
|
|
/* retrieve a complete listing of the available fonts */
|
|
fontList = XListFonts(scr->display, ALL_FONTS_MASK, MAX_FONTS_TO_RETRIEVE,
|
|
&count);
|
|
if (!fontList) {
|
|
wwarning("could not retrieve font list");
|
|
return NULL;
|
|
}
|
|
|
|
fdb = PLMakeDictionaryFromEntries(NULL, NULL, NULL);
|
|
|
|
for (i=0; i<count; i++) {
|
|
if (!isXLFD(fontList[i], &font_name_length)) {
|
|
continue;
|
|
}
|
|
/* the XLFD specs limit the size of a font description in 255 chars */
|
|
assert(font_name_length < 256);
|
|
|
|
if (parseFont(fontList[i], fields)) {
|
|
family = PLMakeString(fields[FAMILY]);
|
|
font = PLGetDictionaryEntry(fdb, family);
|
|
if (font) {
|
|
foundry = PLGetDictionaryEntry(font, foundryKey);
|
|
if (strcmp(PLGetString(foundry), fields[FOUNDRY])==0) {
|
|
/* already a font with the same family */
|
|
addTypefaceToFont(font, fields);
|
|
} else {
|
|
/* same font family by different foundries */
|
|
sprintf(buffer, "%s (%s)", fields[FAMILY],
|
|
fields[FOUNDRY]);
|
|
PLRelease(family);
|
|
family = PLMakeString(buffer);
|
|
|
|
font = PLGetDictionaryEntry(fdb, family);
|
|
if (font) {
|
|
/* already a font with the same family */
|
|
addTypefaceToFont(font, fields);
|
|
} else {
|
|
tmp = makeFontEntry(fields);
|
|
PLInsertDictionaryEntry(fdb, family, tmp);
|
|
PLRelease(tmp);
|
|
}
|
|
}
|
|
} else {
|
|
tmp = makeFontEntry(fields);
|
|
PLInsertDictionaryEntry(fdb, family, tmp);
|
|
PLRelease(tmp);
|
|
}
|
|
PLRelease(family);
|
|
}
|
|
}
|
|
XFreeFontNames(fontList);
|
|
|
|
return fdb;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
listFamilies(proplist_t fdb, WMList *list)
|
|
{
|
|
proplist_t arr;
|
|
proplist_t fam;
|
|
int i;
|
|
|
|
arr = PLGetAllDictionaryKeys(fdb);
|
|
for (i = 0; i<PLGetNumberOfElements(arr); i++) {
|
|
fam = PLGetArrayElement(arr, i);
|
|
WMAddSortedListItem(list, PLGetString(fam));
|
|
}
|
|
}
|