gryf/wmaker
1
0
Fork 0
mirror of https://github.com/gryf/wmaker.git synced 2025-12-19 04:20:27 +01:00
Code Issues Projects Releases Wiki Activity

- Fixed WMArray.

Browse Source 
- Changed WMList to use WMArray instead of WMBag
- Fixed compilation problems in WPrefs.app
This commit is contained in:
dan
2000-09-23 03:49:58 +00:00
parent 18b7dcc2b0
commit 41ff127444
8 changed files with 399 additions and 387 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
WINGs/WINGs.h
View File

@@ -343,7 +343,7 @@ typedef struct W_ColorPanel WMColorPanel;
typedef struct WMListItem { typedef struct WMListItem {
char *text; char *text;
void *clientData; /* ptr for user clientdata. */ void *clientData; /* ptr for user clientdata. */
unsigned int uflags:16; /* flags for the user */ unsigned int uflags:16; /* flags for the user */
unsigned int selected:1; unsigned int selected:1;
unsigned int disabled:1; unsigned int disabled:1;
@@ -363,7 +363,7 @@ typedef struct WMAlertPanel {
WMFrame *line; /* separator */ WMFrame *line; /* separator */
short result; /* button that was pushed */ short result; /* button that was pushed */
short done; short done;
KeyCode retKey; KeyCode retKey;
KeyCode escKey; KeyCode escKey;
} WMAlertPanel; } WMAlertPanel;
@@ -378,7 +378,7 @@ typedef struct WMInputPanel {
WMTextField *text; /* text field */ WMTextField *text; /* text field */
short result; /* button that was pushed */ short result; /* button that was pushed */
short done; short done;
KeyCode retKey; KeyCode retKey;
KeyCode escKey; KeyCode escKey;
} WMInputPanel; } WMInputPanel;
@@ -456,39 +456,39 @@ typedef struct WMTextFieldDelegate {
void *data; void *data;
void (*didBeginEditing)(struct WMTextFieldDelegate *self, void (*didBeginEditing)(struct WMTextFieldDelegate *self,
WMNotification *notif); WMNotification *notif);
void (*didChange)(struct WMTextFieldDelegate *self, void (*didChange)(struct WMTextFieldDelegate *self,
WMNotification *notif); WMNotification *notif);
void (*didEndEditing)(struct WMTextFieldDelegate *self, void (*didEndEditing)(struct WMTextFieldDelegate *self,
WMNotification *notif); WMNotification *notif);
Bool (*shouldBeginEditing)(struct WMTextFieldDelegate *self, Bool (*shouldBeginEditing)(struct WMTextFieldDelegate *self,
WMTextField *tPtr); WMTextField *tPtr);
Bool (*shouldEndEditing)(struct WMTextFieldDelegate *self, Bool (*shouldEndEditing)(struct WMTextFieldDelegate *self,
WMTextField *tPtr); WMTextField *tPtr);
} WMTextFieldDelegate; } WMTextFieldDelegate;
typedef struct WMTextDelegate { typedef struct WMTextDelegate {
void *data; void *data;
void (*didBeginEditing)(struct WMTextDelegate *self, void (*didBeginEditing)(struct WMTextDelegate *self,
WMNotification *notif); WMNotification *notif);
void (*didChange)(struct WMTextDelegate *self, void (*didChange)(struct WMTextDelegate *self,
WMNotification *notif); WMNotification *notif);
void (*didEndEditing)(struct WMTextDelegate *self, void (*didEndEditing)(struct WMTextDelegate *self,
WMNotification *notif); WMNotification *notif);
Bool (*shouldBeginEditing)(struct WMTextDelegate *self, Bool (*shouldBeginEditing)(struct WMTextDelegate *self,
WMText *tPtr); WMText *tPtr);
Bool (*shouldEndEditing)(struct WMTextDelegate *self, Bool (*shouldEndEditing)(struct WMTextDelegate *self,
WMText *tPtr); WMText *tPtr);
} WMTextDelegate; } WMTextDelegate;
@@ -500,13 +500,13 @@ typedef struct WMTabViewDelegate {
WMTabView *tabView); WMTabView *tabView);
void (*didSelectItem)(struct WMTabViewDelegate *self, WMTabView *tabView, void (*didSelectItem)(struct WMTabViewDelegate *self, WMTabView *tabView,
WMTabViewItem *item); WMTabViewItem *item);
Bool (*shouldSelectItem)(struct WMTabViewDelegate *self, WMTabView *tabView, Bool (*shouldSelectItem)(struct WMTabViewDelegate *self, WMTabView *tabView,
WMTabViewItem *item); WMTabViewItem *item);
void (*willSelectItem)(struct WMTabViewDelegate *self, WMTabView *tabView, void (*willSelectItem)(struct WMTabViewDelegate *self, WMTabView *tabView,
WMTabViewItem *item); WMTabViewItem *item);
} WMTabViewDelegate; } WMTabViewDelegate;
@@ -1066,8 +1066,7 @@ int WMFindRowOfListItemWithTitle(WMList *lPtr, char *title);
WMListItem *WMGetListItem(WMList *lPtr, int row); WMListItem *WMGetListItem(WMList *lPtr, int row);
WMBag *WMGetListItems(WMList *lPtr); WMArray *WMGetListItems(WMList *lPtr);
void WMRemoveListItem(WMList *lPtr, int row); void WMRemoveListItem(WMList *lPtr, int row);

27
WINGs/WUtil.h
View File

@@ -131,6 +131,10 @@ typedef struct W_Connection WMConnection;
typedef void WMFreeDataProc(void *data); typedef void WMFreeDataProc(void *data);
/* Used by WMBag or WMArray for matching data */
typedef int WMMatchDataProc(void *item, void *cdata);
typedef struct { typedef struct {
@@ -320,16 +324,15 @@ extern const WMHashTableCallbacks WMStringPointerHashCallbacks;
* aren't in the end * aren't in the end
*/ */
WMArray* WMCreateArray(unsigned initialSize); WMArray* WMCreateArray(int initialSize);
WMArray* WMCreateArrayWithDestructor(unsigned initialSize, WMArray* WMCreateArrayWithDestructor(int initialSize, WMFreeDataProc *destructor);
void (*destructor)(void*));
void WMEmptyArray(WMArray *array); void WMEmptyArray(WMArray *array);
void WMFreeArray(WMArray *array); void WMFreeArray(WMArray *array);
unsigned WMGetArrayItemCount(WMArray *array); int WMGetArrayItemCount(WMArray *array);
/* appends other to array. other remains unchanged */ /* appends other to array. other remains unchanged */
int WMAppendArray(WMArray *array, WMArray *other); int WMAppendArray(WMArray *array, WMArray *other);
@@ -340,12 +343,12 @@ int WMAddToArray(WMArray *array, void *item);
#define WMPushInArray(array, item) WMAddToArray(array, item) #define WMPushInArray(array, item) WMAddToArray(array, item)
/* insert will increment the index of elements after it by 1 */ /* insert will increment the index of elements after it by 1 */
int WMInsertInArray(WMArray *array, unsigned index, void *item); int WMInsertInArray(WMArray *array, int index, void *item);
/* replace and set will return the old item WITHOUT calling the /* replace and set will return the old item WITHOUT calling the
* destructor on it even if its available. Free the returned item yourself. * destructor on it even if its available. Free the returned item yourself.
*/ */
void* WMReplaceInArray(WMArray *array, unsigned index, void *item); void* WMReplaceInArray(WMArray *array, int index, void *item);
#define WMSetInArray(array, index, item) WMReplaceInArray(array, index, item) #define WMSetInArray(array, index, item) WMReplaceInArray(array, index, item)
@@ -353,11 +356,11 @@ void* WMReplaceInArray(WMArray *array, unsigned index, void *item);
* after them to decrement their indexes by 1. Also will call the * after them to decrement their indexes by 1. Also will call the
* destructor on the deleted element if there's one available. * destructor on the deleted element if there's one available.
*/ */
int WMDeleteFromArray(WMArray *array, unsigned index); int WMDeleteFromArray(WMArray *array, int index);
int WMRemoveFromArray(WMArray *array, void *item); int WMRemoveFromArray(WMArray *array, void *item);
void* WMGetFromArray(WMArray *array, unsigned index); void* WMGetFromArray(WMArray *array, int index);
#define WMGetFirstInArray(array, item) WMFindInArray(array, NULL, item) #define WMGetFirstInArray(array, item) WMFindInArray(array, NULL, item)
@@ -367,9 +370,9 @@ void* WMGetFromArray(WMArray *array, unsigned index);
*/ */
void* WMPopFromArray(WMArray *array); void* WMPopFromArray(WMArray *array);
int WMFindInArray(WMArray *array, int (*match)(void*, void*), void *cdata); int WMFindInArray(WMArray *array, WMMatchDataProc *match, void *cdata);
unsigned WMCountInArray(WMArray *array, void *item); int WMCountInArray(WMArray *array, void *item);
/* comparer must return: /* comparer must return:
* < 0 if a < b * < 0 if a < b
@@ -403,7 +406,7 @@ void WMMapArray(WMArray *array, void (*function)(void*, void*), void *data);
WMBag* WMCreateTreeBag(void); WMBag* WMCreateTreeBag(void);
WMBag* WMCreateTreeBagWithDestructor(void (*destructor)(void*)); WMBag* WMCreateTreeBagWithDestructor(WMFreeDataProc *destructor);
int WMGetBagItemCount(WMBag *bag); int WMGetBagItemCount(WMBag *bag);
@@ -448,7 +451,7 @@ int WMGetFirstInBag(WMBag *bag, void *item);
int WMCountInBag(WMBag *bag, void *item); int WMCountInBag(WMBag *bag, void *item);
int WMFindInBag(WMBag *bag, int (*match)(void*,void*), void *cdata); int WMFindInBag(WMBag *bag, WMMatchDataProc *match, void *cdata);
void* WMBagFirst(WMBag *bag, WMBagIterator *ptr); void* WMBagFirst(WMBag *bag, WMBagIterator *ptr);

30
WINGs/array.c
View File

@@ -21,21 +21,21 @@
typedef struct W_Array { typedef struct W_Array {
void **items; /* the array data */ void **items; /* the array data */
unsigned itemCount; /* # of items in array */ int itemCount; /* # of items in array */
unsigned allocSize; /* allocated size of array */ int allocSize; /* allocated size of array */
void (*destructor)(void *item); /* the destructor to free elements */ void (*destructor)(void *item); /* the destructor to free elements */
} W_Array; } W_Array;
WMArray* WMArray*
WMCreateArray(unsigned initialSize) WMCreateArray(int initialSize)
{ {
WMCreateArrayWithDestructor(initialSize, NULL); WMCreateArrayWithDestructor(initialSize, NULL);
} }
WMArray* WMArray*
WMCreateArrayWithDestructor(unsigned initialSize, void (*destructor)(void*)) WMCreateArrayWithDestructor(int initialSize, WMFreeDataProc *destructor)
{ {
WMArray *array; WMArray *array;
@@ -78,7 +78,7 @@ WMFreeArray(WMArray *array)
} }
unsigned int
WMGetArrayItemCount(WMArray *array) WMGetArrayItemCount(WMArray *array)
{ {
return array->itemCount; return array->itemCount;
@@ -120,7 +120,7 @@ WMAddToArray(WMArray *array, void *item)
int int
WMInsertInArray(WMArray *array, unsigned index, void *item) WMInsertInArray(WMArray *array, int index, void *item)
{ {
wassertrv(index <= array->itemCount, 0); wassertrv(index <= array->itemCount, 0);
@@ -141,7 +141,7 @@ WMInsertInArray(WMArray *array, unsigned index, void *item)
void* void*
WMReplaceInArray(WMArray *array, unsigned index, void *item) WMReplaceInArray(WMArray *array, int index, void *item)
{ {
void *old; void *old;
@@ -160,7 +160,7 @@ WMReplaceInArray(WMArray *array, unsigned index, void *item)
int int
WMDeleteFromArray(WMArray *array, unsigned index) WMDeleteFromArray(WMArray *array, int index)
{ {
if (index >= array->itemCount) if (index >= array->itemCount)
return 0; return 0;
@@ -183,7 +183,7 @@ WMDeleteFromArray(WMArray *array, unsigned index)
int int
WMRemoveFromArray(WMArray *array, void *item) WMRemoveFromArray(WMArray *array, void *item)
{ {
unsigned i; int i;
for (i = 0; i < array->itemCount; i++) { for (i = 0; i < array->itemCount; i++) {
if (array->items[i] == item) { if (array->items[i] == item) {
@@ -196,7 +196,7 @@ WMRemoveFromArray(WMArray *array, void *item)
void* void*
WMGetFromArray(WMArray *array, unsigned index) WMGetFromArray(WMArray *array, int index)
{ {
if (index >= array->itemCount) if (index >= array->itemCount)
return NULL; return NULL;
@@ -215,9 +215,9 @@ WMPopFromArray(WMArray *array)
int int
WMFindInArray(WMArray *array, int (*match)(void*, void*), void *cdata) WMFindInArray(WMArray *array, WMMatchDataProc *match, void *cdata)
{ {
unsigned i; int i;
if (match!=NULL) { if (match!=NULL) {
for (i = 0; i < array->itemCount; i++) { for (i = 0; i < array->itemCount; i++) {
@@ -235,10 +235,10 @@ WMFindInArray(WMArray *array, int (*match)(void*, void*), void *cdata)
} }
unsigned int
WMCountInArray(WMArray *array, void *item) WMCountInArray(WMArray *array, void *item)
{ {
unsigned i, count; int i, count;
for (i=0, count=0; i<array->itemCount; i++) { for (i=0, count=0; i<array->itemCount; i++) {
if (array->items[i] == item) if (array->items[i] == item)
@@ -261,7 +261,7 @@ WMSortArray(WMArray *array, int (*comparer)(const void*, const void*))
void void
WMMapArray(WMArray *array, void (*function)(void*, void*), void *data) WMMapArray(WMArray *array, void (*function)(void*, void*), void *data)
{ {
unsigned i; int i;
for (i=0; i<array->itemCount; i++) { for (i=0; i<array->itemCount; i++) {
(*function)(array->items[i], data); (*function)(array->items[i], data);

10
WINGs/wfilepanel.c
View File

@@ -100,18 +100,18 @@ static int
closestListItem(WMList *list, char *text, Bool exact) closestListItem(WMList *list, char *text, Bool exact)
{ {
WMListItem *item; WMListItem *item;
WMBag *items = WMGetListItems(list); WMArray *items = WMGetListItems(list);
WMBagIterator i; int i, len = strlen(text);
int len = strlen(text);
if (len==0) if (len==0)
return -1; return -1;
WM_ITERATE_BAG(items, item, i) { for(i=0; i<WMGetArrayItemCount(items); i++) {
item = WMGetFromArray(items, i);
if (strlen(item->text) >= len && if (strlen(item->text) >= len &&
((exact && strcmp(item->text, text)==0) || ((exact && strcmp(item->text, text)==0) ||
(!exact && strncmp(item->text, text, len)==0))) { (!exact && strncmp(item->text, text, len)==0))) {
return WMBagIndexForIterator(items, i); return i;
} }
} }

590
WINGs/wlist.c
View File

@@ -11,40 +11,37 @@ typedef struct W_List {
W_Class widgetClass; W_Class widgetClass;
W_View *view; W_View *view;
WMBag *items; /* list of WMListItem */ WMArray *items; /* list of WMListItem */
WMArray *selectedItems; /* list of selected WMListItems */
short selectedItem; short selectedItem;
short itemHeight; short itemHeight;
short topItem; /* index of first visible item */ short topItem; /* index of first visible item */
short fullFitLines; /* no of lines that fit entirely */ short fullFitLines; /* no of lines that fit entirely */
void *clientData; void *clientData;
WMAction *action; WMAction *action;
void *doubleClientData; void *doubleClientData;
WMAction *doubleAction; WMAction *doubleAction;
WMListDrawProc *draw; WMListDrawProc *draw;
WMHandlerID *idleID; /* for updating the scroller after WMHandlerID *idleID; /* for updating the scroller after adding elements */
* adding elements */
WMScroller *vScroller; WMScroller *vScroller;
/*
WMScroller *hScroller;
*/
struct { struct {
unsigned int allowMultipleSelection:1; unsigned int allowMultipleSelection:1;
unsigned int userDrawn:1; unsigned int allowEmptySelection:1;
unsigned int userItemHeight:1; unsigned int userDrawn:1;
/* */ unsigned int userItemHeight:1;
unsigned int dontFitAll:1; /* 1 = last item won't be fully visible */ unsigned int dontFitAll:1; /* 1 = last item won't be fully visible */
unsigned int redrawPending:1; unsigned int redrawPending:1;
unsigned int buttonPressed:1; unsigned int buttonPressed:1;
unsigned int buttonWasPressed:1; unsigned int buttonWasPressed:1;
} flags; } flags;
} List; } List;
@@ -70,14 +67,24 @@ static void didResizeList();
W_ViewDelegate _ListViewDelegate = { W_ViewDelegate _ListViewDelegate = {
NULL, NULL,
NULL, NULL,
didResizeList, didResizeList,
NULL, NULL,
NULL NULL
}; };
static void
releaseItem(void *data)
{
WMListItem *item = (WMListItem*)data;
if (item->text)
wfree(item->text);
wfree(item);
}
WMList* WMList*
WMCreateList(WMWidget *parent) WMCreateList(WMWidget *parent)
{ {
@@ -91,23 +98,23 @@ WMCreateList(WMWidget *parent)
lPtr->view = W_CreateView(W_VIEW(parent)); lPtr->view = W_CreateView(W_VIEW(parent));
if (!lPtr->view) { if (!lPtr->view) {
wfree(lPtr); wfree(lPtr);
return NULL; return NULL;
} }
lPtr->view->self = lPtr; lPtr->view->self = lPtr;
lPtr->view->delegate = &_ListViewDelegate; lPtr->view->delegate = &_ListViewDelegate;
WMCreateEventHandler(lPtr->view, ExposureMask|StructureNotifyMask WMCreateEventHandler(lPtr->view, ExposureMask|StructureNotifyMask
|ClientMessageMask, handleEvents, lPtr); |ClientMessageMask, handleEvents, lPtr);
WMCreateEventHandler(lPtr->view, ButtonPressMask|ButtonReleaseMask WMCreateEventHandler(lPtr->view, ButtonPressMask|ButtonReleaseMask
|EnterWindowMask|LeaveWindowMask|ButtonMotionMask, |EnterWindowMask|LeaveWindowMask|ButtonMotionMask,
handleActionEvents, lPtr); handleActionEvents, lPtr);
lPtr->itemHeight = WMFontHeight(scrPtr->normalFont) + 1; lPtr->itemHeight = WMFontHeight(scrPtr->normalFont) + 1;
lPtr->items = WMCreateBag(4); lPtr->items = WMCreateArrayWithDestructor(4, releaseItem);
/* create the vertical scroller */ /* create the vertical scroller */
lPtr->vScroller = WMCreateScroller(lPtr); lPtr->vScroller = WMCreateScroller(lPtr);
@@ -120,7 +127,7 @@ WMCreateList(WMWidget *parent)
WMMapWidget(lPtr->vScroller); WMMapWidget(lPtr->vScroller);
W_ResizeView(lPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT); W_ResizeView(lPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);
lPtr->selectedItem = -1; lPtr->selectedItem = -1;
return lPtr; return lPtr;
@@ -137,7 +144,7 @@ comparator(const void *a, const void *b)
void void
WMSortListItems(WMList *lPtr) WMSortListItems(WMList *lPtr)
{ {
WMSortBag(lPtr->items, comparator); WMSortArray(lPtr->items, comparator);
paintList(lPtr); paintList(lPtr);
} }
@@ -147,7 +154,7 @@ WMSortListItems(WMList *lPtr)
void void
WMSortListItemsWithComparer(WMList *lPtr, int (f)(const void*, const void*)) WMSortListItemsWithComparer(WMList *lPtr, int (f)(const void*, const void*))
{ {
WMSortBag(lPtr->items, f); WMSortArray(lPtr->items, f);
paintList(lPtr); paintList(lPtr);
} }
@@ -167,21 +174,21 @@ WMInsertListItem(WMList *lPtr, int row, char *text)
if (lPtr->selectedItem >= row && lPtr->selectedItem >= 0 if (lPtr->selectedItem >= row && lPtr->selectedItem >= 0
&& row >= 0) && row >= 0)
lPtr->selectedItem++; lPtr->selectedItem++;
row = WMIN(row, WMGetBagItemCount(lPtr->items)); row = WMIN(row, WMGetArrayItemCount(lPtr->items));
if (row < 0) if (row < 0)
WMPutInBag(lPtr->items, item); WMAddToArray(lPtr->items, item);
else else
WMInsertInBag(lPtr->items, row, item); WMInsertInArray(lPtr->items, row, item);
/* update the scroller when idle, so that we don't waste time /* update the scroller when idle, so that we don't waste time
* updating it when another item is going to be added later */ * updating it when another item is going to be added later */
if (!lPtr->idleID) { if (!lPtr->idleID) {
lPtr->idleID = WMAddIdleHandler((WMCallback*)updateScroller, lPtr); lPtr->idleID = WMAddIdleHandler((WMCallback*)updateScroller, lPtr);
} }
return item; return item;
} }
@@ -190,14 +197,13 @@ WMInsertListItem(WMList *lPtr, int row, char *text)
void void
WMRemoveListItem(WMList *lPtr, int row) WMRemoveListItem(WMList *lPtr, int row)
{ {
WMListItem *item;
int topItem = lPtr->topItem; int topItem = lPtr->topItem;
int selNotify = 0; int selNotify = 0;
CHECK_CLASS(lPtr, WC_List); CHECK_CLASS(lPtr, WC_List);
if (row < 0 || row >= WMGetBagItemCount(lPtr->items)) if (row < 0 || row >= WMGetArrayItemCount(lPtr->items))
return; return;
if (lPtr->selectedItem == row) { if (lPtr->selectedItem == row) {
lPtr->selectedItem = -1; lPtr->selectedItem = -1;
@@ -207,22 +213,17 @@ WMRemoveListItem(WMList *lPtr, int row)
} }
if (row <= lPtr->topItem+lPtr->fullFitLines+lPtr->flags.dontFitAll) if (row <= lPtr->topItem+lPtr->fullFitLines+lPtr->flags.dontFitAll)
lPtr->topItem--; lPtr->topItem--;
if (lPtr->topItem < 0) if (lPtr->topItem < 0)
lPtr->topItem = 0; lPtr->topItem = 0;
item = WMGetFromBag(lPtr->items, row); WMDeleteFromArray(lPtr->items, row);
if (item->text)
wfree(item->text);
wfree(item);
WMDeleteFromBag(lPtr->items, row);
if (!lPtr->idleID) { if (!lPtr->idleID) {
lPtr->idleID = WMAddIdleHandler((WMCallback*)updateScroller, lPtr); lPtr->idleID = WMAddIdleHandler((WMCallback*)updateScroller, lPtr);
} }
if (lPtr->topItem != topItem) if (lPtr->topItem != topItem)
WMPostNotificationName(WMListDidScrollNotification, lPtr, NULL); WMPostNotificationName(WMListDidScrollNotification, lPtr, NULL);
if (selNotify) if (selNotify)
WMPostNotificationName(WMListSelectionDidChangeNotification, lPtr, WMPostNotificationName(WMListSelectionDidChangeNotification, lPtr,
(void*)((int)lPtr->selectedItem)); (void*)((int)lPtr->selectedItem));
@@ -233,11 +234,11 @@ WMRemoveListItem(WMList *lPtr, int row)
WMListItem* WMListItem*
WMGetListItem(WMList *lPtr, int row) WMGetListItem(WMList *lPtr, int row)
{ {
return WMGetFromBag(lPtr->items, row); return WMGetFromArray(lPtr->items, row);
} }
WMBag* WMArray*
WMGetListItems(WMList *lPtr) WMGetListItems(WMList *lPtr)
{ {
return lPtr->items; return lPtr->items;
@@ -257,10 +258,10 @@ void
WMSetListUserDrawItemHeight(WMList *lPtr, unsigned short height) WMSetListUserDrawItemHeight(WMList *lPtr, unsigned short height)
{ {
assert(height > 0); assert(height > 0);
lPtr->flags.userItemHeight = 1; lPtr->flags.userItemHeight = 1;
lPtr->itemHeight = height; lPtr->itemHeight = height;
updateGeometry(lPtr); updateGeometry(lPtr);
} }
@@ -268,26 +269,20 @@ WMSetListUserDrawItemHeight(WMList *lPtr, unsigned short height)
void void
WMClearList(WMList *lPtr) WMClearList(WMList *lPtr)
{ {
WMListItem *item;
int oldSelected = lPtr->selectedItem; int oldSelected = lPtr->selectedItem;
int i; int i;
for (i = 0; i < WMGetBagItemCount(lPtr->items); i++) { WMEmptyArray(lPtr->items);
item = WMGetFromBag(lPtr->items, i);
wfree(item->text);
wfree(item);
}
WMEmptyBag(lPtr->items);
lPtr->topItem = 0; lPtr->topItem = 0;
lPtr->selectedItem = -1; lPtr->selectedItem = -1;
if (!lPtr->idleID) { if (!lPtr->idleID) {
WMDeleteIdleHandler(lPtr->idleID); WMDeleteIdleHandler(lPtr->idleID);
lPtr->idleID = NULL; lPtr->idleID = NULL;
} }
if (lPtr->view->flags.realized) { if (lPtr->view->flags.realized) {
updateScroller(lPtr); updateScroller(lPtr);
} }
if (oldSelected != -1) if (oldSelected != -1)
WMPostNotificationName(WMListSelectionDidChangeNotification, lPtr, WMPostNotificationName(WMListSelectionDidChangeNotification, lPtr,
@@ -315,22 +310,22 @@ WMListItem*
WMGetListSelectedItem(WMList *lPtr) WMGetListSelectedItem(WMList *lPtr)
{ {
if (lPtr->selectedItem < 0) if (lPtr->selectedItem < 0)
return NULL; return NULL;
return WMGetFromBag(lPtr->items, lPtr->selectedItem); return WMGetFromArray(lPtr->items, lPtr->selectedItem);
} }
int int
WMGetListSelectedItemRow(WMList *lPtr) WMGetListSelectedItemRow(WMList *lPtr)
{ {
return lPtr->selectedItem; return lPtr->selectedItem;
} }
int int
WMGetListItemHeight(WMList *lPtr) WMGetListItemHeight(WMList *lPtr)
{ {
return lPtr->itemHeight; return lPtr->itemHeight;
} }
@@ -339,26 +334,26 @@ void
WMSetListPosition(WMList *lPtr, int row) WMSetListPosition(WMList *lPtr, int row)
{ {
lPtr->topItem = row; lPtr->topItem = row;
if (lPtr->topItem + lPtr->fullFitLines > WMGetBagItemCount(lPtr->items)) if (lPtr->topItem + lPtr->fullFitLines > WMGetArrayItemCount(lPtr->items))
lPtr->topItem = WMGetBagItemCount(lPtr->items) - lPtr->fullFitLines; lPtr->topItem = WMGetArrayItemCount(lPtr->items) - lPtr->fullFitLines;
if (lPtr->topItem < 0) if (lPtr->topItem < 0)
lPtr->topItem = 0; lPtr->topItem = 0;
if (lPtr->view->flags.realized) if (lPtr->view->flags.realized)
updateScroller(lPtr); updateScroller(lPtr);
} }
void void
WMSetListBottomPosition(WMList *lPtr, int row) WMSetListBottomPosition(WMList *lPtr, int row)
{ {
if (WMGetBagItemCount(lPtr->items) > lPtr->fullFitLines) { if (WMGetArrayItemCount(lPtr->items) > lPtr->fullFitLines) {
lPtr->topItem = row - lPtr->fullFitLines; lPtr->topItem = row - lPtr->fullFitLines;
if (lPtr->topItem < 0) if (lPtr->topItem < 0)
lPtr->topItem = 0; lPtr->topItem = 0;
if (lPtr->view->flags.realized) if (lPtr->view->flags.realized)
updateScroller(lPtr); updateScroller(lPtr);
} }
} }
@@ -366,7 +361,7 @@ WMSetListBottomPosition(WMList *lPtr, int row)
int int
WMGetListNumberOfRows(WMList *lPtr) WMGetListNumberOfRows(WMList *lPtr)
{ {
return WMGetBagItemCount(lPtr->items); return WMGetArrayItemCount(lPtr->items);
} }
int int
@@ -383,69 +378,69 @@ vScrollCallBack(WMWidget *scroller, void *self)
WMScroller *sPtr = (WMScroller*)scroller; WMScroller *sPtr = (WMScroller*)scroller;
int height; int height;
int topItem = lPtr->topItem; int topItem = lPtr->topItem;
int itemCount = WMGetBagItemCount(lPtr->items); int itemCount = WMGetArrayItemCount(lPtr->items);
height = lPtr->view->size.height - 4; height = lPtr->view->size.height - 4;
switch (WMGetScrollerHitPart(sPtr)) { switch (WMGetScrollerHitPart(sPtr)) {
case WSDecrementLine: case WSDecrementLine:
if (lPtr->topItem > 0) { if (lPtr->topItem > 0) {
lPtr->topItem--; lPtr->topItem--;
updateScroller(lPtr); updateScroller(lPtr);
} }
break; break;
case WSDecrementPage:
if (lPtr->topItem > 0) {
lPtr->topItem -= lPtr->fullFitLines-(1-lPtr->flags.dontFitAll)-1;
if (lPtr->topItem < 0)
lPtr->topItem = 0;
updateScroller(lPtr); case WSDecrementPage:
} if (lPtr->topItem > 0) {
break; lPtr->topItem -= lPtr->fullFitLines-(1-lPtr->flags.dontFitAll)-1;
if (lPtr->topItem < 0)
lPtr->topItem = 0;
updateScroller(lPtr);
case WSIncrementLine: }
if (lPtr->topItem + lPtr->fullFitLines < itemCount) { break;
lPtr->topItem++;
updateScroller(lPtr);
}
break;
case WSIncrementPage:
if (lPtr->topItem + lPtr->fullFitLines < itemCount) {
lPtr->topItem += lPtr->fullFitLines-(1-lPtr->flags.dontFitAll)-1;
if (lPtr->topItem + lPtr->fullFitLines > itemCount)
lPtr->topItem = itemCount - lPtr->fullFitLines;
updateScroller(lPtr); case WSIncrementLine:
} if (lPtr->topItem + lPtr->fullFitLines < itemCount) {
break; lPtr->topItem++;
case WSKnob:
{
int oldTopItem = lPtr->topItem;
lPtr->topItem = WMGetScrollerValue(lPtr->vScroller) *
(float)(itemCount - lPtr->fullFitLines);
if (oldTopItem != lPtr->topItem) updateScroller(lPtr);
paintList(lPtr); }
} break;
break;
case WSKnobSlot: case WSIncrementPage:
case WSNoPart: if (lPtr->topItem + lPtr->fullFitLines < itemCount) {
/* do nothing */ lPtr->topItem += lPtr->fullFitLines-(1-lPtr->flags.dontFitAll)-1;
break;
if (lPtr->topItem + lPtr->fullFitLines > itemCount)
lPtr->topItem = itemCount - lPtr->fullFitLines;
updateScroller(lPtr);
}
break;
case WSKnob:
{
int oldTopItem = lPtr->topItem;
lPtr->topItem = WMGetScrollerValue(lPtr->vScroller) *
(float)(itemCount - lPtr->fullFitLines);
if (oldTopItem != lPtr->topItem)
paintList(lPtr);
}
break;
case WSKnobSlot:
case WSNoPart:
/* do nothing */
break;
} }
if (lPtr->topItem != topItem) if (lPtr->topItem != topItem)
WMPostNotificationName(WMListDidScrollNotification, lPtr, NULL); WMPostNotificationName(WMListDidScrollNotification, lPtr, NULL);
} }
@@ -457,7 +452,7 @@ paintItem(List *lPtr, int index)
int width, height, x, y; int width, height, x, y;
WMListItem *itemPtr; WMListItem *itemPtr;
itemPtr = WMGetFromBag(lPtr->items, index); itemPtr = WMGetFromArray(lPtr->items, index);
width = lPtr->view->size.width - 2 - 19; width = lPtr->view->size.width - 2 - 19;
height = lPtr->itemHeight; height = lPtr->itemHeight;
@@ -465,35 +460,35 @@ paintItem(List *lPtr, int index)
y = 2 + (index-lPtr->topItem) * lPtr->itemHeight + 1; y = 2 + (index-lPtr->topItem) * lPtr->itemHeight + 1;
if (lPtr->flags.userDrawn) { if (lPtr->flags.userDrawn) {
WMRect rect; WMRect rect;
int flags; int flags;
rect.size.width = width; rect.size.width = width;
rect.size.height = height; rect.size.height = height;
rect.pos.x = x; rect.pos.x = x;
rect.pos.y = y; rect.pos.y = y;
flags = itemPtr->uflags; flags = itemPtr->uflags;
if (itemPtr->disabled) if (itemPtr->disabled)
flags |= WLDSDisabled; flags |= WLDSDisabled;
if (itemPtr->selected) if (itemPtr->selected)
flags |= WLDSSelected; flags |= WLDSSelected;
if (itemPtr->isBranch) if (itemPtr->isBranch)
flags |= WLDSIsBranch; flags |= WLDSIsBranch;
if (lPtr->draw) if (lPtr->draw)
(*lPtr->draw)(lPtr, index, view->window, itemPtr->text, flags, (*lPtr->draw)(lPtr, index, view->window, itemPtr->text, flags,
&rect); &rect);
} else { } else {
if (itemPtr->selected) if (itemPtr->selected)
XFillRectangle(scr->display, view->window, WMColorGC(scr->white), XFillRectangle(scr->display, view->window, WMColorGC(scr->white),
x, y, width, height); x, y, width, height);
else else
XClearArea(scr->display, view->window, x, y, width, height, False); XClearArea(scr->display, view->window, x, y, width, height, False);
W_PaintText(view, view->window, scr->normalFont, x+4, y, width, W_PaintText(view, view->window, scr->normalFont, x+4, y, width,
WALeft, WMColorGC(scr->black), False, WALeft, WMColorGC(scr->black), False,
itemPtr->text, strlen(itemPtr->text)); itemPtr->text, strlen(itemPtr->text));
} }
} }
@@ -506,34 +501,34 @@ paintList(List *lPtr)
int i, lim; int i, lim;
if (!lPtr->view->flags.mapped) if (!lPtr->view->flags.mapped)
return; return;
if (WMGetBagItemCount(lPtr->items) > 0) { if (WMGetArrayItemCount(lPtr->items) > 0) {
if (lPtr->topItem+lPtr->fullFitLines+lPtr->flags.dontFitAll if (lPtr->topItem+lPtr->fullFitLines+lPtr->flags.dontFitAll
> WMGetBagItemCount(lPtr->items)) { > WMGetArrayItemCount(lPtr->items)) {
lim = WMGetBagItemCount(lPtr->items) - lPtr->topItem; lim = WMGetArrayItemCount(lPtr->items) - lPtr->topItem;
XClearArea(scrPtr->display, lPtr->view->window, 19, XClearArea(scrPtr->display, lPtr->view->window, 19,
2+lim*lPtr->itemHeight, lPtr->view->size.width-21, 2+lim*lPtr->itemHeight, lPtr->view->size.width-21,
lPtr->view->size.height-lim*lPtr->itemHeight-3, False); lPtr->view->size.height-lim*lPtr->itemHeight-3, False);
} else { } else {
lim = lPtr->fullFitLines + lPtr->flags.dontFitAll; lim = lPtr->fullFitLines + lPtr->flags.dontFitAll;
} }
for (i = lPtr->topItem; i < lPtr->topItem + lim; i++) { for (i = lPtr->topItem; i < lPtr->topItem + lim; i++) {
paintItem(lPtr, i); paintItem(lPtr, i);
} }
} else { } else {
XClearWindow(scrPtr->display, lPtr->view->window); XClearWindow(scrPtr->display, lPtr->view->window);
} }
W_DrawRelief(scrPtr, lPtr->view->window, 0, 0, lPtr->view->size.width, W_DrawRelief(scrPtr, lPtr->view->window, 0, 0, lPtr->view->size.width,
lPtr->view->size.height, WRSunken); lPtr->view->size.height, WRSunken);
} }
#if 0 #if 0
static void static void
scrollTo(List *lPtr, int newTop) scrollTo(List *lPtr, int newTop)
{ {
} }
#endif #endif
@@ -541,23 +536,23 @@ static void
updateScroller(List *lPtr) updateScroller(List *lPtr)
{ {
float knobProportion, floatValue, tmp; float knobProportion, floatValue, tmp;
int count = WMGetBagItemCount(lPtr->items); int count = WMGetArrayItemCount(lPtr->items);
if (lPtr->idleID) if (lPtr->idleID)
WMDeleteIdleHandler(lPtr->idleID); WMDeleteIdleHandler(lPtr->idleID);
lPtr->idleID = NULL; lPtr->idleID = NULL;
paintList(lPtr); paintList(lPtr);
if (count == 0 || count <= lPtr->fullFitLines) if (count == 0 || count <= lPtr->fullFitLines)
WMSetScrollerParameters(lPtr->vScroller, 0, 1); WMSetScrollerParameters(lPtr->vScroller, 0, 1);
else { else {
tmp = lPtr->fullFitLines; tmp = lPtr->fullFitLines;
knobProportion = tmp/(float)count; knobProportion = tmp/(float)count;
floatValue = (float)lPtr->topItem/(float)(count - lPtr->fullFitLines); floatValue = (float)lPtr->topItem/(float)(count - lPtr->fullFitLines);
WMSetScrollerParameters(lPtr->vScroller, floatValue, knobProportion); WMSetScrollerParameters(lPtr->vScroller, floatValue, knobProportion);
} }
} }
@@ -570,36 +565,32 @@ handleEvents(XEvent *event, void *data)
CHECK_CLASS(data, WC_List); CHECK_CLASS(data, WC_List);
switch (event->type) { switch (event->type) {
case Expose: case Expose:
if (event->xexpose.count!=0) if (event->xexpose.count!=0)
break; break;
paintList(lPtr); paintList(lPtr);
break; break;
case DestroyNotify: case DestroyNotify:
destroyList(lPtr); destroyList(lPtr);
break; break;
} }
} }
static int
matchTitle(void *item, void *title)
{
return (strcmp(((WMListItem*)item)->text, (char*)title)==0 ? 1 : 0);
}
int int
WMFindRowOfListItemWithTitle(WMList *lPtr, char *title) WMFindRowOfListItemWithTitle(WMList *lPtr, char *title)
{ {
WMListItem *item; return WMFindInArray(lPtr->items, matchTitle, title);
WMBagIterator i;
int ok = 0;
WM_ITERATE_BAG(lPtr->items, item, i) {
if (strcmp(item->text, title)==0) {
ok = 1;
break;
}
}
return ok ? WMBagIndexForIterator(lPtr->items, i) : -1;
} }
@@ -609,8 +600,8 @@ WMSelectListItem(WMList *lPtr, int row)
WMListItem *itemPtr; WMListItem *itemPtr;
int notify = 0; int notify = 0;
if (row >= WMGetBagItemCount(lPtr->items)) if (row >= WMGetArrayItemCount(lPtr->items))
return; return;
/* the check below must be changed when the multiple selection is /* the check below must be changed when the multiple selection is
* implemented. -Dan * implemented. -Dan
@@ -620,50 +611,50 @@ WMSelectListItem(WMList *lPtr, int row)
else else
notify = 1; notify = 1;
assert(lPtr->selectedItem < WMGetBagItemCount(lPtr->items)); assert(lPtr->selectedItem < WMGetArrayItemCount(lPtr->items));
if (!lPtr->flags.allowMultipleSelection) {
/* unselect previous selected item */
if (lPtr->selectedItem >= 0) {
itemPtr = WMGetFromBag(lPtr->items, lPtr->selectedItem);
if (itemPtr->selected) { if (!lPtr->flags.allowMultipleSelection) {
itemPtr->selected = 0; /* unselect previous selected item */
if (lPtr->view->flags.mapped if (lPtr->selectedItem >= 0) {
&& lPtr->selectedItem>=lPtr->topItem itemPtr = WMGetFromArray(lPtr->items, lPtr->selectedItem);
&& lPtr->selectedItem<=lPtr->topItem+lPtr->fullFitLines) {
paintItem(lPtr, lPtr->selectedItem); if (itemPtr->selected) {
} itemPtr->selected = 0;
} if (lPtr->view->flags.mapped
} && lPtr->selectedItem>=lPtr->topItem
&& lPtr->selectedItem<=lPtr->topItem+lPtr->fullFitLines) {
paintItem(lPtr, lPtr->selectedItem);
}
}
}
} }
if (row < 0) { if (row < 0) {
if (!lPtr->flags.allowMultipleSelection) { if (!lPtr->flags.allowMultipleSelection) {
lPtr->selectedItem = -1; lPtr->selectedItem = -1;
if (notify) if (notify)
WMPostNotificationName(WMListSelectionDidChangeNotification, WMPostNotificationName(WMListSelectionDidChangeNotification,
lPtr, (void*)((int)lPtr->selectedItem)); lPtr, (void*)((int)lPtr->selectedItem));
} }
return; return;
} }
/* select item */ /* select item */
itemPtr = WMGetFromBag(lPtr->items, row); itemPtr = WMGetFromArray(lPtr->items, row);
if (lPtr->flags.allowMultipleSelection) if (lPtr->flags.allowMultipleSelection)
itemPtr->selected = !itemPtr->selected; itemPtr->selected = !itemPtr->selected;
else else
itemPtr->selected = 1; itemPtr->selected = 1;
if (lPtr->view->flags.mapped) { if (lPtr->view->flags.mapped) {
paintItem(lPtr, row); paintItem(lPtr, row);
if ((row-lPtr->topItem+lPtr->fullFitLines)*lPtr->itemHeight if ((row-lPtr->topItem+lPtr->fullFitLines)*lPtr->itemHeight
> lPtr->view->size.height-2) > lPtr->view->size.height-2)
W_DrawRelief(lPtr->view->screen, lPtr->view->window, 0, 0, W_DrawRelief(lPtr->view->screen, lPtr->view->window, 0, 0,
lPtr->view->size.width, lPtr->view->size.height, lPtr->view->size.width, lPtr->view->size.height,
WRSunken); WRSunken);
} }
lPtr->selectedItem = row; lPtr->selectedItem = row;
if (notify) if (notify)
@@ -679,8 +670,8 @@ getItemIndexAt(List *lPtr, int clickY)
index = (clickY - 2) / lPtr->itemHeight + lPtr->topItem; index = (clickY - 2) / lPtr->itemHeight + lPtr->topItem;
if (index < 0 || index >= WMGetBagItemCount(lPtr->items)) if (index < 0 || index >= WMGetArrayItemCount(lPtr->items))
return -1; return -1;
return index; return index;
} }
@@ -696,7 +687,7 @@ handleActionEvents(XEvent *event, void *data)
CHECK_CLASS(data, WC_List); CHECK_CLASS(data, WC_List);
switch (event->type) { switch (event->type) {
case ButtonRelease: case ButtonRelease:
#define CHECK_WHEEL_PATCH #define CHECK_WHEEL_PATCH
#ifdef CHECK_WHEEL_PATCH #ifdef CHECK_WHEEL_PATCH
/* Ignore mouse wheel events, they're not "real" button events */ /* Ignore mouse wheel events, they're not "real" button events */
@@ -705,27 +696,27 @@ handleActionEvents(XEvent *event, void *data)
break; break;
#endif #endif
lPtr->flags.buttonPressed = 0; lPtr->flags.buttonPressed = 0;
tmp = getItemIndexAt(lPtr, event->xbutton.y); tmp = getItemIndexAt(lPtr, event->xbutton.y);
if (tmp == lPtr->selectedItem && tmp >= 0) { if (tmp == lPtr->selectedItem && tmp >= 0) {
if (lPtr->action) if (lPtr->action)
(*lPtr->action)(lPtr, lPtr->clientData); (*lPtr->action)(lPtr, lPtr->clientData);
} }
break; break;
case EnterNotify: case EnterNotify:
lPtr->flags.buttonPressed = lPtr->flags.buttonWasPressed; lPtr->flags.buttonPressed = lPtr->flags.buttonWasPressed;
lPtr->flags.buttonWasPressed = 0; lPtr->flags.buttonWasPressed = 0;
break; break;
case LeaveNotify: case LeaveNotify:
lPtr->flags.buttonWasPressed = lPtr->flags.buttonPressed; lPtr->flags.buttonWasPressed = lPtr->flags.buttonPressed;
lPtr->flags.buttonPressed = 0; lPtr->flags.buttonPressed = 0;
break; break;
case ButtonPress: case ButtonPress:
if (event->xbutton.x > WMWidgetWidth(lPtr->vScroller)) { if (event->xbutton.x > WMWidgetWidth(lPtr->vScroller)) {
#ifdef CHECK_WHEEL_PATCH #ifdef CHECK_WHEEL_PATCH
/* Mouse wheel events need to be properly handled here. It would /* Mouse wheel events need to be properly handled here. It would
* be best to somehow route them to lPtr->vScroller so that the * be best to somehow route them to lPtr->vScroller so that the
@@ -737,7 +728,7 @@ handleActionEvents(XEvent *event, void *data)
if (event->xbutton.button == WINGsConfiguration.mouseWheelDown) { if (event->xbutton.button == WINGsConfiguration.mouseWheelDown) {
/* Wheel down */ /* Wheel down */
int itemCount = WMGetBagItemCount(lPtr->items); int itemCount = WMGetArrayItemCount(lPtr->items);
if (lPtr->topItem + lPtr->fullFitLines < itemCount) { if (lPtr->topItem + lPtr->fullFitLines < itemCount) {
int incr = lPtr->fullFitLines-(1-lPtr->flags.dontFitAll)-1; int incr = lPtr->fullFitLines-(1-lPtr->flags.dontFitAll)-1;
lPtr->topItem += incr; lPtr->topItem += incr;
@@ -766,48 +757,48 @@ handleActionEvents(XEvent *event, void *data)
#endif #endif
tmp = getItemIndexAt(lPtr, event->xbutton.y); tmp = getItemIndexAt(lPtr, event->xbutton.y);
lPtr->flags.buttonPressed = 1; lPtr->flags.buttonPressed = 1;
if (tmp >= 0) { if (tmp >= 0) {
if (tmp == lPtr->selectedItem && WMIsDoubleClick(event)) { if (tmp == lPtr->selectedItem && WMIsDoubleClick(event)) {
WMSelectListItem(lPtr, tmp); WMSelectListItem(lPtr, tmp);
if (lPtr->doubleAction) if (lPtr->doubleAction)
(*lPtr->doubleAction)(lPtr, lPtr->doubleClientData); (*lPtr->doubleAction)(lPtr, lPtr->doubleClientData);
} else { } else {
WMSelectListItem(lPtr, tmp); WMSelectListItem(lPtr, tmp);
} }
} }
} }
break; break;
case MotionNotify: case MotionNotify:
if (lPtr->flags.buttonPressed) { if (lPtr->flags.buttonPressed) {
tmp = getItemIndexAt(lPtr, event->xmotion.y); tmp = getItemIndexAt(lPtr, event->xmotion.y);
if (tmp>=0 && tmp != lPtr->selectedItem) { if (tmp>=0 && tmp != lPtr->selectedItem) {
WMSelectListItem(lPtr, tmp); WMSelectListItem(lPtr, tmp);
} }
} }
break; break;
} }
if (lPtr->topItem != topItem) if (lPtr->topItem != topItem)
WMPostNotificationName(WMListDidScrollNotification, lPtr, NULL); WMPostNotificationName(WMListDidScrollNotification, lPtr, NULL);
} }
static void static void
updateGeometry(WMList *lPtr) updateGeometry(WMList *lPtr)
{ {
lPtr->fullFitLines = (lPtr->view->size.height - 4) / lPtr->itemHeight; lPtr->fullFitLines = (lPtr->view->size.height - 4) / lPtr->itemHeight;
if (lPtr->fullFitLines * lPtr->itemHeight < lPtr->view->size.height - 4) { if (lPtr->fullFitLines * lPtr->itemHeight < lPtr->view->size.height - 4) {
lPtr->flags.dontFitAll = 1; lPtr->flags.dontFitAll = 1;
} else { } else {
lPtr->flags.dontFitAll = 0; lPtr->flags.dontFitAll = 0;
} }
if (WMGetBagItemCount(lPtr->items) - lPtr->topItem <= lPtr->fullFitLines) { if (WMGetArrayItemCount(lPtr->items) - lPtr->topItem <= lPtr->fullFitLines) {
lPtr->topItem = WMGetBagItemCount(lPtr->items) - lPtr->fullFitLines; lPtr->topItem = WMGetArrayItemCount(lPtr->items) - lPtr->fullFitLines;
if (lPtr->topItem < 0) if (lPtr->topItem < 0)
lPtr->topItem = 0; lPtr->topItem = 0;
} }
updateScroller(lPtr); updateScroller(lPtr);
@@ -816,7 +807,7 @@ updateGeometry(WMList *lPtr)
static void static void
didResizeList(W_ViewDelegate *self, WMView *view) didResizeList(W_ViewDelegate *self, WMView *view)
{ {
WMList *lPtr = (WMList*)view->self; WMList *lPtr = (WMList*)view->self;
WMResizeWidget(lPtr->vScroller, 1, view->size.height-2); WMResizeWidget(lPtr->vScroller, 1, view->size.height-2);
@@ -828,18 +819,11 @@ didResizeList(W_ViewDelegate *self, WMView *view)
static void static void
destroyList(List *lPtr) destroyList(List *lPtr)
{ {
WMListItem *item;
WMBagIterator i;
if (lPtr->idleID) if (lPtr->idleID)
WMDeleteIdleHandler(lPtr->idleID); WMDeleteIdleHandler(lPtr->idleID);
lPtr->idleID = NULL; lPtr->idleID = NULL;
WM_ITERATE_BAG(lPtr->items, item, i) { WMFreeArray(lPtr->items);
wfree(item->text);
wfree(item);
}
WMFreeBag(lPtr->items);
wfree(lPtr); wfree(lPtr);
} }

19
WPrefs.app/Menu.c
View File

@@ -1303,14 +1303,13 @@ menuItemCloned(WEditMenuDelegate *delegate, WEditMenu *menu,
} }
static void
menuItemEdited(struct WEditMenuDelegate *delegate, WEditMenu *menu,
static void menuItemEdited(struct WEditMenuDelegate *delegate, WEditMenu *menu, WEditMenuItem *item)
WEditMenuItem *item)
{ {
_Panel *panel = (_Panel*)delegate->data; _Panel *panel = (_Panel*)delegate->data;
WEditMenu *submenu; WEditMenu *submenu;
updateFrameTitle(panel, WGetEditMenuItemTitle(item), panel->currentType); updateFrameTitle(panel, WGetEditMenuItemTitle(item), panel->currentType);
submenu = WGetEditMenuSubmenu(menu, item); submenu = WGetEditMenuSubmenu(menu, item);
@@ -1320,17 +1319,15 @@ static void menuItemEdited(struct WEditMenuDelegate *delegate, WEditMenu *menu,
} }
static Bool
shouldRemoveItem(struct WEditMenuDelegate *delegate, WEditMenu *menu,
WEditMenuItem *item)
static Bool shouldRemoveItem(struct WEditMenuDelegate *delegate,
WEditMenu *menu, WEditMenuItem *item)
{ {
_Panel *panel = (_Panel*)delegate->data; _Panel *panel = (_Panel*)delegate->data;
if (panel->dontAsk) if (panel->dontAsk)
return True; return True;
if (WGetEditMenuSubmenu(menu, item)) { if (WGetEditMenuSubmenu(menu, item)) {
int res; int res;

52
WPrefs.app/editmenu.c
View File

@@ -164,26 +164,29 @@ WCreateEditMenuItem(WMWidget *parent, char *title, Bool isTitle)
return iPtr; return iPtr;
} }
char *WGetEditMenuItemTitle(WEditMenuItem *item) char*
WGetEditMenuItemTitle(WEditMenuItem *item)
{ {
return item->label; return item->label;
} }
void *WGetEditMenuItemData(WEditMenuItem *item) void*
WGetEditMenuItemData(WEditMenuItem *item)
{ {
return item->data; return item->data;
} }
void WSetEditMenuItemData(WEditMenuItem *item, void *data, void
WMCallback *destroyer) WSetEditMenuItemData(WEditMenuItem *item, void *data, WMCallback *destroyer)
{ {
item->data = data; item->data = data;
item->destroyData = destroyer; item->destroyData = destroyer;
} }
void WSetEditMenuItemImage(WEditMenuItem *item, WMPixmap *pixmap) void
WSetEditMenuItemImage(WEditMenuItem *item, WMPixmap *pixmap)
{ {
if (item->pixmap) if (item->pixmap)
WMReleasePixmap(item->pixmap); WMReleasePixmap(item->pixmap);
@@ -315,10 +318,9 @@ static void updateMenuContents(WEditMenu *mPtr);
static void handleEvents(XEvent *event, void *data); static void handleEvents(XEvent *event, void *data);
static void editItemLabel(WEditMenuItem *item); static void editItemLabel(WEditMenuItem *item);
static void stopEditItem(WEditMenu *menu, Bool apply); static void stopEditItem(WEditMenu *menu, Bool apply);
static void unmapMenu(WEditMenu *menu);
static void deselectItem(WEditMenu *menu); static void deselectItem(WEditMenu *menu);
@@ -594,12 +596,10 @@ WGetEditMenuSubmenu(WEditMenu *mPtr, WEditMenuItem *item)
} }
static int simpleMatch(void *a, void *b) static int
simpleMatch(void *a, void *b)
{ {
if (a == b) return ((a == b) ? 1 : 0);
return 1;
else
return 0;
} }
@@ -692,7 +692,7 @@ closeMenuAction(WMWidget *w, void *data)
WMAddIdleHandler(WMDestroyWidget, menu->closeB); WMAddIdleHandler(WMDestroyWidget, menu->closeB);
menu->closeB = NULL; menu->closeB = NULL;
unmapMenu(menu); WEditMenuHide(menu);
} }
@@ -790,17 +790,32 @@ updateMenuContents(WEditMenu *mPtr)
} }
static void void
unmapMenu(WEditMenu *menu) WEditMenuHide(WEditMenu *menu)
{ {
WMUnmapWidget(menu); WMUnmapWidget(menu);
if (menu->selectedItem) { if (menu->selectedItem) {
deselectItem(menu); deselectItem(menu);
} }
} }
void
WEditMenuUnhide(WEditMenu *menu)
{
WMMapWidget(menu);
}
void
WEditMenuShowAt(WEditMenu *menu, int x, int y)
{
WMMoveWidget(menu, x, y);
WMMapWidget(menu);
}
static void static void
deselectItem(WEditMenu *menu) deselectItem(WEditMenu *menu)
{ {
@@ -815,7 +830,7 @@ deselectItem(WEditMenu *menu)
submenu = item->submenu; submenu = item->submenu;
if (submenu && !WEditMenuIsTornOff(submenu)) { if (submenu && !WEditMenuIsTornOff(submenu)) {
unmapMenu(submenu); WEditMenuHide(submenu);
} }
menu->selectedItem = NULL; menu->selectedItem = NULL;
@@ -1057,7 +1072,8 @@ slideWindow(Display *dpy, Window win, int srcX, int srcY, int dstX, int dstY)
} }
static int errorHandler(Display *d, XErrorEvent *ev) static int
errorHandler(Display *d, XErrorEvent *ev)
{ {
/* just ignore */ /* just ignore */
return 0; return 0;

13
WPrefs.app/editmenu.h
View File

@@ -21,6 +21,9 @@
*/ */
#ifndef _editmenu_h_
#define _editmenu_h_
typedef struct W_EditMenu WEditMenu; typedef struct W_EditMenu WEditMenu;
typedef struct W_EditMenuItem WEditMenuItem; typedef struct W_EditMenuItem WEditMenuItem;
@@ -98,3 +101,13 @@ WMPoint WGetEditMenuLocationForSubmenu(WEditMenu *mPtr, WEditMenu *submenu);
void WTearOffEditMenu(WEditMenu *menu, WEditMenu *submenu); void WTearOffEditMenu(WEditMenu *menu, WEditMenu *submenu);
Bool WEditMenuIsTornOff(WEditMenu *mPtr); Bool WEditMenuIsTornOff(WEditMenu *mPtr);
void WEditMenuHide(WEditMenu *menu);
void WEditMenuUnhide(WEditMenu *menu);
void WEdirMenuShowAt(WEditMenu *menu, int x, int y);
#endif