Compare commits
67
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
d3dac752cc | ||
|
|
0893be1cea | ||
|
|
d8057575ce | ||
|
|
d8912c58e6 | ||
|
|
b7f765e3f6 | ||
|
|
d88d626fbe | ||
|
|
5847e9d68f | ||
|
|
adb967ab15 | ||
|
|
0c4d78a53d | ||
|
|
dcd45f0677 | ||
|
|
0097d1819e | ||
|
|
8270124869 | ||
|
|
89183f3bcb | ||
|
|
46e540b1b1 | ||
|
|
9802b684ae | ||
|
|
0a04a4c12e | ||
|
|
e1a263cc5b | ||
|
|
c298b5f96f | ||
|
|
dfd77b11a9 | ||
|
|
927cc93e0a | ||
|
|
d2046de7ff | ||
|
|
a7a44397a4 | ||
|
|
72a1f8cb9e | ||
|
|
60902b9222 | ||
|
|
46af2c27ee | ||
|
|
026426e6c3 | ||
|
|
564501953f | ||
|
|
8c68f95291 | ||
|
|
d66eb34f16 | ||
|
|
65726a1e6a | ||
|
|
fbd6400186 | ||
|
|
4f4dcf551b | ||
|
|
bd61e58821 | ||
|
|
1a8d99b2c0 | ||
|
|
7bded0055f | ||
|
|
32c40643c2 | ||
|
|
157a8e0d5a | ||
|
|
252362545e | ||
|
|
f69227ce19 | ||
|
|
bc163d13f6 | ||
|
|
2d2dd9febe | ||
|
|
14c316615e | ||
|
|
6a98614d13 | ||
|
|
dfdaa67b4d | ||
|
|
e6fd7e49f8 | ||
|
|
12930739ec | ||
|
|
cf588d6e27 | ||
|
|
f3961ba66f | ||
|
|
5b593fb19a | ||
|
|
f2e9123db6 | ||
|
|
791149fe70 | ||
|
|
52b0e6b182 | ||
|
|
bbcf40ee47 | ||
|
|
9d07e2d3d8 | ||
|
|
dea8c36cd5 | ||
|
|
3beadbb6cb | ||
|
|
dd36130730 | ||
|
|
6ede7a5cb0 | ||
|
|
2b9b915768 | ||
|
|
d50adaa1c8 | ||
|
|
5b0ad78f01 | ||
|
|
46fcbb0ff1 | ||
|
|
e3fb8ddbc8 | ||
|
|
59ad67f4dc | ||
|
|
d91275d959 | ||
|
|
5325e2d455 | ||
|
|
82c8b0c9b4 |
No files matched your search
+1
-1
@@ -142,4 +142,4 @@ WPrefs.app/WPrefs.desktop
|
||||
.pc
|
||||
|
||||
# Rust stuff.
|
||||
/wmakerlib/target/**
|
||||
/*/target/**
|
||||
+1
-1
@@ -39,7 +39,7 @@ ACLOCAL_AMFLAGS = -I m4
|
||||
AM_DISTCHECK_CONFIGURE_FLAGS = --enable-silent-rules LINGUAS='*'
|
||||
|
||||
|
||||
SUBDIRS = wrlib WINGs src util po WindowMaker wmlib WPrefs.app doc
|
||||
SUBDIRS = wrlib wutil-rs WINGs wmaker-rs src util po WindowMaker wmlib WPrefs.app doc
|
||||
DIST_SUBDIRS = $(SUBDIRS) test
|
||||
|
||||
EXTRA_DIST = TODO BUGS BUGFORM FAQ INSTALL \
|
||||
|
||||
+6
-11
@@ -10,14 +10,17 @@ libWUtil_la_LDFLAGS = -version-info @WUTIL_VERSION@
|
||||
|
||||
lib_LTLIBRARIES = libWUtil.la libWINGs.la
|
||||
|
||||
wutilrs = $(top_builddir)/wutil-rs/target/debug/libwutil_rs.a
|
||||
wraster = $(top_builddir)/wrlib/libwraster.la
|
||||
|
||||
LDADD= libWUtil.la libWINGs.la $(top_builddir)/wrlib/libwraster.la @INTLIBS@
|
||||
libWINGs_la_LIBADD = libWUtil.la $(top_builddir)/wrlib/libwraster.la @XLIBS@ @XFT_LIBS@ @FCLIBS@ @LIBM@ @PANGO_LIBS@
|
||||
libWUtil_la_LIBADD = @LIBBSD@
|
||||
LDADD= libWUtil.la libWINGs.la $(wraster) $(wutilrs) @INTLIBS@
|
||||
libWINGs_la_LIBADD = libWUtil.la $(wraster) $(wutilrs) @XLIBS@ @XFT_LIBS@ @FCLIBS@ @LIBM@ @PANGO_LIBS@
|
||||
libWUtil_la_LIBADD = $(wutilrs)
|
||||
|
||||
EXTRA_DIST = BUGS make-rgb Examples Extras Tests
|
||||
|
||||
|
||||
|
||||
# wbutton.c
|
||||
libWINGs_la_SOURCES = \
|
||||
configuration.c \
|
||||
@@ -62,23 +65,15 @@ libWINGs_la_SOURCES = \
|
||||
wwindow.c
|
||||
|
||||
libWUtil_la_SOURCES = \
|
||||
array.c \
|
||||
bagtree.c \
|
||||
data.c \
|
||||
error.c \
|
||||
error.h \
|
||||
findfile.c \
|
||||
handlers.c \
|
||||
hashtable.c \
|
||||
memory.c \
|
||||
menuparser.c \
|
||||
menuparser.h \
|
||||
menuparser_macros.c \
|
||||
misc.c \
|
||||
notification.c \
|
||||
proplist.c \
|
||||
string.c \
|
||||
tree.c \
|
||||
userdefaults.c \
|
||||
userdefaults.h \
|
||||
usleep.c \
|
||||
|
||||
+7
-10
@@ -233,7 +233,7 @@ typedef enum {
|
||||
|
||||
|
||||
/* text movement types */
|
||||
enum {
|
||||
typedef enum {
|
||||
WMIllegalTextMovement,
|
||||
WMReturnTextMovement,
|
||||
WMEscapeTextMovement,
|
||||
@@ -243,13 +243,13 @@ enum {
|
||||
WMRightTextMovement,
|
||||
WMUpTextMovement,
|
||||
WMDownTextMovement
|
||||
};
|
||||
} WMTextMovementType;
|
||||
|
||||
/* text field special events */
|
||||
enum {
|
||||
typedef enum {
|
||||
WMInsertTextEvent,
|
||||
WMDeleteTextEvent
|
||||
};
|
||||
} WMTextFieldSpecialEventType;
|
||||
|
||||
|
||||
enum {
|
||||
@@ -533,14 +533,11 @@ typedef struct WMBrowserDelegate {
|
||||
typedef struct WMTextFieldDelegate {
|
||||
void *data;
|
||||
|
||||
void (*didBeginEditing)(struct WMTextFieldDelegate *self,
|
||||
WMNotification *notif);
|
||||
void (*didBeginEditing)(struct WMTextFieldDelegate *self, WMTextMovementType reason);
|
||||
|
||||
void (*didChange)(struct WMTextFieldDelegate *self,
|
||||
WMNotification *notif);
|
||||
void (*didChange)(struct WMTextFieldDelegate *self, WMTextFieldSpecialEventType reason);
|
||||
|
||||
void (*didEndEditing)(struct WMTextFieldDelegate *self,
|
||||
WMNotification *notif);
|
||||
void (*didEndEditing)(struct WMTextFieldDelegate *self, WMTextMovementType reason);
|
||||
|
||||
Bool (*shouldBeginEditing)(struct WMTextFieldDelegate *self,
|
||||
WMTextField *tPtr);
|
||||
|
||||
@@ -378,10 +378,6 @@ void W_InitNotificationCenter(void);
|
||||
|
||||
void W_ReleaseNotificationCenter(void);
|
||||
|
||||
void W_FlushASAPNotificationQueue(void);
|
||||
|
||||
void W_FlushIdleNotificationQueue(void);
|
||||
|
||||
|
||||
/* ---[ selection.c ]----------------------------------------------------- */
|
||||
|
||||
|
||||
+32
-192
@@ -169,15 +169,11 @@ typedef struct {
|
||||
unsigned (*hash)(const void *);
|
||||
/* NULL is pointer compare */
|
||||
Bool (*keyIsEqual)(const void *, const void *);
|
||||
/* NULL does nothing */
|
||||
void* (*retainKey)(const void *);
|
||||
/* NULL does nothing */
|
||||
void (*releaseKey)(const void *);
|
||||
} WMHashTableCallbacks;
|
||||
|
||||
|
||||
typedef int WMArrayIterator;
|
||||
typedef void *WMBagIterator;
|
||||
typedef int WMBagIterator;
|
||||
|
||||
|
||||
typedef void WMNotificationObserverAction(void *observerData,
|
||||
@@ -213,10 +209,6 @@ void wfree(void *ptr);
|
||||
void wrelease(void *ptr);
|
||||
void* wretain(void *ptr);
|
||||
|
||||
typedef void waborthandler(int);
|
||||
|
||||
waborthandler* wsetabort(waborthandler* handler);
|
||||
|
||||
/* ---[ WINGs/error.c ]--------------------------------------------------- */
|
||||
|
||||
enum {
|
||||
@@ -248,11 +240,14 @@ char* wexpandpath(const char *path);
|
||||
|
||||
int wcopy_file(const char *toPath, const char *srcFile, const char *destFile);
|
||||
|
||||
/* don't free the returned string */
|
||||
const char* wgethomedir(void);
|
||||
/* You must free the returned string! */
|
||||
char* wgethomedir(void);
|
||||
|
||||
/* ---[ WINGs/proplist.c ]------------------------------------------------ */
|
||||
|
||||
/*
|
||||
* Creates the directory path and all its parents.
|
||||
*/
|
||||
int wmkdirhier(const char *path);
|
||||
int wrmdirhier(const char *path);
|
||||
|
||||
@@ -276,14 +271,9 @@ char* wstrconcat(const char *str1, const char *str2);
|
||||
* so always assign the returned address to avoid dangling pointers. */
|
||||
char* wstrappend(char *dst, const char *src);
|
||||
|
||||
size_t wstrlcpy(char *, const char *, size_t);
|
||||
size_t wstrlcat(char *, const char *, size_t);
|
||||
|
||||
|
||||
void wtokensplit(char *command, char ***argv, int *argc);
|
||||
|
||||
char* wtokennext(char *word, char **next);
|
||||
|
||||
char* wtokenjoin(char **list, int count);
|
||||
|
||||
void wtokenfree(char **tokens, int count);
|
||||
@@ -342,7 +332,8 @@ void WHandleEvents(void);
|
||||
/* ---[ WINGs/hashtable.c ]----------------------------------------------- */
|
||||
|
||||
|
||||
WMHashTable* WMCreateHashTable(const WMHashTableCallbacks callbacks);
|
||||
WMHashTable* WMCreateIdentityHashTable();
|
||||
WMHashTable* WMCreateStringHashTable();
|
||||
|
||||
void WMFreeHashTable(WMHashTable *table);
|
||||
|
||||
@@ -392,15 +383,11 @@ Bool WMNextHashEnumeratorItemAndKey(WMHashEnumerator *enumerator,
|
||||
extern const WMHashTableCallbacks WMIntHashCallbacks;
|
||||
/* sizeof(keys) are <= sizeof(void*) */
|
||||
|
||||
extern const WMHashTableCallbacks WMStringHashCallbacks;
|
||||
/* keys are strings. Strings will be copied with wstrdup()
|
||||
* and freed with wfree() */
|
||||
|
||||
extern const WMHashTableCallbacks WMStringPointerHashCallbacks;
|
||||
/* keys are strings, but they are not copied */
|
||||
|
||||
|
||||
/* ---[ WINGs/array.c ]--------------------------------------------------- */
|
||||
/* ---[ wutil-rs/src/array.rs ]--------------------------------------------------- */
|
||||
|
||||
/*
|
||||
* WMArray use an array to store the elements.
|
||||
@@ -422,29 +409,22 @@ WMArray* WMCreateArrayWithDestructor(int initialSize, WMFreeDataProc *destructor
|
||||
|
||||
WMArray* WMCreateArrayWithArray(WMArray *array);
|
||||
|
||||
#define WMDuplicateArray(array) WMCreateArrayWithArray(array)
|
||||
|
||||
void WMEmptyArray(WMArray *array);
|
||||
|
||||
void WMFreeArray(WMArray *array);
|
||||
|
||||
int WMGetArrayItemCount(WMArray *array);
|
||||
|
||||
/* appends other to array. other remains unchanged */
|
||||
void WMAppendArray(WMArray *array, WMArray *other);
|
||||
|
||||
/* add will place the element at the end of the array */
|
||||
void WMAddToArray(WMArray *array, void *item);
|
||||
|
||||
/* insert will increment the index of elements after it by 1 */
|
||||
void WMInsertInArray(WMArray *array, int index, void *item);
|
||||
|
||||
/* replace and set will return the old item WITHOUT calling the
|
||||
/* set returns the old item WITHOUT calling the
|
||||
* destructor on it even if its available. Free the returned item yourself.
|
||||
*/
|
||||
void* WMReplaceInArray(WMArray *array, int index, void *item);
|
||||
|
||||
#define WMSetInArray(array, index, item) WMReplaceInArray(array, index, item)
|
||||
void* WMSetInArray(WMArray *array, int index, void *item);
|
||||
|
||||
/* delete and remove will remove the elements and cause the elements
|
||||
* after them to decrement their indexes by 1. Also will call the
|
||||
@@ -452,20 +432,21 @@ void* WMReplaceInArray(WMArray *array, int index, void *item);
|
||||
*/
|
||||
int WMDeleteFromArray(WMArray *array, int index);
|
||||
|
||||
#define WMRemoveFromArray(array, item) WMRemoveFromArrayMatching(array, NULL, item)
|
||||
int WMRemoveFromArray(WMArray *array, void *item);
|
||||
|
||||
int WMRemoveFromArrayMatching(WMArray *array, WMMatchDataProc *match, void *cdata);
|
||||
|
||||
void* WMGetFromArray(WMArray *array, int index);
|
||||
|
||||
#define WMGetFirstInArray(array, item) WMFindInArray(array, NULL, item)
|
||||
|
||||
/* pop will return the last element from the array, also removing it
|
||||
* from the array. The destructor is NOT called, even if available.
|
||||
* Free the returned element if needed by yourself
|
||||
*/
|
||||
void* WMPopFromArray(WMArray *array);
|
||||
|
||||
/* Like WMFindInArray(array, NULL, item) */
|
||||
int WMGetFirstInArray(WMArray *array, void *item);
|
||||
|
||||
int WMFindInArray(WMArray *array, WMMatchDataProc *match, void *cdata);
|
||||
|
||||
int WMCountInArray(WMArray *array, void *item);
|
||||
@@ -479,8 +460,6 @@ void WMSortArray(WMArray *array, WMCompareDataProc *comparer);
|
||||
|
||||
void WMMapArray(WMArray *array, void (*function)(void*, void*), void *data);
|
||||
|
||||
WMArray* WMGetSubarrayWithRange(WMArray* array, WMRange aRange);
|
||||
|
||||
void* WMArrayFirst(WMArray *array, WMArrayIterator *iter);
|
||||
|
||||
void* WMArrayLast(WMArray *array, WMArrayIterator *iter);
|
||||
@@ -500,7 +479,7 @@ void* WMArrayPrevious(WMArray *array, WMArrayIterator *iter);
|
||||
for (var = WMArrayLast(array, &(i)); (i) != WANotFound; \
|
||||
var = WMArrayPrevious(array, &(i)))
|
||||
|
||||
/* ---[ WINGs/bagtree.c ]------------------------------------------------- */
|
||||
/* ---[ wutil-rs/src/bag.rs ]------------------------------------------------- */
|
||||
|
||||
/*
|
||||
* Tree bags use a red-black tree for storage.
|
||||
@@ -515,58 +494,16 @@ void* WMArrayPrevious(WMArray *array, WMArrayIterator *iter);
|
||||
* Slow for storing small numbers of elements
|
||||
*/
|
||||
|
||||
#define WMCreateBag(size) WMCreateTreeBag()
|
||||
|
||||
#define WMCreateBagWithDestructor(size, d) WMCreateTreeBagWithDestructor(d)
|
||||
|
||||
WMBag* WMCreateTreeBag(void);
|
||||
|
||||
WMBag* WMCreateTreeBagWithDestructor(WMFreeDataProc *destructor);
|
||||
|
||||
int WMGetBagItemCount(WMBag *bag);
|
||||
|
||||
void WMAppendBag(WMBag *bag, WMBag *other);
|
||||
|
||||
void WMPutInBag(WMBag *bag, void *item);
|
||||
|
||||
/* insert will increment the index of elements after it by 1 */
|
||||
void WMInsertInBag(WMBag *bag, int index, void *item);
|
||||
|
||||
/* erase will remove the element from the bag,
|
||||
* but will keep the index of the other elements unchanged */
|
||||
int WMEraseFromBag(WMBag *bag, int index);
|
||||
|
||||
/* delete and remove will remove the elements and cause the elements
|
||||
* after them to decrement their indexes by 1 */
|
||||
int WMDeleteFromBag(WMBag *bag, int index);
|
||||
|
||||
int WMRemoveFromBag(WMBag *bag, void *item);
|
||||
|
||||
void* WMGetFromBag(WMBag *bag, int index);
|
||||
|
||||
void* WMReplaceInBag(WMBag *bag, int index, void *item);
|
||||
|
||||
#define WMSetInBag(bag, index, item) WMReplaceInBag(bag, index, item)
|
||||
|
||||
/* comparer must return:
|
||||
* < 0 if a < b
|
||||
* > 0 if a > b
|
||||
* = 0 if a = b
|
||||
*/
|
||||
void WMSortBag(WMBag *bag, WMCompareDataProc *comparer);
|
||||
void WMSetInBag(WMBag *bag, int index, void *item);
|
||||
|
||||
void WMEmptyBag(WMBag *bag);
|
||||
|
||||
void WMFreeBag(WMBag *bag);
|
||||
|
||||
void WMMapBag(WMBag *bag, void (*function)(void*, void*), void *data);
|
||||
|
||||
int WMGetFirstInBag(WMBag *bag, void *item);
|
||||
|
||||
int WMCountInBag(WMBag *bag, void *item);
|
||||
|
||||
int WMFindInBag(WMBag *bag, WMMatchDataProc *match, void *cdata);
|
||||
|
||||
void* WMBagFirst(WMBag *bag, WMBagIterator *ptr);
|
||||
|
||||
void* WMBagLast(WMBag *bag, WMBagIterator *ptr);
|
||||
@@ -578,16 +515,11 @@ void* WMBagPrevious(WMBag *bag, WMBagIterator *ptr);
|
||||
|
||||
void* WMBagIteratorAtIndex(WMBag *bag, int index, WMBagIterator *ptr);
|
||||
|
||||
int WMBagIndexForIterator(WMBag *bag, WMBagIterator ptr);
|
||||
|
||||
|
||||
/* The following 2 macros assume that the bag doesn't change in the for loop */
|
||||
#define WM_ITERATE_BAG(bag, var, i) \
|
||||
for (var = WMBagFirst(bag, &(i)); (i) != NULL; \
|
||||
var = WMBagNext(bag, &(i)))
|
||||
/* The following macro assumes that the bag doesn't change in the for loop */
|
||||
|
||||
#define WM_ETARETI_BAG(bag, var, i) \
|
||||
for (var = WMBagLast(bag, &(i)); (i) != NULL; \
|
||||
for (var = WMBagLast(bag, &(i)); (i) >= 0; \
|
||||
var = WMBagPrevious(bag, &(i)))
|
||||
|
||||
|
||||
@@ -604,37 +536,16 @@ WMData* WMCreateDataWithLength(unsigned length);
|
||||
|
||||
WMData* WMCreateDataWithBytes(const void *bytes, unsigned length);
|
||||
|
||||
/* destructor is a function called to free the data when releasing the data
|
||||
* object, or NULL if no freeing of data is necesary. */
|
||||
WMData* WMCreateDataWithBytesNoCopy(void *bytes, unsigned length,
|
||||
WMFreeDataProc *destructor);
|
||||
|
||||
WMData* WMCreateDataWithData(WMData *aData);
|
||||
|
||||
WMData* WMRetainData(WMData *aData);
|
||||
|
||||
void WMReleaseData(WMData *aData);
|
||||
|
||||
/* Adjusting capacity */
|
||||
|
||||
void WMSetDataCapacity(WMData *aData, unsigned capacity);
|
||||
|
||||
void WMSetDataLength(WMData *aData, unsigned length);
|
||||
|
||||
void WMIncreaseDataLengthBy(WMData *aData, unsigned extraLength);
|
||||
|
||||
/* Accessing data */
|
||||
|
||||
const void* WMDataBytes(WMData *aData);
|
||||
|
||||
void WMGetDataBytes(WMData *aData, void *buffer);
|
||||
|
||||
void WMGetDataBytesWithLength(WMData *aData, void *buffer, unsigned length);
|
||||
|
||||
void WMGetDataBytesWithRange(WMData *aData, void *buffer, WMRange aRange);
|
||||
|
||||
WMData* WMGetSubdataWithRange(WMData *aData, WMRange aRange);
|
||||
|
||||
/* Testing data */
|
||||
|
||||
Bool WMIsDataEqualToData(WMData *aData, WMData *anotherData);
|
||||
@@ -649,10 +560,6 @@ void WMAppendData(WMData *aData, WMData *anotherData);
|
||||
|
||||
/* Modifying data */
|
||||
|
||||
void WMReplaceDataBytesInRange(WMData *aData, WMRange aRange, const void *bytes);
|
||||
|
||||
void WMResetDataBytesInRange(WMData *aData, WMRange aRange);
|
||||
|
||||
void WMSetData(WMData *aData, WMData *anotherData);
|
||||
|
||||
|
||||
@@ -661,14 +568,12 @@ void WMSetDataFormat(WMData *aData, unsigned format);
|
||||
unsigned WMGetDataFormat(WMData *aData);
|
||||
/* Storing data */
|
||||
|
||||
/* ---[ WINGs/tree.c ]---------------------------------------------------- */
|
||||
/* ---[ wutil-rs/src/tree.rs ]---------------------------------------------------- */
|
||||
|
||||
/* Generic Tree and TreeNode */
|
||||
|
||||
WMTreeNode* WMCreateTreeNode(void *data);
|
||||
|
||||
WMTreeNode* WMCreateTreeNodeWithDestructor(void *data, WMFreeDataProc *destructor);
|
||||
|
||||
WMTreeNode* WMInsertItemInTree(WMTreeNode *parent, int index, void *item);
|
||||
|
||||
#define WMAddItemToTree(parent, item) WMInsertItemInTree(parent, -1, item)
|
||||
@@ -677,48 +582,23 @@ WMTreeNode* WMInsertNodeInTree(WMTreeNode *parent, int index, WMTreeNode *aNode)
|
||||
|
||||
#define WMAddNodeToTree(parent, aNode) WMInsertNodeInTree(parent, -1, aNode)
|
||||
|
||||
void WMDestroyTreeNode(WMTreeNode *aNode);
|
||||
|
||||
void WMDeleteLeafForTreeNode(WMTreeNode *aNode, int index);
|
||||
|
||||
void WMRemoveLeafForTreeNode(WMTreeNode *aNode, void *leaf);
|
||||
|
||||
void* WMReplaceDataForTreeNode(WMTreeNode *aNode, void *newData);
|
||||
|
||||
void* WMGetDataForTreeNode(WMTreeNode *aNode);
|
||||
|
||||
int WMGetTreeNodeDepth(WMTreeNode *aNode);
|
||||
|
||||
WMTreeNode* WMGetParentForTreeNode(WMTreeNode *aNode);
|
||||
|
||||
/* Sort only the leaves of the passed node */
|
||||
void WMSortLeavesForTreeNode(WMTreeNode *aNode, WMCompareDataProc *comparer);
|
||||
|
||||
/* Sort all tree recursively starting from the passed node */
|
||||
void WMSortTree(WMTreeNode *aNode, WMCompareDataProc *comparer);
|
||||
|
||||
/* Returns the first node which matches node's data with cdata by 'match' */
|
||||
WMTreeNode* WMFindInTree(WMTreeNode *aTree, WMMatchDataProc *match, void *cdata);
|
||||
void WMSortTree(WMTreeNode *aNode, int (*comparer)(const WMTreeNode *a, const WMTreeNode *b));
|
||||
|
||||
/* Returns the first node where node's data matches cdata by 'match' and node is
|
||||
* at most `limit' depths down from `aTree'. */
|
||||
WMTreeNode *WMFindInTreeWithDepthLimit(WMTreeNode * aTree, WMMatchDataProc * match, void *cdata, int limit);
|
||||
|
||||
/* Returns first tree node that has data == cdata */
|
||||
#define WMGetFirstInTree(aTree, cdata) WMFindInTree(aTree, NULL, cdata)
|
||||
WMTreeNode *WMFindInTreeWithDepthLimit(WMTreeNode * aTree, int (*match)(const WMTreeNode *item, const void *cdata), void *cdata, int limit);
|
||||
|
||||
/* Walk every node of aNode with `walk' */
|
||||
void WMTreeWalk(WMTreeNode *aNode, WMTreeWalkProc * walk, void *data, Bool DepthFirst);
|
||||
void WMTreeWalk(WMTreeNode *aNode, WMTreeWalkProc * walk, void *data);
|
||||
|
||||
/* ---[ WINGs/data.c ]---------------------------------------------------- */
|
||||
/* ---[ WINGs/notification.c ]---------------------------------------------------- */
|
||||
|
||||
|
||||
WMNotification* WMCreateNotification(const char *name, void *object, void *clientData);
|
||||
|
||||
void WMReleaseNotification(WMNotification *notification);
|
||||
|
||||
WMNotification* WMRetainNotification(WMNotification *notification);
|
||||
|
||||
void* WMGetNotificationClientData(WMNotification *notification);
|
||||
|
||||
void* WMGetNotificationObject(WMNotification *notification);
|
||||
@@ -729,52 +609,27 @@ const char* WMGetNotificationName(WMNotification *notification);
|
||||
void WMAddNotificationObserver(WMNotificationObserverAction *observerAction,
|
||||
void *observer, const char *name, void *object);
|
||||
|
||||
void WMPostNotification(WMNotification *notification);
|
||||
|
||||
void WMRemoveNotificationObserver(void *observer);
|
||||
|
||||
void WMRemoveNotificationObserverWithName(void *observer, const char *name,
|
||||
void *object);
|
||||
|
||||
void WMPostNotificationName(const char *name, void *object, void *clientData);
|
||||
|
||||
WMNotificationQueue* WMGetDefaultNotificationQueue(void);
|
||||
|
||||
WMNotificationQueue* WMCreateNotificationQueue(void);
|
||||
|
||||
void WMDequeueNotificationMatching(WMNotificationQueue *queue,
|
||||
WMNotification *notification,
|
||||
unsigned mask);
|
||||
|
||||
void WMEnqueueNotification(WMNotificationQueue *queue,
|
||||
WMNotification *notification,
|
||||
WMPostingStyle postingStyle);
|
||||
|
||||
void WMEnqueueCoalesceNotification(WMNotificationQueue *queue,
|
||||
WMNotification *notification,
|
||||
WMPostingStyle postingStyle,
|
||||
unsigned coalesceMask);
|
||||
|
||||
/* Property Lists handling */
|
||||
|
||||
/* ---[ WINGs/proplist.c ]------------------------------------------------ */
|
||||
|
||||
/* Property Lists handling */
|
||||
WMPropList* WMCreatePLArray(WMPropList *elem, ...);
|
||||
|
||||
void WMPLSetCaseSensitive(Bool caseSensitive);
|
||||
/* ---[ wutil-rs/src/prop_list.rs ]--------------------------------------- */
|
||||
|
||||
WMPropList* WMCreatePLString(const char *str);
|
||||
|
||||
WMPropList* WMCreatePLData(WMData *data);
|
||||
WMPropList* WMCreatePLArrayFromSlice(WMPropList *elems, unsigned int length);
|
||||
|
||||
WMPropList* WMCreatePLDataWithBytes(const unsigned char *bytes, unsigned int length);
|
||||
WMPropList* WMCreateEmptyPLArray();
|
||||
|
||||
WMPropList* WMCreatePLDataWithBytesNoCopy(unsigned char *bytes,
|
||||
unsigned int length,
|
||||
WMFreeDataProc *destructor);
|
||||
WMPropList* WMCreatePLDictionary(WMPropList *key, WMPropList *value);
|
||||
|
||||
WMPropList* WMCreatePLArray(WMPropList *elem, ...);
|
||||
|
||||
WMPropList* WMCreatePLDictionary(WMPropList *key, WMPropList *value, ...);
|
||||
WMPropList* WMCreateEmptyPLDictionary();
|
||||
|
||||
WMPropList* WMRetainPropList(WMPropList *plist);
|
||||
|
||||
@@ -812,8 +667,6 @@ int WMGetPropListItemCount(WMPropList *plist);
|
||||
|
||||
Bool WMIsPLString(WMPropList *plist);
|
||||
|
||||
Bool WMIsPLData(WMPropList *plist);
|
||||
|
||||
Bool WMIsPLArray(WMPropList *plist);
|
||||
|
||||
Bool WMIsPLDictionary(WMPropList *plist);
|
||||
@@ -823,14 +676,6 @@ Bool WMIsPropListEqualTo(WMPropList *plist, WMPropList *other);
|
||||
/* Returns a reference. Do not free it! */
|
||||
char* WMGetFromPLString(WMPropList *plist);
|
||||
|
||||
/* Returns a reference. Do not free it! */
|
||||
WMData* WMGetFromPLData(WMPropList *plist);
|
||||
|
||||
/* Returns a reference. Do not free it! */
|
||||
const unsigned char* WMGetPLDataBytes(WMPropList *plist);
|
||||
|
||||
int WMGetPLDataLength(WMPropList *plist);
|
||||
|
||||
/* Returns a reference. */
|
||||
WMPropList* WMGetFromPLArray(WMPropList *plist, int index);
|
||||
|
||||
@@ -838,14 +683,9 @@ WMPropList* WMGetFromPLArray(WMPropList *plist, int index);
|
||||
WMPropList* WMGetFromPLDictionary(WMPropList *plist, WMPropList *key);
|
||||
|
||||
/* Returns a PropList array with all the dictionary keys. Release it when
|
||||
* you're done. Keys in array are retained from the original dictionary
|
||||
* not copied and need NOT to be released individually. */
|
||||
* you're done. */
|
||||
WMPropList* WMGetPLDictionaryKeys(WMPropList *plist);
|
||||
|
||||
/* Creates only the first level deep object. All the elements inside are
|
||||
* retained from the original */
|
||||
WMPropList* WMShallowCopyPropList(WMPropList *plist);
|
||||
|
||||
/* Makes a completely separate replica of the original proplist */
|
||||
WMPropList* WMDeepCopyPropList(WMPropList *plist);
|
||||
|
||||
|
||||
-363
@@ -1,363 +0,0 @@
|
||||
/*
|
||||
* Dynamically Resized Array
|
||||
*
|
||||
* Authors: Alfredo K. Kojima <kojima@windowmaker.info>
|
||||
* Dan Pascu <dan@windowmaker.info>
|
||||
*
|
||||
* This code is released to the Public Domain, but
|
||||
* proper credit is always appreciated :)
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "WUtil.h"
|
||||
|
||||
#define INITIAL_SIZE 8
|
||||
#define RESIZE_INCREMENT 8
|
||||
|
||||
typedef struct W_Array {
|
||||
void **items; /* the array data */
|
||||
int itemCount; /* # of items in array */
|
||||
int allocSize; /* allocated size of array */
|
||||
WMFreeDataProc *destructor; /* the destructor to free elements */
|
||||
} W_Array;
|
||||
|
||||
WMArray *WMCreateArray(int initialSize)
|
||||
{
|
||||
return WMCreateArrayWithDestructor(initialSize, NULL);
|
||||
}
|
||||
|
||||
WMArray *WMCreateArrayWithDestructor(int initialSize, WMFreeDataProc * destructor)
|
||||
{
|
||||
WMArray *array;
|
||||
|
||||
array = wmalloc(sizeof(WMArray));
|
||||
|
||||
if (initialSize <= 0) {
|
||||
initialSize = INITIAL_SIZE;
|
||||
}
|
||||
|
||||
array->items = wmalloc(sizeof(void *) * initialSize);
|
||||
|
||||
array->itemCount = 0;
|
||||
array->allocSize = initialSize;
|
||||
array->destructor = destructor;
|
||||
|
||||
return array;
|
||||
}
|
||||
|
||||
WMArray *WMCreateArrayWithArray(WMArray * array)
|
||||
{
|
||||
WMArray *newArray;
|
||||
|
||||
newArray = wmalloc(sizeof(WMArray));
|
||||
|
||||
newArray->items = wmalloc(sizeof(void *) * array->allocSize);
|
||||
memcpy(newArray->items, array->items, sizeof(void *) * array->itemCount);
|
||||
|
||||
newArray->itemCount = array->itemCount;
|
||||
newArray->allocSize = array->allocSize;
|
||||
newArray->destructor = NULL;
|
||||
|
||||
return newArray;
|
||||
}
|
||||
|
||||
void WMEmptyArray(WMArray * array)
|
||||
{
|
||||
if (array->destructor) {
|
||||
while (array->itemCount > 0) {
|
||||
array->itemCount--;
|
||||
array->destructor(array->items[array->itemCount]);
|
||||
}
|
||||
}
|
||||
/*memset(array->items, 0, array->itemCount * sizeof(void*)); */
|
||||
array->itemCount = 0;
|
||||
}
|
||||
|
||||
void WMFreeArray(WMArray * array)
|
||||
{
|
||||
if (array == NULL)
|
||||
return;
|
||||
|
||||
WMEmptyArray(array);
|
||||
wfree(array->items);
|
||||
wfree(array);
|
||||
}
|
||||
|
||||
int WMGetArrayItemCount(WMArray * array)
|
||||
{
|
||||
if (array == NULL)
|
||||
return 0;
|
||||
|
||||
return array->itemCount;
|
||||
}
|
||||
|
||||
void WMAppendArray(WMArray * array, WMArray * other)
|
||||
{
|
||||
if (array == NULL || other == NULL)
|
||||
return;
|
||||
|
||||
if (other->itemCount == 0)
|
||||
return;
|
||||
|
||||
if (array->itemCount + other->itemCount > array->allocSize) {
|
||||
array->allocSize += other->allocSize;
|
||||
array->items = wrealloc(array->items, sizeof(void *) * array->allocSize);
|
||||
}
|
||||
|
||||
memcpy(array->items + array->itemCount, other->items, sizeof(void *) * other->itemCount);
|
||||
array->itemCount += other->itemCount;
|
||||
}
|
||||
|
||||
void WMAddToArray(WMArray * array, void *item)
|
||||
{
|
||||
if (array == NULL)
|
||||
return;
|
||||
|
||||
if (array->itemCount >= array->allocSize) {
|
||||
array->allocSize += RESIZE_INCREMENT;
|
||||
array->items = wrealloc(array->items, sizeof(void *) * array->allocSize);
|
||||
}
|
||||
array->items[array->itemCount] = item;
|
||||
|
||||
array->itemCount++;
|
||||
}
|
||||
|
||||
void WMInsertInArray(WMArray * array, int index, void *item)
|
||||
{
|
||||
if (array == NULL)
|
||||
return;
|
||||
|
||||
wassertr(index >= 0 && index <= array->itemCount);
|
||||
|
||||
if (array->itemCount >= array->allocSize) {
|
||||
array->allocSize += RESIZE_INCREMENT;
|
||||
array->items = wrealloc(array->items, sizeof(void *) * array->allocSize);
|
||||
}
|
||||
if (index < array->itemCount) {
|
||||
memmove(array->items + index + 1, array->items + index,
|
||||
sizeof(void *) * (array->itemCount - index));
|
||||
}
|
||||
array->items[index] = item;
|
||||
|
||||
array->itemCount++;
|
||||
}
|
||||
|
||||
void *WMReplaceInArray(WMArray * array, int index, void *item)
|
||||
{
|
||||
void *old;
|
||||
|
||||
if (array == NULL)
|
||||
return NULL;
|
||||
|
||||
wassertrv(index >= 0 && index <= array->itemCount, NULL);
|
||||
|
||||
/* is it really useful to perform append if index == array->itemCount ? -Dan */
|
||||
if (index == array->itemCount) {
|
||||
WMAddToArray(array, item);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
old = array->items[index];
|
||||
array->items[index] = item;
|
||||
|
||||
return old;
|
||||
}
|
||||
|
||||
int WMDeleteFromArray(WMArray * array, int index)
|
||||
{
|
||||
if (array == NULL)
|
||||
return 0;
|
||||
|
||||
wassertrv(index >= 0 && index < array->itemCount, 0);
|
||||
|
||||
if (array->destructor) {
|
||||
array->destructor(array->items[index]);
|
||||
}
|
||||
|
||||
if (index < array->itemCount - 1) {
|
||||
memmove(array->items + index, array->items + index + 1,
|
||||
sizeof(void *) * (array->itemCount - index - 1));
|
||||
}
|
||||
|
||||
array->itemCount--;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
int WMRemoveFromArrayMatching(WMArray * array, WMMatchDataProc * match, void *cdata)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (array == NULL)
|
||||
return 1;
|
||||
|
||||
if (match != NULL) {
|
||||
for (i = 0; i < array->itemCount; i++) {
|
||||
if ((*match) (array->items[i], cdata)) {
|
||||
WMDeleteFromArray(array, i);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (i = 0; i < array->itemCount; i++) {
|
||||
if (array->items[i] == cdata) {
|
||||
WMDeleteFromArray(array, i);
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void *WMGetFromArray(WMArray * array, int index)
|
||||
{
|
||||
if (index < 0 || array == NULL || index >= array->itemCount)
|
||||
return NULL;
|
||||
|
||||
return array->items[index];
|
||||
}
|
||||
|
||||
void *WMPopFromArray(WMArray * array)
|
||||
{
|
||||
if (array == NULL || array->itemCount <= 0)
|
||||
return NULL;
|
||||
|
||||
array->itemCount--;
|
||||
|
||||
return array->items[array->itemCount];
|
||||
}
|
||||
|
||||
int WMFindInArray(WMArray * array, WMMatchDataProc * match, void *cdata)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (array == NULL)
|
||||
return WANotFound;
|
||||
|
||||
if (match != NULL) {
|
||||
for (i = 0; i < array->itemCount; i++) {
|
||||
if ((*match) (array->items[i], cdata))
|
||||
return i;
|
||||
}
|
||||
} else {
|
||||
for (i = 0; i < array->itemCount; i++) {
|
||||
if (array->items[i] == cdata)
|
||||
return i;
|
||||
}
|
||||
}
|
||||
|
||||
return WANotFound;
|
||||
}
|
||||
|
||||
int WMCountInArray(WMArray * array, void *item)
|
||||
{
|
||||
int i, count;
|
||||
|
||||
if (array == NULL)
|
||||
return 0;
|
||||
|
||||
for (i = 0, count = 0; i < array->itemCount; i++) {
|
||||
if (array->items[i] == item)
|
||||
count++;
|
||||
}
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
void WMSortArray(WMArray * array, WMCompareDataProc * comparer)
|
||||
{
|
||||
if (array == NULL)
|
||||
return;
|
||||
|
||||
if (array->itemCount > 1) { /* Don't sort empty or single element arrays */
|
||||
qsort(array->items, array->itemCount, sizeof(void *), comparer);
|
||||
}
|
||||
}
|
||||
|
||||
void WMMapArray(WMArray * array, void (*function) (void *, void *), void *data)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (array == NULL)
|
||||
return;
|
||||
|
||||
for (i = 0; i < array->itemCount; i++) {
|
||||
(*function) (array->items[i], data);
|
||||
}
|
||||
}
|
||||
|
||||
WMArray *WMGetSubarrayWithRange(WMArray * array, WMRange aRange)
|
||||
{
|
||||
WMArray *newArray;
|
||||
|
||||
if (aRange.count <= 0 || array == NULL)
|
||||
return WMCreateArray(0);
|
||||
|
||||
if (aRange.position < 0)
|
||||
aRange.position = 0;
|
||||
if (aRange.position >= array->itemCount)
|
||||
aRange.position = array->itemCount - 1;
|
||||
if (aRange.position + aRange.count > array->itemCount)
|
||||
aRange.count = array->itemCount - aRange.position;
|
||||
|
||||
newArray = WMCreateArray(aRange.count);
|
||||
memcpy(newArray->items, array->items + aRange.position, sizeof(void *) * aRange.count);
|
||||
newArray->itemCount = aRange.count;
|
||||
|
||||
return newArray;
|
||||
}
|
||||
|
||||
void *WMArrayFirst(WMArray * array, WMArrayIterator * iter)
|
||||
{
|
||||
if (array == NULL || array->itemCount == 0) {
|
||||
*iter = WANotFound;
|
||||
return NULL;
|
||||
} else {
|
||||
*iter = 0;
|
||||
return array->items[0];
|
||||
}
|
||||
}
|
||||
|
||||
void *WMArrayLast(WMArray * array, WMArrayIterator * iter)
|
||||
{
|
||||
if (array == NULL || array->itemCount == 0) {
|
||||
*iter = WANotFound;
|
||||
return NULL;
|
||||
} else {
|
||||
*iter = array->itemCount - 1;
|
||||
return array->items[*iter];
|
||||
}
|
||||
}
|
||||
|
||||
void *WMArrayNext(WMArray * array, WMArrayIterator * iter)
|
||||
{
|
||||
if (array == NULL) {
|
||||
*iter = WANotFound;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (*iter >= 0 && *iter < array->itemCount - 1) {
|
||||
return array->items[++(*iter)];
|
||||
} else {
|
||||
*iter = WANotFound;
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void *WMArrayPrevious(WMArray * array, WMArrayIterator * iter)
|
||||
{
|
||||
if (array == NULL) {
|
||||
*iter = WANotFound;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (*iter > 0 && *iter < array->itemCount) {
|
||||
return array->items[--(*iter)];
|
||||
} else {
|
||||
*iter = WANotFound;
|
||||
return NULL;
|
||||
}
|
||||
}
|
||||
-745
@@ -1,745 +0,0 @@
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "WUtil.h"
|
||||
|
||||
typedef struct W_Node {
|
||||
struct W_Node *parent;
|
||||
struct W_Node *left;
|
||||
struct W_Node *right;
|
||||
int color;
|
||||
|
||||
void *data;
|
||||
int index;
|
||||
} W_Node;
|
||||
|
||||
typedef struct W_Bag {
|
||||
W_Node *root;
|
||||
|
||||
W_Node *nil; /* sentinel */
|
||||
|
||||
int count;
|
||||
|
||||
void (*destructor) (void *item);
|
||||
} W_Bag;
|
||||
|
||||
#define IS_LEFT(node) (node == node->parent->left)
|
||||
#define IS_RIGHT(node) (node == node->parent->right)
|
||||
|
||||
static void leftRotate(W_Bag * tree, W_Node * node)
|
||||
{
|
||||
W_Node *node2;
|
||||
|
||||
node2 = node->right;
|
||||
node->right = node2->left;
|
||||
|
||||
node2->left->parent = node;
|
||||
|
||||
node2->parent = node->parent;
|
||||
|
||||
if (node->parent == tree->nil) {
|
||||
tree->root = node2;
|
||||
} else {
|
||||
if (IS_LEFT(node)) {
|
||||
node->parent->left = node2;
|
||||
} else {
|
||||
node->parent->right = node2;
|
||||
}
|
||||
}
|
||||
node2->left = node;
|
||||
node->parent = node2;
|
||||
}
|
||||
|
||||
static void rightRotate(W_Bag * tree, W_Node * node)
|
||||
{
|
||||
W_Node *node2;
|
||||
|
||||
node2 = node->left;
|
||||
node->left = node2->right;
|
||||
|
||||
node2->right->parent = node;
|
||||
|
||||
node2->parent = node->parent;
|
||||
|
||||
if (node->parent == tree->nil) {
|
||||
tree->root = node2;
|
||||
} else {
|
||||
if (IS_LEFT(node)) {
|
||||
node->parent->left = node2;
|
||||
} else {
|
||||
node->parent->right = node2;
|
||||
}
|
||||
}
|
||||
node2->right = node;
|
||||
node->parent = node2;
|
||||
}
|
||||
|
||||
static void treeInsert(W_Bag * tree, W_Node * node)
|
||||
{
|
||||
W_Node *y = tree->nil;
|
||||
W_Node *x = tree->root;
|
||||
|
||||
while (x != tree->nil) {
|
||||
y = x;
|
||||
if (node->index <= x->index)
|
||||
x = x->left;
|
||||
else
|
||||
x = x->right;
|
||||
}
|
||||
node->parent = y;
|
||||
if (y == tree->nil)
|
||||
tree->root = node;
|
||||
else if (node->index <= y->index)
|
||||
y->left = node;
|
||||
else
|
||||
y->right = node;
|
||||
}
|
||||
|
||||
static void rbTreeInsert(W_Bag * tree, W_Node * node)
|
||||
{
|
||||
W_Node *y;
|
||||
|
||||
treeInsert(tree, node);
|
||||
|
||||
node->color = 'R';
|
||||
|
||||
while (node != tree->root && node->parent->color == 'R') {
|
||||
if (IS_LEFT(node->parent)) {
|
||||
y = node->parent->parent->right;
|
||||
|
||||
if (y->color == 'R') {
|
||||
|
||||
node->parent->color = 'B';
|
||||
y->color = 'B';
|
||||
node->parent->parent->color = 'R';
|
||||
node = node->parent->parent;
|
||||
|
||||
} else {
|
||||
if (IS_RIGHT(node)) {
|
||||
node = node->parent;
|
||||
leftRotate(tree, node);
|
||||
}
|
||||
node->parent->color = 'B';
|
||||
node->parent->parent->color = 'R';
|
||||
rightRotate(tree, node->parent->parent);
|
||||
}
|
||||
} else {
|
||||
y = node->parent->parent->left;
|
||||
|
||||
if (y->color == 'R') {
|
||||
|
||||
node->parent->color = 'B';
|
||||
y->color = 'B';
|
||||
node->parent->parent->color = 'R';
|
||||
node = node->parent->parent;
|
||||
|
||||
} else {
|
||||
if (IS_LEFT(node)) {
|
||||
node = node->parent;
|
||||
rightRotate(tree, node);
|
||||
}
|
||||
node->parent->color = 'B';
|
||||
node->parent->parent->color = 'R';
|
||||
leftRotate(tree, node->parent->parent);
|
||||
}
|
||||
}
|
||||
}
|
||||
tree->root->color = 'B';
|
||||
}
|
||||
|
||||
static void rbDeleteFixup(W_Bag * tree, W_Node * node)
|
||||
{
|
||||
W_Node *w;
|
||||
|
||||
while (node != tree->root && node->color == 'B') {
|
||||
if (IS_LEFT(node)) {
|
||||
w = node->parent->right;
|
||||
if (w->color == 'R') {
|
||||
w->color = 'B';
|
||||
node->parent->color = 'R';
|
||||
leftRotate(tree, node->parent);
|
||||
w = node->parent->right;
|
||||
}
|
||||
if (w->left->color == 'B' && w->right->color == 'B') {
|
||||
w->color = 'R';
|
||||
node = node->parent;
|
||||
} else {
|
||||
if (w->right->color == 'B') {
|
||||
w->left->color = 'B';
|
||||
w->color = 'R';
|
||||
rightRotate(tree, w);
|
||||
w = node->parent->right;
|
||||
}
|
||||
w->color = node->parent->color;
|
||||
node->parent->color = 'B';
|
||||
w->right->color = 'B';
|
||||
leftRotate(tree, node->parent);
|
||||
node = tree->root;
|
||||
}
|
||||
} else {
|
||||
w = node->parent->left;
|
||||
if (w->color == 'R') {
|
||||
w->color = 'B';
|
||||
node->parent->color = 'R';
|
||||
rightRotate(tree, node->parent);
|
||||
w = node->parent->left;
|
||||
}
|
||||
if (w->left->color == 'B' && w->right->color == 'B') {
|
||||
w->color = 'R';
|
||||
node = node->parent;
|
||||
} else {
|
||||
if (w->left->color == 'B') {
|
||||
w->right->color = 'B';
|
||||
w->color = 'R';
|
||||
leftRotate(tree, w);
|
||||
w = node->parent->left;
|
||||
}
|
||||
w->color = node->parent->color;
|
||||
node->parent->color = 'B';
|
||||
w->left->color = 'B';
|
||||
rightRotate(tree, node->parent);
|
||||
node = tree->root;
|
||||
}
|
||||
}
|
||||
}
|
||||
node->color = 'B';
|
||||
|
||||
}
|
||||
|
||||
static W_Node *treeMinimum(W_Node * node, W_Node * nil)
|
||||
{
|
||||
while (node->left != nil)
|
||||
node = node->left;
|
||||
return node;
|
||||
}
|
||||
|
||||
static W_Node *treeMaximum(W_Node * node, W_Node * nil)
|
||||
{
|
||||
while (node->right != nil)
|
||||
node = node->right;
|
||||
return node;
|
||||
}
|
||||
|
||||
static W_Node *treeSuccessor(W_Node * node, W_Node * nil)
|
||||
{
|
||||
W_Node *y;
|
||||
|
||||
if (node->right != nil) {
|
||||
return treeMinimum(node->right, nil);
|
||||
}
|
||||
y = node->parent;
|
||||
while (y != nil && node == y->right) {
|
||||
node = y;
|
||||
y = y->parent;
|
||||
}
|
||||
return y;
|
||||
}
|
||||
|
||||
static W_Node *treePredecessor(W_Node * node, W_Node * nil)
|
||||
{
|
||||
W_Node *y;
|
||||
|
||||
if (node->left != nil) {
|
||||
return treeMaximum(node->left, nil);
|
||||
}
|
||||
y = node->parent;
|
||||
while (y != nil && node == y->left) {
|
||||
node = y;
|
||||
y = y->parent;
|
||||
}
|
||||
return y;
|
||||
}
|
||||
|
||||
static W_Node *rbTreeDelete(W_Bag * tree, W_Node * node)
|
||||
{
|
||||
W_Node *nil = tree->nil;
|
||||
W_Node *x, *y;
|
||||
|
||||
if (node->left == nil || node->right == nil) {
|
||||
y = node;
|
||||
} else {
|
||||
y = treeSuccessor(node, nil);
|
||||
}
|
||||
|
||||
if (y->left != nil) {
|
||||
x = y->left;
|
||||
} else {
|
||||
x = y->right;
|
||||
}
|
||||
|
||||
x->parent = y->parent;
|
||||
|
||||
if (y->parent == nil) {
|
||||
tree->root = x;
|
||||
} else {
|
||||
if (IS_LEFT(y)) {
|
||||
y->parent->left = x;
|
||||
} else {
|
||||
y->parent->right = x;
|
||||
}
|
||||
}
|
||||
if (y != node) {
|
||||
node->index = y->index;
|
||||
node->data = y->data;
|
||||
}
|
||||
if (y->color == 'B') {
|
||||
rbDeleteFixup(tree, x);
|
||||
}
|
||||
|
||||
return y;
|
||||
}
|
||||
|
||||
static W_Node *treeSearch(W_Node * root, W_Node * nil, int index)
|
||||
{
|
||||
if (root == nil || root->index == index) {
|
||||
return root;
|
||||
}
|
||||
|
||||
if (index < root->index) {
|
||||
return treeSearch(root->left, nil, index);
|
||||
} else {
|
||||
return treeSearch(root->right, nil, index);
|
||||
}
|
||||
}
|
||||
|
||||
static W_Node *treeFind(W_Node * root, W_Node * nil, void *data)
|
||||
{
|
||||
W_Node *tmp;
|
||||
|
||||
if (root == nil || root->data == data)
|
||||
return root;
|
||||
|
||||
tmp = treeFind(root->left, nil, data);
|
||||
if (tmp != nil)
|
||||
return tmp;
|
||||
|
||||
tmp = treeFind(root->right, nil, data);
|
||||
|
||||
return tmp;
|
||||
}
|
||||
|
||||
#if 0
|
||||
static char buf[512];
|
||||
|
||||
static void printNodes(W_Node * node, W_Node * nil, int depth)
|
||||
{
|
||||
if (node == nil) {
|
||||
return;
|
||||
}
|
||||
|
||||
printNodes(node->left, nil, depth + 1);
|
||||
|
||||
memset(buf, ' ', depth * 2);
|
||||
buf[depth * 2] = 0;
|
||||
if (IS_LEFT(node))
|
||||
printf("%s/(%2i\n", buf, node->index);
|
||||
else
|
||||
printf("%s\\(%2i\n", buf, node->index);
|
||||
|
||||
printNodes(node->right, nil, depth + 1);
|
||||
}
|
||||
|
||||
void PrintTree(WMBag * bag)
|
||||
{
|
||||
W_TreeBag *tree = (W_TreeBag *) bag->data;
|
||||
|
||||
printNodes(tree->root, tree->nil, 0);
|
||||
}
|
||||
#endif
|
||||
|
||||
WMBag *WMCreateTreeBag(void)
|
||||
{
|
||||
return WMCreateTreeBagWithDestructor(NULL);
|
||||
}
|
||||
|
||||
WMBag *WMCreateTreeBagWithDestructor(WMFreeDataProc * destructor)
|
||||
{
|
||||
WMBag *bag;
|
||||
|
||||
bag = wmalloc(sizeof(WMBag));
|
||||
bag->nil = wmalloc(sizeof(W_Node));
|
||||
bag->nil->left = bag->nil->right = bag->nil->parent = bag->nil;
|
||||
bag->nil->index = WBNotFound;
|
||||
bag->root = bag->nil;
|
||||
bag->destructor = destructor;
|
||||
|
||||
return bag;
|
||||
}
|
||||
|
||||
int WMGetBagItemCount(WMBag * self)
|
||||
{
|
||||
return self->count;
|
||||
}
|
||||
|
||||
void WMAppendBag(WMBag * self, WMBag * bag)
|
||||
{
|
||||
WMBagIterator ptr;
|
||||
void *data;
|
||||
|
||||
for (data = WMBagFirst(bag, &ptr); data != NULL; data = WMBagNext(bag, &ptr)) {
|
||||
WMPutInBag(self, data);
|
||||
}
|
||||
}
|
||||
|
||||
void WMPutInBag(WMBag * self, void *item)
|
||||
{
|
||||
W_Node *ptr;
|
||||
|
||||
ptr = wmalloc(sizeof(W_Node));
|
||||
|
||||
ptr->data = item;
|
||||
ptr->index = self->count;
|
||||
ptr->left = self->nil;
|
||||
ptr->right = self->nil;
|
||||
ptr->parent = self->nil;
|
||||
|
||||
rbTreeInsert(self, ptr);
|
||||
|
||||
self->count++;
|
||||
}
|
||||
|
||||
void WMInsertInBag(WMBag * self, int index, void *item)
|
||||
{
|
||||
W_Node *ptr;
|
||||
|
||||
ptr = wmalloc(sizeof(W_Node));
|
||||
|
||||
ptr->data = item;
|
||||
ptr->index = index;
|
||||
ptr->left = self->nil;
|
||||
ptr->right = self->nil;
|
||||
ptr->parent = self->nil;
|
||||
|
||||
rbTreeInsert(self, ptr);
|
||||
|
||||
while ((ptr = treeSuccessor(ptr, self->nil)) != self->nil) {
|
||||
ptr->index++;
|
||||
}
|
||||
|
||||
self->count++;
|
||||
}
|
||||
|
||||
static int treeDeleteNode(WMBag * self, W_Node *ptr)
|
||||
{
|
||||
if (ptr != self->nil) {
|
||||
W_Node *tmp;
|
||||
|
||||
self->count--;
|
||||
|
||||
tmp = treeSuccessor(ptr, self->nil);
|
||||
while (tmp != self->nil) {
|
||||
tmp->index--;
|
||||
tmp = treeSuccessor(tmp, self->nil);
|
||||
}
|
||||
|
||||
ptr = rbTreeDelete(self, ptr);
|
||||
if (self->destructor)
|
||||
self->destructor(ptr->data);
|
||||
wfree(ptr);
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int WMRemoveFromBag(WMBag * self, void *item)
|
||||
{
|
||||
W_Node *ptr = treeFind(self->root, self->nil, item);
|
||||
return treeDeleteNode(self, ptr);
|
||||
}
|
||||
|
||||
int WMEraseFromBag(WMBag * self, int index)
|
||||
{
|
||||
W_Node *ptr = treeSearch(self->root, self->nil, index);
|
||||
|
||||
if (ptr != self->nil) {
|
||||
|
||||
self->count--;
|
||||
|
||||
ptr = rbTreeDelete(self, ptr);
|
||||
if (self->destructor)
|
||||
self->destructor(ptr->data);
|
||||
wfree(ptr);
|
||||
|
||||
wassertrv(self->count == 0 || self->root->index >= 0, 1);
|
||||
|
||||
return 1;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
int WMDeleteFromBag(WMBag * self, int index)
|
||||
{
|
||||
W_Node *ptr = treeSearch(self->root, self->nil, index);
|
||||
return treeDeleteNode(self, ptr);
|
||||
}
|
||||
|
||||
void *WMGetFromBag(WMBag * self, int index)
|
||||
{
|
||||
W_Node *node;
|
||||
|
||||
node = treeSearch(self->root, self->nil, index);
|
||||
if (node != self->nil)
|
||||
return node->data;
|
||||
else
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int WMGetFirstInBag(WMBag * self, void *item)
|
||||
{
|
||||
W_Node *node;
|
||||
|
||||
node = treeFind(self->root, self->nil, item);
|
||||
if (node != self->nil)
|
||||
return node->index;
|
||||
else
|
||||
return WBNotFound;
|
||||
}
|
||||
|
||||
static int treeCount(W_Node * root, W_Node * nil, void *item)
|
||||
{
|
||||
int count = 0;
|
||||
|
||||
if (root == nil)
|
||||
return 0;
|
||||
|
||||
if (root->data == item)
|
||||
count++;
|
||||
|
||||
if (root->left != nil)
|
||||
count += treeCount(root->left, nil, item);
|
||||
|
||||
if (root->right != nil)
|
||||
count += treeCount(root->right, nil, item);
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
int WMCountInBag(WMBag * self, void *item)
|
||||
{
|
||||
return treeCount(self->root, self->nil, item);
|
||||
}
|
||||
|
||||
void *WMReplaceInBag(WMBag * self, int index, void *item)
|
||||
{
|
||||
W_Node *ptr = treeSearch(self->root, self->nil, index);
|
||||
void *old = NULL;
|
||||
|
||||
if (item == NULL) {
|
||||
self->count--;
|
||||
ptr = rbTreeDelete(self, ptr);
|
||||
if (self->destructor)
|
||||
self->destructor(ptr->data);
|
||||
wfree(ptr);
|
||||
} else if (ptr != self->nil) {
|
||||
old = ptr->data;
|
||||
ptr->data = item;
|
||||
} else {
|
||||
W_Node *ptr;
|
||||
|
||||
ptr = wmalloc(sizeof(W_Node));
|
||||
|
||||
ptr->data = item;
|
||||
ptr->index = index;
|
||||
ptr->left = self->nil;
|
||||
ptr->right = self->nil;
|
||||
ptr->parent = self->nil;
|
||||
|
||||
rbTreeInsert(self, ptr);
|
||||
|
||||
self->count++;
|
||||
}
|
||||
|
||||
return old;
|
||||
}
|
||||
|
||||
void WMSortBag(WMBag * self, WMCompareDataProc * comparer)
|
||||
{
|
||||
void **items;
|
||||
W_Node *tmp;
|
||||
int i;
|
||||
|
||||
if (self->count == 0)
|
||||
return;
|
||||
|
||||
items = wmalloc(sizeof(void *) * self->count);
|
||||
i = 0;
|
||||
|
||||
tmp = treeMinimum(self->root, self->nil);
|
||||
while (tmp != self->nil) {
|
||||
items[i++] = tmp->data;
|
||||
tmp = treeSuccessor(tmp, self->nil);
|
||||
}
|
||||
|
||||
qsort(&items[0], self->count, sizeof(void *), comparer);
|
||||
|
||||
i = 0;
|
||||
tmp = treeMinimum(self->root, self->nil);
|
||||
while (tmp != self->nil) {
|
||||
tmp->index = i;
|
||||
tmp->data = items[i++];
|
||||
tmp = treeSuccessor(tmp, self->nil);
|
||||
}
|
||||
|
||||
wfree(items);
|
||||
}
|
||||
|
||||
static void deleteTree(WMBag * self, W_Node * node)
|
||||
{
|
||||
if (node == self->nil)
|
||||
return;
|
||||
|
||||
deleteTree(self, node->left);
|
||||
|
||||
if (self->destructor)
|
||||
self->destructor(node->data);
|
||||
|
||||
deleteTree(self, node->right);
|
||||
|
||||
wfree(node);
|
||||
}
|
||||
|
||||
void WMEmptyBag(WMBag * self)
|
||||
{
|
||||
deleteTree(self, self->root);
|
||||
self->root = self->nil;
|
||||
self->count = 0;
|
||||
}
|
||||
|
||||
void WMFreeBag(WMBag * self)
|
||||
{
|
||||
WMEmptyBag(self);
|
||||
wfree(self->nil);
|
||||
wfree(self);
|
||||
}
|
||||
|
||||
static void mapTree(W_Bag * tree, W_Node * node, void (*function) (void *, void *), void *data)
|
||||
{
|
||||
if (node == tree->nil)
|
||||
return;
|
||||
|
||||
mapTree(tree, node->left, function, data);
|
||||
|
||||
(*function) (node->data, data);
|
||||
|
||||
mapTree(tree, node->right, function, data);
|
||||
}
|
||||
|
||||
void WMMapBag(WMBag * self, void (*function) (void *, void *), void *data)
|
||||
{
|
||||
mapTree(self, self->root, function, data);
|
||||
}
|
||||
|
||||
static int findInTree(W_Bag * tree, W_Node * node, WMMatchDataProc * function, void *cdata)
|
||||
{
|
||||
int index;
|
||||
|
||||
if (node == tree->nil)
|
||||
return WBNotFound;
|
||||
|
||||
index = findInTree(tree, node->left, function, cdata);
|
||||
if (index != WBNotFound)
|
||||
return index;
|
||||
|
||||
if ((*function) (node->data, cdata)) {
|
||||
return node->index;
|
||||
}
|
||||
|
||||
return findInTree(tree, node->right, function, cdata);
|
||||
}
|
||||
|
||||
int WMFindInBag(WMBag * self, WMMatchDataProc * match, void *cdata)
|
||||
{
|
||||
return findInTree(self, self->root, match, cdata);
|
||||
}
|
||||
|
||||
void *WMBagFirst(WMBag * self, WMBagIterator * ptr)
|
||||
{
|
||||
W_Node *node;
|
||||
|
||||
node = treeMinimum(self->root, self->nil);
|
||||
|
||||
if (node == self->nil) {
|
||||
*ptr = NULL;
|
||||
return NULL;
|
||||
} else {
|
||||
*ptr = node;
|
||||
return node->data;
|
||||
}
|
||||
}
|
||||
|
||||
void *WMBagLast(WMBag * self, WMBagIterator * ptr)
|
||||
{
|
||||
|
||||
W_Node *node;
|
||||
|
||||
node = treeMaximum(self->root, self->nil);
|
||||
|
||||
if (node == self->nil) {
|
||||
*ptr = NULL;
|
||||
return NULL;
|
||||
} else {
|
||||
*ptr = node;
|
||||
return node->data;
|
||||
}
|
||||
}
|
||||
|
||||
void *WMBagNext(WMBag * self, WMBagIterator * ptr)
|
||||
{
|
||||
W_Node *node;
|
||||
|
||||
if (*ptr == NULL)
|
||||
return NULL;
|
||||
|
||||
node = treeSuccessor(*ptr, self->nil);
|
||||
|
||||
if (node == self->nil) {
|
||||
*ptr = NULL;
|
||||
return NULL;
|
||||
} else {
|
||||
*ptr = node;
|
||||
return node->data;
|
||||
}
|
||||
}
|
||||
|
||||
void *WMBagPrevious(WMBag * self, WMBagIterator * ptr)
|
||||
{
|
||||
W_Node *node;
|
||||
|
||||
if (*ptr == NULL)
|
||||
return NULL;
|
||||
|
||||
node = treePredecessor(*ptr, self->nil);
|
||||
|
||||
if (node == self->nil) {
|
||||
*ptr = NULL;
|
||||
return NULL;
|
||||
} else {
|
||||
*ptr = node;
|
||||
return node->data;
|
||||
}
|
||||
}
|
||||
|
||||
void *WMBagIteratorAtIndex(WMBag * self, int index, WMBagIterator * ptr)
|
||||
{
|
||||
W_Node *node;
|
||||
|
||||
node = treeSearch(self->root, self->nil, index);
|
||||
|
||||
if (node == self->nil) {
|
||||
*ptr = NULL;
|
||||
return NULL;
|
||||
} else {
|
||||
*ptr = node;
|
||||
return node->data;
|
||||
}
|
||||
}
|
||||
|
||||
int WMBagIndexForIterator(WMBag * bag, WMBagIterator ptr)
|
||||
{
|
||||
/* Parameter not used, but tell the compiler that it is ok */
|
||||
(void) bag;
|
||||
|
||||
return ((W_Node *) ptr)->index;
|
||||
}
|
||||
-289
@@ -1,289 +0,0 @@
|
||||
/*
|
||||
* WINGs WMData function library
|
||||
*
|
||||
* Copyright (c) 1999-2003 Dan Pascu
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston,
|
||||
* MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include <string.h>
|
||||
#include "WUtil.h"
|
||||
|
||||
typedef struct W_Data {
|
||||
unsigned length; /* How many bytes we have */
|
||||
unsigned capacity; /* How many bytes it can hold */
|
||||
unsigned growth; /* How much to grow */
|
||||
void *bytes; /* Actual data */
|
||||
unsigned retainCount;
|
||||
WMFreeDataProc *destructor;
|
||||
int format; /* 0, 8, 16 or 32 */
|
||||
} W_Data;
|
||||
|
||||
/* Creating and destroying data objects */
|
||||
|
||||
WMData *WMCreateDataWithCapacity(unsigned capacity)
|
||||
{
|
||||
WMData *aData;
|
||||
|
||||
aData = (WMData *) wmalloc(sizeof(WMData));
|
||||
|
||||
if (capacity > 0)
|
||||
aData->bytes = wmalloc(capacity);
|
||||
else
|
||||
aData->bytes = NULL;
|
||||
|
||||
aData->capacity = capacity;
|
||||
aData->growth = capacity / 2 > 0 ? capacity / 2 : 1;
|
||||
aData->length = 0;
|
||||
aData->retainCount = 1;
|
||||
aData->format = 0;
|
||||
aData->destructor = wfree;
|
||||
|
||||
return aData;
|
||||
}
|
||||
|
||||
WMData *WMCreateDataWithLength(unsigned length)
|
||||
{
|
||||
WMData *aData;
|
||||
|
||||
aData = WMCreateDataWithCapacity(length);
|
||||
if (length > 0) {
|
||||
aData->length = length;
|
||||
}
|
||||
|
||||
return aData;
|
||||
}
|
||||
|
||||
WMData *WMCreateDataWithBytes(const void *bytes, unsigned length)
|
||||
{
|
||||
WMData *aData;
|
||||
|
||||
aData = WMCreateDataWithCapacity(length);
|
||||
aData->length = length;
|
||||
memcpy(aData->bytes, bytes, length);
|
||||
|
||||
return aData;
|
||||
}
|
||||
|
||||
WMData *WMCreateDataWithBytesNoCopy(void *bytes, unsigned length, WMFreeDataProc * destructor)
|
||||
{
|
||||
WMData *aData;
|
||||
|
||||
aData = (WMData *) wmalloc(sizeof(WMData));
|
||||
aData->length = length;
|
||||
aData->capacity = length;
|
||||
aData->growth = length / 2 > 0 ? length / 2 : 1;
|
||||
aData->bytes = bytes;
|
||||
aData->retainCount = 1;
|
||||
aData->format = 0;
|
||||
aData->destructor = destructor;
|
||||
|
||||
return aData;
|
||||
}
|
||||
|
||||
WMData *WMCreateDataWithData(WMData * aData)
|
||||
{
|
||||
WMData *newData;
|
||||
|
||||
if (aData->length > 0) {
|
||||
newData = WMCreateDataWithBytes(aData->bytes, aData->length);
|
||||
} else {
|
||||
newData = WMCreateDataWithCapacity(0);
|
||||
}
|
||||
newData->format = aData->format;
|
||||
|
||||
return newData;
|
||||
}
|
||||
|
||||
WMData *WMRetainData(WMData * aData)
|
||||
{
|
||||
aData->retainCount++;
|
||||
return aData;
|
||||
}
|
||||
|
||||
void WMReleaseData(WMData * aData)
|
||||
{
|
||||
aData->retainCount--;
|
||||
if (aData->retainCount > 0)
|
||||
return;
|
||||
if (aData->bytes != NULL && aData->destructor != NULL) {
|
||||
aData->destructor(aData->bytes);
|
||||
}
|
||||
wfree(aData);
|
||||
}
|
||||
|
||||
/* Adjusting capacity */
|
||||
|
||||
void WMSetDataCapacity(WMData * aData, unsigned capacity)
|
||||
{
|
||||
if (aData->capacity != capacity) {
|
||||
aData->bytes = wrealloc(aData->bytes, capacity);
|
||||
aData->capacity = capacity;
|
||||
aData->growth = capacity / 2 > 0 ? capacity / 2 : 1;
|
||||
}
|
||||
if (aData->length > capacity) {
|
||||
aData->length = capacity;
|
||||
}
|
||||
}
|
||||
|
||||
void WMSetDataLength(WMData * aData, unsigned length)
|
||||
{
|
||||
if (length > aData->capacity) {
|
||||
WMSetDataCapacity(aData, length);
|
||||
}
|
||||
if (length > aData->length) {
|
||||
memset((unsigned char *)aData->bytes + aData->length, 0, length - aData->length);
|
||||
}
|
||||
aData->length = length;
|
||||
}
|
||||
|
||||
void WMSetDataFormat(WMData * aData, unsigned format)
|
||||
{
|
||||
aData->format = format;
|
||||
}
|
||||
|
||||
void WMIncreaseDataLengthBy(WMData * aData, unsigned extraLength)
|
||||
{
|
||||
WMSetDataLength(aData, aData->length + extraLength);
|
||||
}
|
||||
|
||||
/* Accessing data */
|
||||
|
||||
const void *WMDataBytes(WMData * aData)
|
||||
{
|
||||
return aData->bytes;
|
||||
}
|
||||
|
||||
void WMGetDataBytes(WMData * aData, void *buffer)
|
||||
{
|
||||
wassertr(aData->length > 0);
|
||||
|
||||
memcpy(buffer, aData->bytes, aData->length);
|
||||
}
|
||||
|
||||
unsigned WMGetDataFormat(WMData * aData)
|
||||
{
|
||||
return aData->format;
|
||||
}
|
||||
|
||||
void WMGetDataBytesWithLength(WMData * aData, void *buffer, unsigned length)
|
||||
{
|
||||
wassertr(aData->length > 0);
|
||||
wassertr(length <= aData->length);
|
||||
|
||||
memcpy(buffer, aData->bytes, length);
|
||||
}
|
||||
|
||||
void WMGetDataBytesWithRange(WMData * aData, void *buffer, WMRange aRange)
|
||||
{
|
||||
wassertr(aRange.position < aData->length);
|
||||
wassertr(aRange.count <= aData->length - aRange.position);
|
||||
|
||||
memcpy(buffer, (unsigned char *)aData->bytes + aRange.position, aRange.count);
|
||||
}
|
||||
|
||||
WMData *WMGetSubdataWithRange(WMData * aData, WMRange aRange)
|
||||
{
|
||||
void *buffer;
|
||||
WMData *newData;
|
||||
|
||||
if (aRange.count <= 0)
|
||||
return WMCreateDataWithCapacity(0);
|
||||
|
||||
buffer = wmalloc(aRange.count);
|
||||
WMGetDataBytesWithRange(aData, buffer, aRange);
|
||||
newData = WMCreateDataWithBytesNoCopy(buffer, aRange.count, wfree);
|
||||
newData->format = aData->format;
|
||||
|
||||
return newData;
|
||||
}
|
||||
|
||||
/* Testing data */
|
||||
|
||||
Bool WMIsDataEqualToData(WMData * aData, WMData * anotherData)
|
||||
{
|
||||
if (aData->length != anotherData->length)
|
||||
return False;
|
||||
else if (!aData->bytes && !anotherData->bytes) /* both are empty */
|
||||
return True;
|
||||
else if (!aData->bytes || !anotherData->bytes) /* one of them is empty */
|
||||
return False;
|
||||
return (memcmp(aData->bytes, anotherData->bytes, aData->length) == 0);
|
||||
}
|
||||
|
||||
unsigned WMGetDataLength(WMData * aData)
|
||||
{
|
||||
return aData->length;
|
||||
}
|
||||
|
||||
/* Adding data */
|
||||
void WMAppendDataBytes(WMData * aData, const void *bytes, unsigned length)
|
||||
{
|
||||
unsigned oldLength = aData->length;
|
||||
unsigned newLength = oldLength + length;
|
||||
|
||||
if (newLength > aData->capacity) {
|
||||
unsigned nextCapacity = aData->capacity + aData->growth;
|
||||
unsigned nextGrowth = aData->capacity ? aData->capacity : 1;
|
||||
|
||||
while (nextCapacity < newLength) {
|
||||
unsigned tmp = nextCapacity + nextGrowth;
|
||||
|
||||
nextGrowth = nextCapacity;
|
||||
nextCapacity = tmp;
|
||||
}
|
||||
WMSetDataCapacity(aData, nextCapacity);
|
||||
aData->growth = nextGrowth;
|
||||
}
|
||||
memcpy((unsigned char *)aData->bytes + oldLength, bytes, length);
|
||||
aData->length = newLength;
|
||||
}
|
||||
|
||||
void WMAppendData(WMData * aData, WMData * anotherData)
|
||||
{
|
||||
if (anotherData->length > 0)
|
||||
WMAppendDataBytes(aData, anotherData->bytes, anotherData->length);
|
||||
}
|
||||
|
||||
/* Modifying data */
|
||||
|
||||
void WMReplaceDataBytesInRange(WMData * aData, WMRange aRange, const void *bytes)
|
||||
{
|
||||
wassertr(aRange.position < aData->length);
|
||||
wassertr(aRange.count <= aData->length - aRange.position);
|
||||
|
||||
memcpy((unsigned char *)aData->bytes + aRange.position, bytes, aRange.count);
|
||||
}
|
||||
|
||||
void WMResetDataBytesInRange(WMData * aData, WMRange aRange)
|
||||
{
|
||||
wassertr(aRange.position < aData->length);
|
||||
wassertr(aRange.count <= aData->length - aRange.position);
|
||||
|
||||
memset((unsigned char *)aData->bytes + aRange.position, 0, aRange.count);
|
||||
}
|
||||
|
||||
void WMSetData(WMData * aData, WMData * anotherData)
|
||||
{
|
||||
unsigned length = anotherData->length;
|
||||
|
||||
WMSetDataCapacity(aData, length);
|
||||
if (length > 0)
|
||||
memcpy(aData->bytes, anotherData->bytes, length);
|
||||
aData->length = length;
|
||||
}
|
||||
|
||||
/* Storing data */
|
||||
+1
-1
@@ -498,7 +498,7 @@ static void registerDescriptionList(WMScreen * scr, WMView * view, WMArray * ope
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
text = WMGetDragOperationItemText(WMGetFromArray(operationArray, i));
|
||||
wstrlcpy(textListItem, text, size);
|
||||
strlcpy(textListItem, text, size);
|
||||
|
||||
/* to next text offset */
|
||||
textListItem = &(textListItem[strlen(textListItem) + 1]);
|
||||
|
||||
+2
-429
@@ -34,331 +34,6 @@
|
||||
#include <pwd.h>
|
||||
#include <limits.h>
|
||||
|
||||
#ifndef PATH_MAX
|
||||
#define PATH_MAX 1024
|
||||
#endif
|
||||
|
||||
|
||||
const char *wgethomedir(void)
|
||||
{
|
||||
static char *home = NULL;
|
||||
char *tmp;
|
||||
struct passwd *user;
|
||||
|
||||
if (home)
|
||||
return home;
|
||||
|
||||
tmp = GETENV("HOME");
|
||||
if (tmp) {
|
||||
home = wstrdup(tmp);
|
||||
return home;
|
||||
}
|
||||
|
||||
user = getpwuid(getuid());
|
||||
if (!user) {
|
||||
werror(_("could not get password entry for UID %i"), getuid());
|
||||
home = "/";
|
||||
return home;
|
||||
}
|
||||
|
||||
if (!user->pw_dir)
|
||||
home = "/";
|
||||
else
|
||||
home = wstrdup(user->pw_dir);
|
||||
|
||||
return home;
|
||||
}
|
||||
|
||||
/*
|
||||
* Return the home directory for the specified used
|
||||
*
|
||||
* If user not found, returns NULL, otherwise always returns a path that is
|
||||
* statically stored.
|
||||
*
|
||||
* Please note you must use the path before any other call to 'getpw*' or it
|
||||
* may be erased. This is a design choice to avoid duplication considering
|
||||
* the use case for this function.
|
||||
*/
|
||||
static const char *getuserhomedir(const char *username)
|
||||
{
|
||||
static const char default_home[] = "/";
|
||||
struct passwd *user;
|
||||
|
||||
user = getpwnam(username);
|
||||
if (!user) {
|
||||
werror(_("could not get password entry for user %s"), username);
|
||||
return NULL;
|
||||
}
|
||||
if (!user->pw_dir)
|
||||
return default_home;
|
||||
else
|
||||
return user->pw_dir;
|
||||
|
||||
}
|
||||
|
||||
char *wexpandpath(const char *path)
|
||||
{
|
||||
const char *origpath = path;
|
||||
char buffer2[PATH_MAX + 2];
|
||||
char buffer[PATH_MAX + 2];
|
||||
int i;
|
||||
|
||||
memset(buffer, 0, PATH_MAX + 2);
|
||||
|
||||
if (*path == '~') {
|
||||
const char *home;
|
||||
|
||||
path++;
|
||||
if (*path == '/' || *path == 0) {
|
||||
home = wgethomedir();
|
||||
if (strlen(home) > PATH_MAX ||
|
||||
wstrlcpy(buffer, home, sizeof(buffer)) >= sizeof(buffer))
|
||||
goto error;
|
||||
} else {
|
||||
int j;
|
||||
j = 0;
|
||||
while (*path != 0 && *path != '/') {
|
||||
if (j > PATH_MAX)
|
||||
goto error;
|
||||
buffer2[j++] = *path;
|
||||
buffer2[j] = 0;
|
||||
path++;
|
||||
}
|
||||
home = getuserhomedir(buffer2);
|
||||
if (!home || wstrlcat(buffer, home, sizeof(buffer)) >= sizeof(buffer))
|
||||
goto error;
|
||||
}
|
||||
}
|
||||
|
||||
i = strlen(buffer);
|
||||
|
||||
while (*path != 0 && i <= PATH_MAX) {
|
||||
char *tmp;
|
||||
|
||||
if (*path == '$') {
|
||||
int j;
|
||||
|
||||
path++;
|
||||
/* expand $(HOME) or $HOME style environment variables */
|
||||
if (*path == '(') {
|
||||
path++;
|
||||
j = 0;
|
||||
while (*path != 0 && *path != ')') {
|
||||
if (j > PATH_MAX)
|
||||
goto error;
|
||||
buffer2[j++] = *(path++);
|
||||
}
|
||||
buffer2[j] = 0;
|
||||
if (*path == ')') {
|
||||
path++;
|
||||
tmp = getenv(buffer2);
|
||||
} else {
|
||||
tmp = NULL;
|
||||
}
|
||||
if (!tmp) {
|
||||
if ((i += strlen(buffer2) + 2) > PATH_MAX)
|
||||
goto error;
|
||||
buffer[i] = 0;
|
||||
if (wstrlcat(buffer, "$(", sizeof(buffer)) >= sizeof(buffer) ||
|
||||
wstrlcat(buffer, buffer2, sizeof(buffer)) >= sizeof(buffer))
|
||||
goto error;
|
||||
if (*(path-1)==')') {
|
||||
if (++i > PATH_MAX ||
|
||||
wstrlcat(buffer, ")", sizeof(buffer)) >= sizeof(buffer))
|
||||
goto error;
|
||||
}
|
||||
} else {
|
||||
if ((i += strlen(tmp)) > PATH_MAX ||
|
||||
wstrlcat(buffer, tmp, sizeof(buffer)) >= sizeof(buffer))
|
||||
goto error;
|
||||
}
|
||||
} else {
|
||||
j = 0;
|
||||
while (*path != 0 && *path != '/') {
|
||||
if (j > PATH_MAX)
|
||||
goto error;
|
||||
buffer2[j++] = *(path++);
|
||||
}
|
||||
buffer2[j] = 0;
|
||||
tmp = getenv(buffer2);
|
||||
if (!tmp) {
|
||||
if ((i += strlen(buffer2) + 1) > PATH_MAX ||
|
||||
wstrlcat(buffer, "$", sizeof(buffer)) >= sizeof(buffer) ||
|
||||
wstrlcat(buffer, buffer2, sizeof(buffer)) >= sizeof(buffer))
|
||||
goto error;
|
||||
} else {
|
||||
if ((i += strlen(tmp)) > PATH_MAX ||
|
||||
wstrlcat(buffer, tmp, sizeof(buffer)) >= sizeof(buffer))
|
||||
goto error;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
buffer[i++] = *path;
|
||||
path++;
|
||||
}
|
||||
}
|
||||
|
||||
if (*path!=0)
|
||||
goto error;
|
||||
|
||||
return wstrdup(buffer);
|
||||
|
||||
error:
|
||||
errno = ENAMETOOLONG;
|
||||
werror(_("could not expand %s"), origpath);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* return address of next char != tok or end of string whichever comes first */
|
||||
static const char *skipchar(const char *string, char tok)
|
||||
{
|
||||
while (*string != 0 && *string == tok)
|
||||
string++;
|
||||
|
||||
return string;
|
||||
}
|
||||
|
||||
/* return address of next char == tok or end of string whichever comes first */
|
||||
static const char *nextchar(const char *string, char tok)
|
||||
{
|
||||
while (*string != 0 && *string != tok)
|
||||
string++;
|
||||
|
||||
return string;
|
||||
}
|
||||
|
||||
/*
|
||||
*----------------------------------------------------------------------
|
||||
* findfile--
|
||||
* Finds a file in a : separated list of paths. ~ expansion is also
|
||||
* done.
|
||||
*
|
||||
* Returns:
|
||||
* The complete path for the file (in a newly allocated string) or
|
||||
* NULL if the file was not found.
|
||||
*
|
||||
* Side effects:
|
||||
* A new string is allocated. It must be freed later.
|
||||
*
|
||||
*----------------------------------------------------------------------
|
||||
*/
|
||||
char *wfindfile(const char *paths, const char *file)
|
||||
{
|
||||
char *path;
|
||||
const char *tmp, *tmp2;
|
||||
int len, flen;
|
||||
char *fullpath;
|
||||
|
||||
if (!file)
|
||||
return NULL;
|
||||
|
||||
if (*file == '/' || *file == '~' || *file == '$' || !paths || *paths == 0) {
|
||||
if (access(file, F_OK) < 0) {
|
||||
fullpath = wexpandpath(file);
|
||||
if (!fullpath)
|
||||
return NULL;
|
||||
|
||||
if (access(fullpath, F_OK) < 0) {
|
||||
wfree(fullpath);
|
||||
return NULL;
|
||||
} else {
|
||||
return fullpath;
|
||||
}
|
||||
} else {
|
||||
return wstrdup(file);
|
||||
}
|
||||
}
|
||||
|
||||
flen = strlen(file);
|
||||
tmp = paths;
|
||||
while (*tmp) {
|
||||
tmp = skipchar(tmp, ':');
|
||||
if (*tmp == 0)
|
||||
break;
|
||||
tmp2 = nextchar(tmp, ':');
|
||||
len = tmp2 - tmp;
|
||||
path = wmalloc(len + flen + 2);
|
||||
path = memcpy(path, tmp, len);
|
||||
path[len] = 0;
|
||||
if (path[len - 1] != '/' &&
|
||||
wstrlcat(path, "/", len + flen + 2) >= len + flen + 2) {
|
||||
wfree(path);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (wstrlcat(path, file, len + flen + 2) >= len + flen + 2) {
|
||||
wfree(path);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
fullpath = wexpandpath(path);
|
||||
wfree(path);
|
||||
|
||||
if (fullpath) {
|
||||
if (access(fullpath, F_OK) == 0) {
|
||||
return fullpath;
|
||||
}
|
||||
wfree(fullpath);
|
||||
}
|
||||
tmp = tmp2;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
char *wfindfileinlist(char *const *path_list, const char *file)
|
||||
{
|
||||
int i;
|
||||
char *path;
|
||||
int len, flen;
|
||||
char *fullpath;
|
||||
|
||||
if (!file)
|
||||
return NULL;
|
||||
|
||||
if (*file == '/' || *file == '~' || !path_list) {
|
||||
if (access(file, F_OK) < 0) {
|
||||
fullpath = wexpandpath(file);
|
||||
if (!fullpath)
|
||||
return NULL;
|
||||
|
||||
if (access(fullpath, F_OK) < 0) {
|
||||
wfree(fullpath);
|
||||
return NULL;
|
||||
} else {
|
||||
return fullpath;
|
||||
}
|
||||
} else {
|
||||
return wstrdup(file);
|
||||
}
|
||||
}
|
||||
|
||||
flen = strlen(file);
|
||||
for (i = 0; path_list[i] != NULL; i++) {
|
||||
len = strlen(path_list[i]);
|
||||
path = wmalloc(len + flen + 2);
|
||||
path = memcpy(path, path_list[i], len);
|
||||
path[len] = 0;
|
||||
if (wstrlcat(path, "/", len + flen + 2) >= len + flen + 2 ||
|
||||
wstrlcat(path, file, len + flen + 2) >= len + flen + 2) {
|
||||
wfree(path);
|
||||
return NULL;
|
||||
}
|
||||
/* expand tilde */
|
||||
fullpath = wexpandpath(path);
|
||||
wfree(path);
|
||||
if (fullpath) {
|
||||
/* check if file exists */
|
||||
if (access(fullpath, F_OK) == 0) {
|
||||
return fullpath;
|
||||
}
|
||||
wfree(fullpath);
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
char *wfindfileinarray(WMPropList *array, const char *file)
|
||||
{
|
||||
@@ -401,8 +76,8 @@ char *wfindfileinarray(WMPropList *array, const char *file)
|
||||
path = wmalloc(len + flen + 2);
|
||||
path = memcpy(path, p, len);
|
||||
path[len] = 0;
|
||||
if (wstrlcat(path, "/", len + flen + 2) >= len + flen + 2 ||
|
||||
wstrlcat(path, file, len + flen + 2) >= len + flen + 2) {
|
||||
if (strlcat(path, "/", len + flen + 2) >= len + flen + 2 ||
|
||||
strlcat(path, file, len + flen + 2) >= len + flen + 2) {
|
||||
wfree(path);
|
||||
return NULL;
|
||||
}
|
||||
@@ -419,105 +94,3 @@ char *wfindfileinarray(WMPropList *array, const char *file)
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int wcopy_file(const char *dest_dir, const char *src_file, const char *dest_file)
|
||||
{
|
||||
char *path_dst;
|
||||
int fd_src, fd_dst;
|
||||
struct stat stat_src;
|
||||
mode_t permission_dst;
|
||||
const size_t buffer_size = 2 * 1024 * 1024; /* 4MB is a decent start choice to allow the OS to take advantage of modern disk's performance */
|
||||
char *buffer; /* The buffer is not created on the stack to avoid possible stack overflow as our buffer is big */
|
||||
|
||||
try_again_src:
|
||||
fd_src = open(src_file, O_RDONLY | O_NOFOLLOW);
|
||||
if (fd_src == -1) {
|
||||
if (errno == EINTR)
|
||||
goto try_again_src;
|
||||
werror(_("Could not open input file \"%s\": %s"), src_file, strerror(errno));
|
||||
return -1;
|
||||
}
|
||||
|
||||
/* Only accept to copy regular files */
|
||||
if (fstat(fd_src, &stat_src) != 0 || !S_ISREG(stat_src.st_mode)) {
|
||||
close(fd_src);
|
||||
return -1;
|
||||
}
|
||||
|
||||
path_dst = wstrconcat(dest_dir, dest_file);
|
||||
try_again_dst:
|
||||
fd_dst = open(path_dst, O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR);
|
||||
if (fd_dst == -1) {
|
||||
if (errno == EINTR)
|
||||
goto try_again_dst;
|
||||
werror(_("Could not create target file \"%s\": %s"), path_dst, strerror(errno));
|
||||
wfree(path_dst);
|
||||
close(fd_src);
|
||||
return -1;
|
||||
}
|
||||
|
||||
buffer = malloc(buffer_size); /* Don't use wmalloc to avoid the memset(0) we don't need */
|
||||
if (buffer == NULL) {
|
||||
werror(_("could not allocate memory for the copy buffer"));
|
||||
close(fd_dst);
|
||||
goto cleanup_and_return_failure;
|
||||
}
|
||||
|
||||
for (;;) {
|
||||
ssize_t size_data;
|
||||
const char *write_ptr;
|
||||
size_t write_remain;
|
||||
|
||||
try_again_read:
|
||||
size_data = read(fd_src, buffer, buffer_size);
|
||||
if (size_data == 0)
|
||||
break; /* End of File have been reached */
|
||||
if (size_data < 0) {
|
||||
if (errno == EINTR)
|
||||
goto try_again_read;
|
||||
werror(_("could not read from file \"%s\": %s"), src_file, strerror(errno));
|
||||
close(fd_dst);
|
||||
goto cleanup_and_return_failure;
|
||||
}
|
||||
|
||||
write_ptr = buffer;
|
||||
write_remain = size_data;
|
||||
while (write_remain > 0) {
|
||||
ssize_t write_done;
|
||||
|
||||
try_again_write:
|
||||
write_done = write(fd_dst, write_ptr, write_remain);
|
||||
if (write_done < 0) {
|
||||
if (errno == EINTR)
|
||||
goto try_again_write;
|
||||
werror(_("could not write data to file \"%s\": %s"), path_dst, strerror(errno));
|
||||
close(fd_dst);
|
||||
goto cleanup_and_return_failure;
|
||||
}
|
||||
write_ptr += write_done;
|
||||
write_remain -= write_done;
|
||||
}
|
||||
}
|
||||
|
||||
/* Keep only the permission-related part of the field: */
|
||||
permission_dst = stat_src.st_mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
|
||||
if (fchmod(fd_dst, permission_dst) != 0)
|
||||
wwarning(_("could not set permission 0%03o on file \"%s\": %s"),
|
||||
permission_dst, path_dst, strerror(errno));
|
||||
|
||||
if (close(fd_dst) != 0) {
|
||||
werror(_("could not close the file \"%s\": %s"), path_dst, strerror(errno));
|
||||
cleanup_and_return_failure:
|
||||
free(buffer);
|
||||
close(fd_src);
|
||||
unlink(path_dst);
|
||||
wfree(path_dst);
|
||||
return -1;
|
||||
}
|
||||
|
||||
free(buffer);
|
||||
wfree(path_dst);
|
||||
close(fd_src);
|
||||
|
||||
return 0;
|
||||
}
|
||||
+5
-17
@@ -126,7 +126,7 @@ WMHandlerID WMAddTimerHandler(int milliseconds, WMCallback * callback, void *cda
|
||||
{
|
||||
TimerHandler *handler;
|
||||
|
||||
handler = malloc(sizeof(TimerHandler));
|
||||
handler = wmalloc(sizeof(TimerHandler));
|
||||
if (!handler)
|
||||
return NULL;
|
||||
|
||||
@@ -214,7 +214,7 @@ WMHandlerID WMAddIdleHandler(WMCallback * callback, void *cdata)
|
||||
{
|
||||
IdleHandler *handler;
|
||||
|
||||
handler = malloc(sizeof(IdleHandler));
|
||||
handler = wmalloc(sizeof(IdleHandler));
|
||||
if (!handler)
|
||||
return NULL;
|
||||
|
||||
@@ -274,12 +274,11 @@ Bool W_CheckIdleHandlers(void)
|
||||
WMArrayIterator iter;
|
||||
|
||||
if (!idleHandler || WMGetArrayItemCount(idleHandler) == 0) {
|
||||
W_FlushIdleNotificationQueue();
|
||||
/* make sure an observer in queue didn't added an idle handler */
|
||||
return (idleHandler != NULL && WMGetArrayItemCount(idleHandler) > 0);
|
||||
}
|
||||
|
||||
handlerCopy = WMDuplicateArray(idleHandler);
|
||||
handlerCopy = WMCreateArrayWithArray(idleHandler);
|
||||
|
||||
WM_ITERATE_ARRAY(handlerCopy, handler, iter) {
|
||||
/* check if the handler still exist or was removed by a callback */
|
||||
@@ -292,8 +291,6 @@ Bool W_CheckIdleHandlers(void)
|
||||
|
||||
WMFreeArray(handlerCopy);
|
||||
|
||||
W_FlushIdleNotificationQueue();
|
||||
|
||||
/* this is not necesarrily False, because one handler can re-add itself */
|
||||
return (WMGetArrayItemCount(idleHandler) > 0);
|
||||
}
|
||||
@@ -304,7 +301,6 @@ void W_CheckTimerHandlers(void)
|
||||
struct timeval now;
|
||||
|
||||
if (!timerHandler) {
|
||||
W_FlushASAPNotificationQueue();
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -331,8 +327,6 @@ void W_CheckTimerHandlers(void)
|
||||
wfree(handler);
|
||||
}
|
||||
}
|
||||
|
||||
W_FlushASAPNotificationQueue();
|
||||
}
|
||||
|
||||
/*
|
||||
@@ -384,7 +378,6 @@ Bool W_HandleInputEvents(Bool waitForInput, int inputfd)
|
||||
nfds = 0;
|
||||
|
||||
if (!extrafd && nfds == 0) {
|
||||
W_FlushASAPNotificationQueue();
|
||||
return False;
|
||||
}
|
||||
|
||||
@@ -429,7 +422,7 @@ Bool W_HandleInputEvents(Bool waitForInput, int inputfd)
|
||||
count = poll(fds, nfds + extrafd, timeout);
|
||||
|
||||
if (count > 0 && nfds > 0) {
|
||||
WMArray *handlerCopy = WMDuplicateArray(inputHandler);
|
||||
WMArray *handlerCopy = WMCreateArrayWithArray(inputHandler);
|
||||
int mask;
|
||||
|
||||
/* use WM_ITERATE_ARRAY() here */
|
||||
@@ -461,8 +454,6 @@ Bool W_HandleInputEvents(Bool waitForInput, int inputfd)
|
||||
|
||||
wfree(fds);
|
||||
|
||||
W_FlushASAPNotificationQueue();
|
||||
|
||||
return (count > 0);
|
||||
#else
|
||||
#ifdef HAVE_SELECT
|
||||
@@ -479,7 +470,6 @@ Bool W_HandleInputEvents(Bool waitForInput, int inputfd)
|
||||
nfds = 0;
|
||||
|
||||
if (inputfd < 0 && nfds == 0) {
|
||||
W_FlushASAPNotificationQueue();
|
||||
return False;
|
||||
}
|
||||
|
||||
@@ -527,7 +517,7 @@ Bool W_HandleInputEvents(Bool waitForInput, int inputfd)
|
||||
count = select(1 + maxfd, &rset, &wset, &eset, timeoutPtr);
|
||||
|
||||
if (count > 0 && nfds > 0) {
|
||||
WMArray *handlerCopy = WMDuplicateArray(inputHandler);
|
||||
WMArray *handlerCopy = WMCreateArrayWithArray(inputHandler);
|
||||
int mask;
|
||||
|
||||
/* use WM_ITERATE_ARRAY() here */
|
||||
@@ -556,8 +546,6 @@ Bool W_HandleInputEvents(Bool waitForInput, int inputfd)
|
||||
WMFreeArray(handlerCopy);
|
||||
}
|
||||
|
||||
W_FlushASAPNotificationQueue();
|
||||
|
||||
return (count > 0);
|
||||
#else /* not HAVE_SELECT, not HAVE_POLL */
|
||||
# error Neither select nor poll. You lose.
|
||||
|
||||
@@ -1,422 +0,0 @@
|
||||
#include <config.h>
|
||||
|
||||
#include <sys/types.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#include "WUtil.h"
|
||||
|
||||
#define INITIAL_CAPACITY 23
|
||||
|
||||
|
||||
typedef struct HashItem {
|
||||
const void *key;
|
||||
const void *data;
|
||||
|
||||
struct HashItem *next; /* collided item list */
|
||||
} HashItem;
|
||||
|
||||
typedef struct W_HashTable {
|
||||
WMHashTableCallbacks callbacks;
|
||||
|
||||
unsigned itemCount;
|
||||
unsigned size; /* table size */
|
||||
|
||||
HashItem **table;
|
||||
} HashTable;
|
||||
|
||||
#define HASH(table, key) (((table)->callbacks.hash ? \
|
||||
(*(table)->callbacks.hash)(key) : hashPtr(key)) % (table)->size)
|
||||
|
||||
#define DUPKEY(table, key) ((table)->callbacks.retainKey ? \
|
||||
(*(table)->callbacks.retainKey)(key) : (key))
|
||||
|
||||
#define RELKEY(table, key) if ((table)->callbacks.releaseKey) \
|
||||
(*(table)->callbacks.releaseKey)(key)
|
||||
|
||||
static inline unsigned hashString(const void *param)
|
||||
{
|
||||
const char *key = param;
|
||||
unsigned ret = 0;
|
||||
unsigned ctr = 0;
|
||||
|
||||
while (*key) {
|
||||
ret ^= *key++ << ctr;
|
||||
ctr = (ctr + 1) % sizeof(char *);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline unsigned hashPtr(const void *key)
|
||||
{
|
||||
return ((size_t) key / sizeof(char *));
|
||||
}
|
||||
|
||||
static void rellocateItem(WMHashTable * table, HashItem * item)
|
||||
{
|
||||
unsigned h;
|
||||
|
||||
h = HASH(table, item->key);
|
||||
|
||||
item->next = table->table[h];
|
||||
table->table[h] = item;
|
||||
}
|
||||
|
||||
static void rebuildTable(WMHashTable * table)
|
||||
{
|
||||
HashItem *next;
|
||||
HashItem **oldArray;
|
||||
int i;
|
||||
int oldSize;
|
||||
int newSize;
|
||||
|
||||
oldArray = table->table;
|
||||
oldSize = table->size;
|
||||
|
||||
newSize = table->size * 2;
|
||||
|
||||
table->table = wmalloc(sizeof(char *) * newSize);
|
||||
table->size = newSize;
|
||||
|
||||
for (i = 0; i < oldSize; i++) {
|
||||
while (oldArray[i] != NULL) {
|
||||
next = oldArray[i]->next;
|
||||
rellocateItem(table, oldArray[i]);
|
||||
oldArray[i] = next;
|
||||
}
|
||||
}
|
||||
wfree(oldArray);
|
||||
}
|
||||
|
||||
WMHashTable *WMCreateHashTable(const WMHashTableCallbacks callbacks)
|
||||
{
|
||||
HashTable *table;
|
||||
|
||||
table = wmalloc(sizeof(HashTable));
|
||||
|
||||
table->callbacks = callbacks;
|
||||
|
||||
table->size = INITIAL_CAPACITY;
|
||||
|
||||
table->table = wmalloc(sizeof(HashItem *) * table->size);
|
||||
|
||||
return table;
|
||||
}
|
||||
|
||||
void WMResetHashTable(WMHashTable * table)
|
||||
{
|
||||
HashItem *item, *tmp;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < table->size; i++) {
|
||||
item = table->table[i];
|
||||
while (item) {
|
||||
tmp = item->next;
|
||||
RELKEY(table, item->key);
|
||||
wfree(item);
|
||||
item = tmp;
|
||||
}
|
||||
}
|
||||
|
||||
table->itemCount = 0;
|
||||
|
||||
if (table->size > INITIAL_CAPACITY) {
|
||||
wfree(table->table);
|
||||
table->size = INITIAL_CAPACITY;
|
||||
table->table = wmalloc(sizeof(HashItem *) * table->size);
|
||||
} else {
|
||||
memset(table->table, 0, sizeof(HashItem *) * table->size);
|
||||
}
|
||||
}
|
||||
|
||||
void WMFreeHashTable(WMHashTable * table)
|
||||
{
|
||||
HashItem *item, *tmp;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < table->size; i++) {
|
||||
item = table->table[i];
|
||||
while (item) {
|
||||
tmp = item->next;
|
||||
RELKEY(table, item->key);
|
||||
wfree(item);
|
||||
item = tmp;
|
||||
}
|
||||
}
|
||||
wfree(table->table);
|
||||
wfree(table);
|
||||
}
|
||||
|
||||
unsigned WMCountHashTable(WMHashTable * table)
|
||||
{
|
||||
return table->itemCount;
|
||||
}
|
||||
|
||||
static HashItem *hashGetItem(WMHashTable *table, const void *key)
|
||||
{
|
||||
unsigned h;
|
||||
HashItem *item;
|
||||
|
||||
h = HASH(table, key);
|
||||
item = table->table[h];
|
||||
|
||||
if (table->callbacks.keyIsEqual) {
|
||||
while (item) {
|
||||
if ((*table->callbacks.keyIsEqual) (key, item->key)) {
|
||||
break;
|
||||
}
|
||||
item = item->next;
|
||||
}
|
||||
} else {
|
||||
while (item) {
|
||||
if (key == item->key) {
|
||||
break;
|
||||
}
|
||||
item = item->next;
|
||||
}
|
||||
}
|
||||
return item;
|
||||
}
|
||||
|
||||
void *WMHashGet(WMHashTable * table, const void *key)
|
||||
{
|
||||
HashItem *item;
|
||||
|
||||
item = hashGetItem(table, key);
|
||||
if (!item)
|
||||
return NULL;
|
||||
return (void *)item->data;
|
||||
}
|
||||
|
||||
Bool WMHashGetItemAndKey(WMHashTable * table, const void *key, void **retItem, void **retKey)
|
||||
{
|
||||
HashItem *item;
|
||||
|
||||
item = hashGetItem(table, key);
|
||||
if (!item)
|
||||
return False;
|
||||
|
||||
if (retKey)
|
||||
*retKey = (void *)item->key;
|
||||
if (retItem)
|
||||
*retItem = (void *)item->data;
|
||||
return True;
|
||||
}
|
||||
|
||||
void *WMHashInsert(WMHashTable * table, const void *key, const void *data)
|
||||
{
|
||||
unsigned h;
|
||||
HashItem *item;
|
||||
int replacing = 0;
|
||||
|
||||
h = HASH(table, key);
|
||||
/* look for the entry */
|
||||
item = table->table[h];
|
||||
if (table->callbacks.keyIsEqual) {
|
||||
while (item) {
|
||||
if ((*table->callbacks.keyIsEqual) (key, item->key)) {
|
||||
replacing = 1;
|
||||
break;
|
||||
}
|
||||
item = item->next;
|
||||
}
|
||||
} else {
|
||||
while (item) {
|
||||
if (key == item->key) {
|
||||
replacing = 1;
|
||||
break;
|
||||
}
|
||||
item = item->next;
|
||||
}
|
||||
}
|
||||
|
||||
if (replacing) {
|
||||
const void *old;
|
||||
|
||||
old = item->data;
|
||||
item->data = data;
|
||||
RELKEY(table, item->key);
|
||||
item->key = DUPKEY(table, key);
|
||||
|
||||
return (void *)old;
|
||||
} else {
|
||||
HashItem *nitem;
|
||||
|
||||
nitem = wmalloc(sizeof(HashItem));
|
||||
nitem->key = DUPKEY(table, key);
|
||||
nitem->data = data;
|
||||
nitem->next = table->table[h];
|
||||
table->table[h] = nitem;
|
||||
|
||||
table->itemCount++;
|
||||
}
|
||||
|
||||
/* OPTIMIZE: put this in an idle handler. */
|
||||
if (table->itemCount > table->size) {
|
||||
#ifdef DEBUG0
|
||||
printf("rebuilding hash table...\n");
|
||||
#endif
|
||||
rebuildTable(table);
|
||||
#ifdef DEBUG0
|
||||
printf("finished rebuild.\n");
|
||||
#endif
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static HashItem *deleteFromList(HashTable * table, HashItem * item, const void *key)
|
||||
{
|
||||
HashItem *next;
|
||||
|
||||
if (item == NULL)
|
||||
return NULL;
|
||||
|
||||
if ((table->callbacks.keyIsEqual && (*table->callbacks.keyIsEqual) (key, item->key))
|
||||
|| (!table->callbacks.keyIsEqual && key == item->key)) {
|
||||
|
||||
next = item->next;
|
||||
RELKEY(table, item->key);
|
||||
wfree(item);
|
||||
|
||||
table->itemCount--;
|
||||
|
||||
return next;
|
||||
}
|
||||
|
||||
item->next = deleteFromList(table, item->next, key);
|
||||
|
||||
return item;
|
||||
}
|
||||
|
||||
void WMHashRemove(WMHashTable * table, const void *key)
|
||||
{
|
||||
unsigned h;
|
||||
|
||||
h = HASH(table, key);
|
||||
|
||||
table->table[h] = deleteFromList(table, table->table[h], key);
|
||||
}
|
||||
|
||||
WMHashEnumerator WMEnumerateHashTable(WMHashTable * table)
|
||||
{
|
||||
WMHashEnumerator enumerator;
|
||||
|
||||
enumerator.table = table;
|
||||
enumerator.index = 0;
|
||||
enumerator.nextItem = table->table[0];
|
||||
|
||||
return enumerator;
|
||||
}
|
||||
|
||||
void *WMNextHashEnumeratorItem(WMHashEnumerator * enumerator)
|
||||
{
|
||||
const void *data = NULL;
|
||||
|
||||
/* this assumes the table doesn't change between
|
||||
* WMEnumerateHashTable() and WMNextHashEnumeratorItem() calls */
|
||||
|
||||
if (enumerator->nextItem == NULL) {
|
||||
HashTable *table = enumerator->table;
|
||||
while (++enumerator->index < table->size) {
|
||||
if (table->table[enumerator->index] != NULL) {
|
||||
enumerator->nextItem = table->table[enumerator->index];
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (enumerator->nextItem) {
|
||||
data = ((HashItem *) enumerator->nextItem)->data;
|
||||
enumerator->nextItem = ((HashItem *) enumerator->nextItem)->next;
|
||||
}
|
||||
|
||||
return (void *)data;
|
||||
}
|
||||
|
||||
void *WMNextHashEnumeratorKey(WMHashEnumerator * enumerator)
|
||||
{
|
||||
const void *key = NULL;
|
||||
|
||||
/* this assumes the table doesn't change between
|
||||
* WMEnumerateHashTable() and WMNextHashEnumeratorKey() calls */
|
||||
|
||||
if (enumerator->nextItem == NULL) {
|
||||
HashTable *table = enumerator->table;
|
||||
while (++enumerator->index < table->size) {
|
||||
if (table->table[enumerator->index] != NULL) {
|
||||
enumerator->nextItem = table->table[enumerator->index];
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (enumerator->nextItem) {
|
||||
key = ((HashItem *) enumerator->nextItem)->key;
|
||||
enumerator->nextItem = ((HashItem *) enumerator->nextItem)->next;
|
||||
}
|
||||
|
||||
return (void *)key;
|
||||
}
|
||||
|
||||
Bool WMNextHashEnumeratorItemAndKey(WMHashEnumerator * enumerator, void **item, void **key)
|
||||
{
|
||||
/* this assumes the table doesn't change between
|
||||
* WMEnumerateHashTable() and WMNextHashEnumeratorItemAndKey() calls */
|
||||
|
||||
if (enumerator->nextItem == NULL) {
|
||||
HashTable *table = enumerator->table;
|
||||
while (++enumerator->index < table->size) {
|
||||
if (table->table[enumerator->index] != NULL) {
|
||||
enumerator->nextItem = table->table[enumerator->index];
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (enumerator->nextItem) {
|
||||
if (item)
|
||||
*item = (void *)((HashItem *) enumerator->nextItem)->data;
|
||||
if (key)
|
||||
*key = (void *)((HashItem *) enumerator->nextItem)->key;
|
||||
enumerator->nextItem = ((HashItem *) enumerator->nextItem)->next;
|
||||
|
||||
return True;
|
||||
}
|
||||
|
||||
return False;
|
||||
}
|
||||
|
||||
static Bool compareStrings(const void *param1, const void *param2)
|
||||
{
|
||||
const char *key1 = param1;
|
||||
const char *key2 = param2;
|
||||
|
||||
return strcmp(key1, key2) == 0;
|
||||
}
|
||||
|
||||
typedef void *(*retainFunc) (const void *);
|
||||
typedef void (*releaseFunc) (const void *);
|
||||
|
||||
const WMHashTableCallbacks WMIntHashCallbacks = {
|
||||
NULL,
|
||||
NULL,
|
||||
NULL,
|
||||
NULL
|
||||
};
|
||||
|
||||
const WMHashTableCallbacks WMStringHashCallbacks = {
|
||||
hashString,
|
||||
compareStrings,
|
||||
(retainFunc) wstrdup,
|
||||
(releaseFunc) wfree
|
||||
};
|
||||
|
||||
const WMHashTableCallbacks WMStringPointerHashCallbacks = {
|
||||
hashString,
|
||||
compareStrings,
|
||||
NULL,
|
||||
NULL
|
||||
};
|
||||
-223
@@ -1,223 +0,0 @@
|
||||
/*
|
||||
* Window Maker miscelaneous function library
|
||||
*
|
||||
* Copyright (c) 1997-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., 51 Franklin St, Fifth Floor, Boston,
|
||||
* MA 02110-1301, USA.
|
||||
*/
|
||||
|
||||
#include "wconfig.h"
|
||||
#include "WUtil.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <sys/types.h>
|
||||
#include <unistd.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <assert.h>
|
||||
#include <signal.h>
|
||||
|
||||
#ifdef HAVE_STDNORETURN
|
||||
#include <stdnoreturn.h>
|
||||
#endif
|
||||
|
||||
#ifdef USE_BOEHM_GC
|
||||
#ifndef GC_DEBUG
|
||||
#define GC_DEBUG
|
||||
#endif /* !GC_DEBUG */
|
||||
#include <gc/gc.h>
|
||||
#endif /* USE_BOEHM_GC */
|
||||
|
||||
#ifndef False
|
||||
# define False 0
|
||||
#endif
|
||||
#ifndef True
|
||||
# define True 1
|
||||
#endif
|
||||
|
||||
static void defaultHandler(int bla)
|
||||
{
|
||||
if (bla)
|
||||
kill(getpid(), SIGABRT);
|
||||
else
|
||||
exit(1);
|
||||
}
|
||||
|
||||
static waborthandler *aborthandler = defaultHandler;
|
||||
|
||||
static inline noreturn void wAbort(int bla)
|
||||
{
|
||||
(*aborthandler)(bla);
|
||||
exit(-1);
|
||||
}
|
||||
|
||||
waborthandler *wsetabort(waborthandler * handler)
|
||||
{
|
||||
waborthandler *old = aborthandler;
|
||||
|
||||
aborthandler = handler;
|
||||
|
||||
return old;
|
||||
}
|
||||
|
||||
static int Aborting = 0; /* if we're in the middle of an emergency exit */
|
||||
|
||||
static WMHashTable *table = NULL;
|
||||
|
||||
void *wmalloc(size_t size)
|
||||
{
|
||||
void *tmp;
|
||||
|
||||
assert(size > 0);
|
||||
|
||||
#ifdef USE_BOEHM_GC
|
||||
tmp = GC_MALLOC(size);
|
||||
#else
|
||||
tmp = malloc(size);
|
||||
#endif
|
||||
if (tmp == NULL) {
|
||||
wwarning("malloc() failed. Retrying after 2s.");
|
||||
sleep(2);
|
||||
#ifdef USE_BOEHM_GC
|
||||
tmp = GC_MALLOC(size);
|
||||
#else
|
||||
tmp = malloc(size);
|
||||
#endif
|
||||
if (tmp == NULL) {
|
||||
if (Aborting) {
|
||||
fputs("Really Bad Error: recursive malloc() failure.", stderr);
|
||||
exit(-1);
|
||||
} else {
|
||||
wfatal("virtual memory exhausted");
|
||||
Aborting = 1;
|
||||
wAbort(False);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (tmp != NULL)
|
||||
memset(tmp, 0, size);
|
||||
return tmp;
|
||||
}
|
||||
|
||||
void *wrealloc(void *ptr, size_t newsize)
|
||||
{
|
||||
void *nptr;
|
||||
|
||||
if (!ptr) {
|
||||
nptr = wmalloc(newsize);
|
||||
} else if (newsize == 0) {
|
||||
wfree(ptr);
|
||||
nptr = NULL;
|
||||
} else {
|
||||
#ifdef USE_BOEHM_GC
|
||||
nptr = GC_REALLOC(ptr, newsize);
|
||||
#else
|
||||
nptr = realloc(ptr, newsize);
|
||||
#endif
|
||||
if (nptr == NULL) {
|
||||
wwarning("realloc() failed. Retrying after 2s.");
|
||||
sleep(2);
|
||||
#ifdef USE_BOEHM_GC
|
||||
nptr = GC_REALLOC(ptr, newsize);
|
||||
#else
|
||||
nptr = realloc(ptr, newsize);
|
||||
#endif
|
||||
if (nptr == NULL) {
|
||||
if (Aborting) {
|
||||
fputs("Really Bad Error: recursive realloc() failure.", stderr);
|
||||
exit(-1);
|
||||
} else {
|
||||
wfatal("virtual memory exhausted");
|
||||
Aborting = 1;
|
||||
wAbort(False);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return nptr;
|
||||
}
|
||||
|
||||
void *wretain(void *ptr)
|
||||
{
|
||||
int *refcount;
|
||||
|
||||
if (!table) {
|
||||
table = WMCreateHashTable(WMIntHashCallbacks);
|
||||
}
|
||||
|
||||
refcount = WMHashGet(table, ptr);
|
||||
if (!refcount) {
|
||||
refcount = wmalloc(sizeof(int));
|
||||
*refcount = 1;
|
||||
WMHashInsert(table, ptr, refcount);
|
||||
#ifdef VERBOSE
|
||||
printf("== %i (%p)\n", *refcount, ptr);
|
||||
#endif
|
||||
} else {
|
||||
(*refcount)++;
|
||||
#ifdef VERBOSE
|
||||
printf("+ %i (%p)\n", *refcount, ptr);
|
||||
#endif
|
||||
}
|
||||
|
||||
return ptr;
|
||||
}
|
||||
|
||||
void wfree(void *ptr)
|
||||
{
|
||||
if (ptr)
|
||||
#ifdef USE_BOEHM_GC
|
||||
/* This should eventually be removed, once the criss-cross
|
||||
* of wmalloc()d memory being free()d, malloc()d memory being
|
||||
* wfree()d, various misuses of calling wfree() on objects
|
||||
* allocated by libc malloc() and calling libc free() on
|
||||
* objects allocated by Boehm GC (think external libraries)
|
||||
* is cleaned up.
|
||||
*/
|
||||
if (GC_base(ptr) != 0)
|
||||
GC_FREE(ptr);
|
||||
else
|
||||
free(ptr);
|
||||
#else
|
||||
free(ptr);
|
||||
#endif
|
||||
ptr = NULL;
|
||||
}
|
||||
|
||||
void wrelease(void *ptr)
|
||||
{
|
||||
int *refcount;
|
||||
|
||||
refcount = WMHashGet(table, ptr);
|
||||
if (!refcount) {
|
||||
wwarning("trying to release unexisting data %p", ptr);
|
||||
} else {
|
||||
(*refcount)--;
|
||||
if (*refcount < 1) {
|
||||
#ifdef VERBOSE
|
||||
printf("RELEASING %p\n", ptr);
|
||||
#endif
|
||||
WMHashRemove(table, ptr);
|
||||
wfree(refcount);
|
||||
wfree(ptr);
|
||||
}
|
||||
#ifdef VERBOSE
|
||||
else {
|
||||
printf("- %i (%p)\n", *refcount, ptr);
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
+3
-1
@@ -536,12 +536,14 @@ found_end_define_fname:
|
||||
while (*src != '\0') {
|
||||
idx = 0;
|
||||
if (*src == '~') {
|
||||
const char *home = wgethomedir();
|
||||
char *home_head = wgethomedir();
|
||||
char *home = home_head;;
|
||||
while (*home != '\0') {
|
||||
if (idx < sizeof(buffer) - 2)
|
||||
buffer[idx++] = *home;
|
||||
home++;
|
||||
}
|
||||
wfree(home_head);
|
||||
src++;
|
||||
}
|
||||
|
||||
|
||||
@@ -652,7 +652,7 @@ static void mpm_get_hostname(WParserMacro *this, WMenuParser parser)
|
||||
return;
|
||||
}
|
||||
}
|
||||
wstrlcpy((char *) this->value, h, sizeof(this->value) );
|
||||
strlcpy((char *) this->value, h, sizeof(this->value) );
|
||||
}
|
||||
|
||||
/* Name of the current user */
|
||||
@@ -677,7 +677,7 @@ static void mpm_get_user_name(WParserMacro *this, WMenuParser parser)
|
||||
user = pw_user->pw_name;
|
||||
if (user == NULL) goto error_no_username;
|
||||
}
|
||||
wstrlcpy((char *) this->value, user, sizeof(this->value) );
|
||||
strlcpy((char *) this->value, user, sizeof(this->value) );
|
||||
}
|
||||
|
||||
/* Number id of the user under which we are running */
|
||||
|
||||
@@ -1,482 +0,0 @@
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "WUtil.h"
|
||||
#include "WINGsP.h"
|
||||
|
||||
|
||||
typedef struct W_Notification {
|
||||
const char *name;
|
||||
void *object;
|
||||
void *clientData;
|
||||
int refCount;
|
||||
} Notification;
|
||||
|
||||
|
||||
const char *WMGetNotificationName(WMNotification * notification)
|
||||
{
|
||||
return notification->name;
|
||||
}
|
||||
|
||||
void *WMGetNotificationObject(WMNotification * notification)
|
||||
{
|
||||
return notification->object;
|
||||
}
|
||||
|
||||
void *WMGetNotificationClientData(WMNotification * notification)
|
||||
{
|
||||
return notification->clientData;
|
||||
}
|
||||
|
||||
WMNotification *WMCreateNotification(const char *name, void *object, void *clientData)
|
||||
{
|
||||
Notification *nPtr;
|
||||
|
||||
nPtr = wmalloc(sizeof(Notification));
|
||||
nPtr->name = name;
|
||||
nPtr->object = object;
|
||||
nPtr->clientData = clientData;
|
||||
nPtr->refCount = 1;
|
||||
|
||||
return nPtr;
|
||||
}
|
||||
|
||||
void WMReleaseNotification(WMNotification * notification)
|
||||
{
|
||||
notification->refCount--;
|
||||
|
||||
if (notification->refCount < 1) {
|
||||
wfree(notification);
|
||||
}
|
||||
}
|
||||
|
||||
WMNotification *WMRetainNotification(WMNotification * notification)
|
||||
{
|
||||
notification->refCount++;
|
||||
|
||||
return notification;
|
||||
}
|
||||
|
||||
/***************** Notification Center *****************/
|
||||
|
||||
typedef struct NotificationObserver {
|
||||
WMNotificationObserverAction *observerAction;
|
||||
void *observer;
|
||||
|
||||
const char *name;
|
||||
void *object;
|
||||
|
||||
struct NotificationObserver *prev; /* for tables */
|
||||
struct NotificationObserver *next;
|
||||
struct NotificationObserver *nextAction; /* for observerTable */
|
||||
} NotificationObserver;
|
||||
|
||||
typedef struct W_NotificationCenter {
|
||||
WMHashTable *nameTable; /* names -> observer lists */
|
||||
WMHashTable *objectTable; /* object -> observer lists */
|
||||
NotificationObserver *nilList; /* obervers that catch everything */
|
||||
|
||||
WMHashTable *observerTable; /* observer -> NotificationObserver */
|
||||
} NotificationCenter;
|
||||
|
||||
/* default (and only) center */
|
||||
static NotificationCenter *notificationCenter = NULL;
|
||||
|
||||
void W_InitNotificationCenter(void)
|
||||
{
|
||||
notificationCenter = wmalloc(sizeof(NotificationCenter));
|
||||
notificationCenter->nameTable = WMCreateHashTable(WMStringPointerHashCallbacks);
|
||||
notificationCenter->objectTable = WMCreateHashTable(WMIntHashCallbacks);
|
||||
notificationCenter->nilList = NULL;
|
||||
notificationCenter->observerTable = WMCreateHashTable(WMIntHashCallbacks);
|
||||
}
|
||||
|
||||
void W_ReleaseNotificationCenter(void)
|
||||
{
|
||||
if (notificationCenter) {
|
||||
if (notificationCenter->nameTable)
|
||||
WMFreeHashTable(notificationCenter->nameTable);
|
||||
if (notificationCenter->objectTable)
|
||||
WMFreeHashTable(notificationCenter->objectTable);
|
||||
if (notificationCenter->observerTable)
|
||||
WMFreeHashTable(notificationCenter->observerTable);
|
||||
|
||||
wfree(notificationCenter);
|
||||
notificationCenter = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
WMAddNotificationObserver(WMNotificationObserverAction * observerAction,
|
||||
void *observer, const char *name, void *object)
|
||||
{
|
||||
NotificationObserver *oRec, *rec;
|
||||
|
||||
oRec = wmalloc(sizeof(NotificationObserver));
|
||||
oRec->observerAction = observerAction;
|
||||
oRec->observer = observer;
|
||||
oRec->name = name;
|
||||
oRec->object = object;
|
||||
oRec->next = NULL;
|
||||
oRec->prev = NULL;
|
||||
|
||||
/* put this action in the list of actions for this observer */
|
||||
rec = (NotificationObserver *) WMHashInsert(notificationCenter->observerTable, observer, oRec);
|
||||
|
||||
if (rec) {
|
||||
/* if this is not the first action for the observer */
|
||||
oRec->nextAction = rec;
|
||||
} else {
|
||||
oRec->nextAction = NULL;
|
||||
}
|
||||
|
||||
if (!name && !object) {
|
||||
/* catch-all */
|
||||
oRec->next = notificationCenter->nilList;
|
||||
if (notificationCenter->nilList) {
|
||||
notificationCenter->nilList->prev = oRec;
|
||||
}
|
||||
notificationCenter->nilList = oRec;
|
||||
} else if (!name) {
|
||||
/* any message coming from object */
|
||||
rec = (NotificationObserver *) WMHashInsert(notificationCenter->objectTable, object, oRec);
|
||||
oRec->next = rec;
|
||||
if (rec) {
|
||||
rec->prev = oRec;
|
||||
}
|
||||
} else {
|
||||
/* name && (object || !object) */
|
||||
rec = (NotificationObserver *) WMHashInsert(notificationCenter->nameTable, name, oRec);
|
||||
oRec->next = rec;
|
||||
if (rec) {
|
||||
rec->prev = oRec;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void WMPostNotification(WMNotification * notification)
|
||||
{
|
||||
NotificationObserver *orec, *tmp;
|
||||
|
||||
WMRetainNotification(notification);
|
||||
|
||||
/* tell the observers that want to know about a particular message */
|
||||
orec = (NotificationObserver *) WMHashGet(notificationCenter->nameTable, notification->name);
|
||||
|
||||
while (orec) {
|
||||
tmp = orec->next;
|
||||
|
||||
if (!orec->object || !notification->object || orec->object == notification->object) {
|
||||
/* tell the observer */
|
||||
if (orec->observerAction) {
|
||||
(*orec->observerAction) (orec->observer, notification);
|
||||
}
|
||||
}
|
||||
|
||||
orec = tmp;
|
||||
}
|
||||
|
||||
/* tell the observers that want to know about an object */
|
||||
orec = (NotificationObserver *) WMHashGet(notificationCenter->objectTable, notification->object);
|
||||
|
||||
while (orec) {
|
||||
tmp = orec->next;
|
||||
|
||||
/* tell the observer */
|
||||
if (orec->observerAction) {
|
||||
(*orec->observerAction) (orec->observer, notification);
|
||||
}
|
||||
orec = tmp;
|
||||
}
|
||||
|
||||
/* tell the catch all observers */
|
||||
orec = notificationCenter->nilList;
|
||||
while (orec) {
|
||||
tmp = orec->next;
|
||||
|
||||
/* tell the observer */
|
||||
if (orec->observerAction) {
|
||||
(*orec->observerAction) (orec->observer, notification);
|
||||
}
|
||||
orec = tmp;
|
||||
}
|
||||
|
||||
WMReleaseNotification(notification);
|
||||
}
|
||||
|
||||
void WMRemoveNotificationObserver(void *observer)
|
||||
{
|
||||
NotificationObserver *orec, *tmp, *rec;
|
||||
|
||||
/* get the list of actions the observer is doing */
|
||||
orec = (NotificationObserver *) WMHashGet(notificationCenter->observerTable, observer);
|
||||
|
||||
/*
|
||||
* FOREACH orec IN actionlist for observer
|
||||
* DO
|
||||
* remove from respective lists/tables
|
||||
* free
|
||||
* END
|
||||
*/
|
||||
while (orec) {
|
||||
tmp = orec->nextAction;
|
||||
|
||||
if (!orec->name && !orec->object) {
|
||||
/* catch-all */
|
||||
if (notificationCenter->nilList == orec)
|
||||
notificationCenter->nilList = orec->next;
|
||||
} else if (!orec->name) {
|
||||
/* any message coming from object */
|
||||
rec = (NotificationObserver *) WMHashGet(notificationCenter->objectTable, orec->object);
|
||||
if (rec == orec) {
|
||||
/* replace table entry */
|
||||
if (orec->next) {
|
||||
WMHashInsert(notificationCenter->objectTable, orec->object, orec->next);
|
||||
} else {
|
||||
WMHashRemove(notificationCenter->objectTable, orec->object);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
/* name && (object || !object) */
|
||||
rec = (NotificationObserver *) WMHashGet(notificationCenter->nameTable, orec->name);
|
||||
if (rec == orec) {
|
||||
/* replace table entry */
|
||||
if (orec->next) {
|
||||
WMHashInsert(notificationCenter->nameTable, orec->name, orec->next);
|
||||
} else {
|
||||
WMHashRemove(notificationCenter->nameTable, orec->name);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (orec->prev)
|
||||
orec->prev->next = orec->next;
|
||||
if (orec->next)
|
||||
orec->next->prev = orec->prev;
|
||||
|
||||
wfree(orec);
|
||||
|
||||
orec = tmp;
|
||||
}
|
||||
|
||||
WMHashRemove(notificationCenter->observerTable, observer);
|
||||
}
|
||||
|
||||
void WMRemoveNotificationObserverWithName(void *observer, const char *name, void *object)
|
||||
{
|
||||
NotificationObserver *orec, *tmp, *rec;
|
||||
NotificationObserver *newList = NULL;
|
||||
|
||||
/* get the list of actions the observer is doing */
|
||||
orec = (NotificationObserver *) WMHashGet(notificationCenter->observerTable, observer);
|
||||
|
||||
WMHashRemove(notificationCenter->observerTable, observer);
|
||||
|
||||
/* rebuild the list of actions for the observer */
|
||||
|
||||
while (orec) {
|
||||
tmp = orec->nextAction;
|
||||
if (orec->name == name && orec->object == object) {
|
||||
if (!name && !object) {
|
||||
if (notificationCenter->nilList == orec)
|
||||
notificationCenter->nilList = orec->next;
|
||||
} else if (!name) {
|
||||
rec =
|
||||
(NotificationObserver *) WMHashGet(notificationCenter->objectTable,
|
||||
orec->object);
|
||||
if (rec == orec) {
|
||||
assert(rec->prev == NULL);
|
||||
/* replace table entry */
|
||||
if (orec->next) {
|
||||
WMHashInsert(notificationCenter->objectTable,
|
||||
orec->object, orec->next);
|
||||
} else {
|
||||
WMHashRemove(notificationCenter->objectTable, orec->object);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
rec = (NotificationObserver *) WMHashGet(notificationCenter->nameTable,
|
||||
orec->name);
|
||||
if (rec == orec) {
|
||||
assert(rec->prev == NULL);
|
||||
/* replace table entry */
|
||||
if (orec->next) {
|
||||
WMHashInsert(notificationCenter->nameTable,
|
||||
orec->name, orec->next);
|
||||
} else {
|
||||
WMHashRemove(notificationCenter->nameTable, orec->name);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (orec->prev)
|
||||
orec->prev->next = orec->next;
|
||||
if (orec->next)
|
||||
orec->next->prev = orec->prev;
|
||||
wfree(orec);
|
||||
} else {
|
||||
/* append this action in the new action list */
|
||||
orec->nextAction = NULL;
|
||||
if (!newList) {
|
||||
newList = orec;
|
||||
} else {
|
||||
NotificationObserver *p;
|
||||
|
||||
p = newList;
|
||||
while (p->nextAction) {
|
||||
p = p->nextAction;
|
||||
}
|
||||
p->nextAction = orec;
|
||||
}
|
||||
}
|
||||
orec = tmp;
|
||||
}
|
||||
|
||||
/* reinsert the list to the table */
|
||||
if (newList) {
|
||||
WMHashInsert(notificationCenter->observerTable, observer, newList);
|
||||
}
|
||||
}
|
||||
|
||||
void WMPostNotificationName(const char *name, void *object, void *clientData)
|
||||
{
|
||||
WMNotification *notification;
|
||||
|
||||
notification = WMCreateNotification(name, object, clientData);
|
||||
|
||||
WMPostNotification(notification);
|
||||
|
||||
WMReleaseNotification(notification);
|
||||
}
|
||||
|
||||
/**************** Notification Queues ****************/
|
||||
|
||||
typedef struct W_NotificationQueue {
|
||||
WMArray *asapQueue;
|
||||
WMArray *idleQueue;
|
||||
|
||||
struct W_NotificationQueue *next;
|
||||
} NotificationQueue;
|
||||
|
||||
static WMNotificationQueue *notificationQueueList = NULL;
|
||||
|
||||
/* default queue */
|
||||
static WMNotificationQueue *notificationQueue = NULL;
|
||||
|
||||
WMNotificationQueue *WMGetDefaultNotificationQueue(void)
|
||||
{
|
||||
if (!notificationQueue)
|
||||
notificationQueue = WMCreateNotificationQueue();
|
||||
|
||||
return notificationQueue;
|
||||
}
|
||||
|
||||
WMNotificationQueue *WMCreateNotificationQueue(void)
|
||||
{
|
||||
NotificationQueue *queue;
|
||||
|
||||
queue = wmalloc(sizeof(NotificationQueue));
|
||||
queue->asapQueue = WMCreateArrayWithDestructor(8, (WMFreeDataProc *) WMReleaseNotification);
|
||||
queue->idleQueue = WMCreateArrayWithDestructor(8, (WMFreeDataProc *) WMReleaseNotification);
|
||||
queue->next = notificationQueueList;
|
||||
|
||||
notificationQueueList = queue;
|
||||
|
||||
return queue;
|
||||
}
|
||||
|
||||
void WMEnqueueNotification(WMNotificationQueue * queue, WMNotification * notification, WMPostingStyle postingStyle)
|
||||
{
|
||||
WMEnqueueCoalesceNotification(queue, notification, postingStyle, WNCOnName | WNCOnSender);
|
||||
}
|
||||
|
||||
#define NOTIF ((WMNotification*)cdata)
|
||||
#define ITEM ((WMNotification*)item)
|
||||
|
||||
static int matchSenderAndName(const void *item, const void *cdata)
|
||||
{
|
||||
return (NOTIF->object == ITEM->object && strcmp(NOTIF->name, ITEM->name) == 0);
|
||||
}
|
||||
|
||||
static int matchSender(const void *item, const void *cdata)
|
||||
{
|
||||
return (NOTIF->object == ITEM->object);
|
||||
}
|
||||
|
||||
static int matchName(const void *item, const void *cdata)
|
||||
{
|
||||
return (strcmp(NOTIF->name, ITEM->name) == 0);
|
||||
}
|
||||
|
||||
#undef NOTIF
|
||||
#undef ITEM
|
||||
|
||||
void WMDequeueNotificationMatching(WMNotificationQueue * queue, WMNotification * notification, unsigned mask)
|
||||
{
|
||||
WMMatchDataProc *matchFunc;
|
||||
|
||||
if ((mask & WNCOnName) && (mask & WNCOnSender))
|
||||
matchFunc = matchSenderAndName;
|
||||
else if (mask & WNCOnName)
|
||||
matchFunc = matchName;
|
||||
else if (mask & WNCOnSender)
|
||||
matchFunc = matchSender;
|
||||
else
|
||||
return;
|
||||
|
||||
WMRemoveFromArrayMatching(queue->asapQueue, matchFunc, notification);
|
||||
WMRemoveFromArrayMatching(queue->idleQueue, matchFunc, notification);
|
||||
}
|
||||
|
||||
void
|
||||
WMEnqueueCoalesceNotification(WMNotificationQueue * queue,
|
||||
WMNotification * notification, WMPostingStyle postingStyle, unsigned coalesceMask)
|
||||
{
|
||||
if (coalesceMask != WNCNone)
|
||||
WMDequeueNotificationMatching(queue, notification, coalesceMask);
|
||||
|
||||
switch (postingStyle) {
|
||||
case WMPostNow:
|
||||
WMPostNotification(notification);
|
||||
WMReleaseNotification(notification);
|
||||
break;
|
||||
|
||||
case WMPostASAP:
|
||||
WMAddToArray(queue->asapQueue, notification);
|
||||
break;
|
||||
|
||||
case WMPostWhenIdle:
|
||||
WMAddToArray(queue->idleQueue, notification);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void W_FlushASAPNotificationQueue(void)
|
||||
{
|
||||
WMNotificationQueue *queue = notificationQueueList;
|
||||
|
||||
while (queue) {
|
||||
while (WMGetArrayItemCount(queue->asapQueue)) {
|
||||
WMPostNotification(WMGetFromArray(queue->asapQueue, 0));
|
||||
WMDeleteFromArray(queue->asapQueue, 0);
|
||||
}
|
||||
|
||||
queue = queue->next;
|
||||
}
|
||||
}
|
||||
|
||||
void W_FlushIdleNotificationQueue(void)
|
||||
{
|
||||
WMNotificationQueue *queue = notificationQueueList;
|
||||
|
||||
while (queue) {
|
||||
while (WMGetArrayItemCount(queue->idleQueue)) {
|
||||
WMPostNotification(WMGetFromArray(queue->idleQueue, 0));
|
||||
WMDeleteFromArray(queue->idleQueue, 0);
|
||||
}
|
||||
|
||||
queue = queue->next;
|
||||
}
|
||||
}
|
||||
+6
-1842
File diff suppressed because it is too large.
Load diff
+4
-3
@@ -237,7 +237,7 @@ static void handleRequestEvent(XEvent * event)
|
||||
}
|
||||
|
||||
/* delete handlers */
|
||||
copy = WMDuplicateArray(selHandlers);
|
||||
copy = WMCreateArrayWithArray(selHandlers);
|
||||
WM_ITERATE_ARRAY(copy, handler, iter) {
|
||||
if (handler && handler->flags.delete_pending) {
|
||||
WMDeleteSelectionHandler(handler->view, handler->selection, handler->timestamp);
|
||||
@@ -261,8 +261,9 @@ static WMData *getSelectionData(Display * dpy, Window win, Atom where)
|
||||
|
||||
bpi = bits / 8;
|
||||
|
||||
wdata = WMCreateDataWithBytesNoCopy(data, len * bpi, (void *) XFree);
|
||||
wdata = WMCreateDataWithBytes(data, len * bpi);
|
||||
WMSetDataFormat(wdata, bits);
|
||||
XFree(data);
|
||||
|
||||
return wdata;
|
||||
}
|
||||
@@ -300,7 +301,7 @@ static void handleNotifyEvent(XEvent * event)
|
||||
}
|
||||
|
||||
/* delete callbacks */
|
||||
copy = WMDuplicateArray(selCallbacks);
|
||||
copy = WMCreateArrayWithArray(selCallbacks);
|
||||
WM_ITERATE_ARRAY(copy, handler, iter) {
|
||||
if (handler && handler->flags.delete_pending) {
|
||||
WMDeleteSelectionCallback(handler->view, handler->selection, handler->timestamp);
|
||||
|
||||
-425
@@ -1,425 +0,0 @@
|
||||
/*
|
||||
* Until FreeBSD gets their act together;
|
||||
* http://www.mail-archive.com/freebsd-hackers@freebsd.org/msg69469.html
|
||||
*/
|
||||
#if defined( FREEBSD )
|
||||
# undef _XOPEN_SOURCE
|
||||
#endif
|
||||
|
||||
#include "wconfig.h"
|
||||
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <assert.h>
|
||||
#include <ctype.h>
|
||||
#ifdef HAVE_BSD_STRING_H
|
||||
#include <bsd/string.h>
|
||||
#endif
|
||||
|
||||
#include "WUtil.h"
|
||||
|
||||
#define PRC_ALPHA 0
|
||||
#define PRC_BLANK 1
|
||||
#define PRC_ESCAPE 2
|
||||
#define PRC_DQUOTE 3
|
||||
#define PRC_EOS 4
|
||||
#define PRC_SQUOTE 5
|
||||
|
||||
typedef struct {
|
||||
short nstate;
|
||||
short output;
|
||||
} DFA;
|
||||
|
||||
static DFA mtable[9][6] = {
|
||||
{{3, 1}, {0, 0}, {4, 0}, {1, 0}, {8, 0}, {6, 0}},
|
||||
{{1, 1}, {1, 1}, {2, 0}, {3, 0}, {5, 0}, {1, 1}},
|
||||
{{1, 1}, {1, 1}, {1, 1}, {1, 1}, {5, 0}, {1, 1}},
|
||||
{{3, 1}, {5, 0}, {4, 0}, {1, 0}, {5, 0}, {6, 0}},
|
||||
{{3, 1}, {3, 1}, {3, 1}, {3, 1}, {5, 0}, {3, 1}},
|
||||
{{-1, -1}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}}, /* final state */
|
||||
{{6, 1}, {6, 1}, {7, 0}, {6, 1}, {5, 0}, {3, 0}},
|
||||
{{6, 1}, {6, 1}, {6, 1}, {6, 1}, {5, 0}, {6, 1}},
|
||||
{{-1, -1}, {0, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 0}}, /* final state */
|
||||
};
|
||||
|
||||
char *wtokennext(char *word, char **next)
|
||||
{
|
||||
char *ptr;
|
||||
char *ret, *t;
|
||||
int state, ctype;
|
||||
|
||||
t = ret = wmalloc(strlen(word) + 1);
|
||||
ptr = word;
|
||||
|
||||
state = 0;
|
||||
while (1) {
|
||||
if (*ptr == 0)
|
||||
ctype = PRC_EOS;
|
||||
else if (*ptr == '\\')
|
||||
ctype = PRC_ESCAPE;
|
||||
else if (*ptr == '"')
|
||||
ctype = PRC_DQUOTE;
|
||||
else if (*ptr == '\'')
|
||||
ctype = PRC_SQUOTE;
|
||||
else if (*ptr == ' ' || *ptr == '\t')
|
||||
ctype = PRC_BLANK;
|
||||
else
|
||||
ctype = PRC_ALPHA;
|
||||
|
||||
if (mtable[state][ctype].output) {
|
||||
*t = *ptr;
|
||||
t++;
|
||||
*t = 0;
|
||||
}
|
||||
state = mtable[state][ctype].nstate;
|
||||
ptr++;
|
||||
if (mtable[state][0].output < 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (*ret == 0) {
|
||||
wfree(ret);
|
||||
ret = NULL;
|
||||
}
|
||||
|
||||
if (ctype == PRC_EOS)
|
||||
*next = NULL;
|
||||
else
|
||||
*next = ptr;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/* separate a string in tokens, taking " and ' into account */
|
||||
void wtokensplit(char *command, char ***argv, int *argc)
|
||||
{
|
||||
char *token, *line;
|
||||
int count;
|
||||
|
||||
count = 0;
|
||||
line = command;
|
||||
do {
|
||||
token = wtokennext(line, &line);
|
||||
if (token) {
|
||||
if (count == 0)
|
||||
*argv = wmalloc(sizeof(**argv));
|
||||
else
|
||||
*argv = wrealloc(*argv, (count + 1) * sizeof(**argv));
|
||||
(*argv)[count++] = token;
|
||||
}
|
||||
} while (token != NULL && line != NULL);
|
||||
|
||||
*argc = count;
|
||||
}
|
||||
|
||||
char *wtokenjoin(char **list, int count)
|
||||
{
|
||||
int i, j;
|
||||
char *flat_string, *wspace;
|
||||
|
||||
j = 0;
|
||||
for (i = 0; i < count; i++) {
|
||||
if (list[i] != NULL && list[i][0] != 0) {
|
||||
j += strlen(list[i]);
|
||||
if (strpbrk(list[i], " \t"))
|
||||
j += 2;
|
||||
}
|
||||
}
|
||||
|
||||
flat_string = wmalloc(j + count + 1);
|
||||
|
||||
for (i = 0; i < count; i++) {
|
||||
if (list[i] != NULL && list[i][0] != 0) {
|
||||
if (i > 0 &&
|
||||
wstrlcat(flat_string, " ", j + count + 1) >= j + count + 1)
|
||||
goto error;
|
||||
|
||||
wspace = strpbrk(list[i], " \t");
|
||||
|
||||
if (wspace &&
|
||||
wstrlcat(flat_string, "\"", j + count + 1) >= j + count + 1)
|
||||
goto error;
|
||||
|
||||
if (wstrlcat(flat_string, list[i], j + count + 1) >= j + count + 1)
|
||||
goto error;
|
||||
|
||||
if (wspace &&
|
||||
wstrlcat(flat_string, "\"", j + count + 1) >= j + count + 1)
|
||||
goto error;
|
||||
}
|
||||
}
|
||||
|
||||
return flat_string;
|
||||
|
||||
error:
|
||||
wfree(flat_string);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void wtokenfree(char **tokens, int count)
|
||||
{
|
||||
while (count--)
|
||||
wfree(tokens[count]);
|
||||
wfree(tokens);
|
||||
}
|
||||
|
||||
char *wtrimspace(const char *s)
|
||||
{
|
||||
const char *t;
|
||||
|
||||
if (s == NULL)
|
||||
return NULL;
|
||||
|
||||
while (isspace(*s) && *s)
|
||||
s++;
|
||||
t = s + strlen(s) - 1;
|
||||
while (t > s && isspace(*t))
|
||||
t--;
|
||||
|
||||
return wstrndup(s, t - s + 1);
|
||||
}
|
||||
|
||||
char *wstrdup(const char *str)
|
||||
{
|
||||
assert(str != NULL);
|
||||
|
||||
return strcpy(wmalloc(strlen(str) + 1), str);
|
||||
}
|
||||
|
||||
char *wstrndup(const char *str, size_t len)
|
||||
{
|
||||
char *copy;
|
||||
|
||||
assert(str != NULL);
|
||||
|
||||
len = WMIN(len, strlen(str));
|
||||
copy = strncpy(wmalloc(len + 1), str, len);
|
||||
copy[len] = 0;
|
||||
|
||||
return copy;
|
||||
}
|
||||
|
||||
char *wstrconcat(const char *str1, const char *str2)
|
||||
{
|
||||
char *str;
|
||||
size_t slen, slen1;
|
||||
|
||||
if (!str1 && str2)
|
||||
return wstrdup(str2);
|
||||
else if (str1 && !str2)
|
||||
return wstrdup(str1);
|
||||
else if (!str1 && !str2)
|
||||
return NULL;
|
||||
|
||||
slen1 = strlen(str1);
|
||||
slen = slen1 + strlen(str2) + 1;
|
||||
str = wmalloc(slen);
|
||||
strcpy(str, str1);
|
||||
strcpy(str + slen1, str2);
|
||||
|
||||
return str;
|
||||
}
|
||||
|
||||
char *wstrappend(char *dst, const char *src)
|
||||
{
|
||||
size_t slen;
|
||||
|
||||
if (!src || *src == 0)
|
||||
return dst;
|
||||
else if (!dst)
|
||||
return wstrdup(src);
|
||||
|
||||
slen = strlen(dst) + strlen(src) + 1;
|
||||
dst = wrealloc(dst, slen);
|
||||
strcat(dst, src);
|
||||
|
||||
return dst;
|
||||
}
|
||||
|
||||
|
||||
#ifdef HAVE_STRLCAT
|
||||
size_t
|
||||
wstrlcat(char *dst, const char *src, size_t siz)
|
||||
{
|
||||
return strlcat(dst, src, siz);
|
||||
}
|
||||
#else
|
||||
/* $OpenBSD: strlcat.c,v 1.13 2005/08/08 08:05:37 espie Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
|
||||
*
|
||||
* Permission to use, copy, modify, and distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Appends src to string dst of size siz (unlike strncat, siz is the
|
||||
* full size of dst, not space left). At most siz-1 characters
|
||||
* will be copied. Always NUL terminates (unless siz <= strlen(dst)).
|
||||
* Returns strlen(src) + MIN(siz, strlen(initial dst)).
|
||||
* If retval >= siz, truncation occurred.
|
||||
*/
|
||||
size_t
|
||||
wstrlcat(char *dst, const char *src, size_t siz)
|
||||
{
|
||||
char *d = dst;
|
||||
const char *s = src;
|
||||
size_t n = siz;
|
||||
size_t dlen;
|
||||
|
||||
/* Find the end of dst and adjust bytes left but don't go past end */
|
||||
while (n-- != 0 && *d != '\0')
|
||||
d++;
|
||||
dlen = d - dst;
|
||||
n = siz - dlen;
|
||||
|
||||
if (n == 0)
|
||||
return(dlen + strlen(s));
|
||||
while (*s != '\0') {
|
||||
if (n != 1) {
|
||||
*d++ = *s;
|
||||
n--;
|
||||
}
|
||||
s++;
|
||||
}
|
||||
*d = '\0';
|
||||
|
||||
return(dlen + (s - src)); /* count does not include NUL */
|
||||
}
|
||||
#endif /* HAVE_STRLCAT */
|
||||
|
||||
#ifdef HAVE_STRLCPY
|
||||
size_t
|
||||
wstrlcpy(char *dst, const char *src, size_t siz)
|
||||
{
|
||||
return strlcpy(dst, src, siz);
|
||||
}
|
||||
#else
|
||||
|
||||
/* $OpenBSD: strlcpy.c,v 1.11 2006/05/05 15:27:38 millert Exp $ */
|
||||
|
||||
/*
|
||||
* Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
|
||||
*
|
||||
* Permission to use, copy, modify, and distribute this software for any
|
||||
* purpose with or without fee is hereby granted, provided that the above
|
||||
* copyright notice and this permission notice appear in all copies.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
||||
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
||||
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
||||
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
||||
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
||||
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
||||
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Copy src to string dst of size siz. At most siz-1 characters
|
||||
* will be copied. Always NUL terminates (unless siz == 0).
|
||||
* Returns strlen(src); if retval >= siz, truncation occurred.
|
||||
*/
|
||||
size_t
|
||||
wstrlcpy(char *dst, const char *src, size_t siz)
|
||||
{
|
||||
char *d = dst;
|
||||
const char *s = src;
|
||||
size_t n = siz;
|
||||
|
||||
/* Copy as many bytes as will fit */
|
||||
if (n != 0) {
|
||||
while (--n != 0) {
|
||||
if ((*d++ = *s++) == '\0')
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Not enough room in dst, add NUL and traverse rest of src */
|
||||
if (n == 0) {
|
||||
if (siz != 0)
|
||||
*d = '\0'; /* NUL-terminate dst */
|
||||
while (*s++)
|
||||
;
|
||||
}
|
||||
|
||||
return(s - src - 1); /* count does not include NUL */
|
||||
}
|
||||
#endif /* HAVE_STRLCPY */
|
||||
|
||||
/* transform `s' so that the result is safe to pass to the shell as an argument.
|
||||
* returns a newly allocated string.
|
||||
* with very heavy inspirations from NetBSD's shquote(3).
|
||||
*/
|
||||
char *wshellquote(const char *s)
|
||||
{
|
||||
char *p, *r, *last, *ret;
|
||||
size_t slen;
|
||||
int needs_quoting;
|
||||
|
||||
if (!s)
|
||||
return NULL;
|
||||
|
||||
needs_quoting = !*s; /* the empty string does need quoting */
|
||||
|
||||
/* do not quote if consists only of the following characters */
|
||||
for (p = (char *)s; *p && !needs_quoting; p++) {
|
||||
needs_quoting = !(isalnum(*p) || (*p == '+') || (*p == '/') ||
|
||||
(*p == '.') || (*p == ',') || (*p == '-'));
|
||||
}
|
||||
|
||||
if (!needs_quoting)
|
||||
return wstrdup(s);
|
||||
|
||||
for (slen = 0, p = (char *)s; *p; p++) /* count space needed (worst case) */
|
||||
slen += *p == '\'' ? 4 : 1; /* every single ' becomes ''\' */
|
||||
|
||||
slen += 2 /* leading + trailing "'" */ + 1 /* NULL */;
|
||||
|
||||
ret = r = wmalloc(slen);
|
||||
p = (char *)s;
|
||||
last = p;
|
||||
|
||||
if (*p != '\'') /* if string doesn't already begin with "'" */
|
||||
*r++ ='\''; /* start putting it in quotes */
|
||||
|
||||
while (*p) {
|
||||
last = p;
|
||||
if (*p == '\'') { /* turn each ' into ''\' */
|
||||
if (p != s) /* except if it's the first ', in which case */
|
||||
*r++ = '\''; /* only escape it */
|
||||
*r++ = '\\';
|
||||
*r++ = '\'';
|
||||
while (*++p && *p == '\'') { /* keep turning each consecutive 's into \' */
|
||||
*r++ = '\\';
|
||||
*r++ = '\'';
|
||||
}
|
||||
if (*p) /* if more input follows, terminate */
|
||||
*r++ = '\''; /* what we have so far */
|
||||
} else {
|
||||
*r++ = *p++;
|
||||
}
|
||||
}
|
||||
|
||||
if (*last != '\'') /* if the last one isn't already a ' */
|
||||
*r++ = '\''; /* terminate the whole shebang */
|
||||
|
||||
*r = '\0';
|
||||
|
||||
return ret; /* technically, we lose (but not leak) a couple of */
|
||||
/* bytes (twice the number of consecutive 's in the */
|
||||
/* input or so), but since these are relatively rare */
|
||||
/* and short-lived strings, not sure if a trip to */
|
||||
/* wstrdup+wfree worths the gain. */
|
||||
}
|
||||
-255
@@ -1,255 +0,0 @@
|
||||
|
||||
#include <string.h>
|
||||
|
||||
#include "WUtil.h"
|
||||
|
||||
typedef struct W_TreeNode {
|
||||
void *data;
|
||||
|
||||
/*unsigned int uflags:16; */
|
||||
|
||||
WMArray *leaves;
|
||||
|
||||
int depth;
|
||||
|
||||
struct W_TreeNode *parent;
|
||||
|
||||
WMFreeDataProc *destructor;
|
||||
} W_TreeNode;
|
||||
|
||||
static void destroyNode(void *data)
|
||||
{
|
||||
WMTreeNode *aNode = (WMTreeNode *) data;
|
||||
|
||||
if (aNode->destructor) {
|
||||
(*aNode->destructor) (aNode->data);
|
||||
}
|
||||
if (aNode->leaves) {
|
||||
WMFreeArray(aNode->leaves);
|
||||
}
|
||||
wfree(aNode);
|
||||
}
|
||||
|
||||
WMTreeNode *WMCreateTreeNode(void *data)
|
||||
{
|
||||
return WMCreateTreeNodeWithDestructor(data, NULL);
|
||||
}
|
||||
|
||||
WMTreeNode *WMCreateTreeNodeWithDestructor(void *data, WMFreeDataProc * destructor)
|
||||
{
|
||||
WMTreeNode *aNode;
|
||||
|
||||
aNode = (WMTreeNode *) wmalloc(sizeof(W_TreeNode));
|
||||
aNode->destructor = destructor;
|
||||
aNode->data = data;
|
||||
aNode->parent = NULL;
|
||||
aNode->depth = 0;
|
||||
aNode->leaves = NULL;
|
||||
/*aNode->leaves = WMCreateArrayWithDestructor(1, destroyNode); */
|
||||
|
||||
return aNode;
|
||||
}
|
||||
|
||||
WMTreeNode *WMInsertItemInTree(WMTreeNode * parent, int index, void *item)
|
||||
{
|
||||
WMTreeNode *aNode;
|
||||
|
||||
wassertrv(parent != NULL, NULL);
|
||||
|
||||
aNode = WMCreateTreeNodeWithDestructor(item, parent->destructor);
|
||||
aNode->parent = parent;
|
||||
aNode->depth = parent->depth + 1;
|
||||
if (!parent->leaves) {
|
||||
parent->leaves = WMCreateArrayWithDestructor(1, destroyNode);
|
||||
}
|
||||
if (index < 0) {
|
||||
WMAddToArray(parent->leaves, aNode);
|
||||
} else {
|
||||
WMInsertInArray(parent->leaves, index, aNode);
|
||||
}
|
||||
|
||||
return aNode;
|
||||
}
|
||||
|
||||
static void updateNodeDepth(WMTreeNode * aNode, int depth)
|
||||
{
|
||||
int i;
|
||||
|
||||
aNode->depth = depth;
|
||||
|
||||
if (aNode->leaves) {
|
||||
for (i = 0; i < WMGetArrayItemCount(aNode->leaves); i++) {
|
||||
updateNodeDepth(WMGetFromArray(aNode->leaves, i), depth + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
WMTreeNode *WMInsertNodeInTree(WMTreeNode * parent, int index, WMTreeNode * aNode)
|
||||
{
|
||||
wassertrv(parent != NULL, NULL);
|
||||
wassertrv(aNode != NULL, NULL);
|
||||
|
||||
aNode->parent = parent;
|
||||
updateNodeDepth(aNode, parent->depth + 1);
|
||||
if (!parent->leaves) {
|
||||
parent->leaves = WMCreateArrayWithDestructor(1, destroyNode);
|
||||
}
|
||||
if (index < 0) {
|
||||
WMAddToArray(parent->leaves, aNode);
|
||||
} else {
|
||||
WMInsertInArray(parent->leaves, index, aNode);
|
||||
}
|
||||
|
||||
return aNode;
|
||||
}
|
||||
|
||||
void WMDestroyTreeNode(WMTreeNode * aNode)
|
||||
{
|
||||
wassertr(aNode != NULL);
|
||||
|
||||
if (aNode->parent && aNode->parent->leaves) {
|
||||
WMRemoveFromArray(aNode->parent->leaves, aNode);
|
||||
} else {
|
||||
destroyNode(aNode);
|
||||
}
|
||||
}
|
||||
|
||||
void WMDeleteLeafForTreeNode(WMTreeNode * aNode, int index)
|
||||
{
|
||||
wassertr(aNode != NULL);
|
||||
wassertr(aNode->leaves != NULL);
|
||||
|
||||
WMDeleteFromArray(aNode->leaves, index);
|
||||
}
|
||||
|
||||
static int sameData(const void *item, const void *data)
|
||||
{
|
||||
return (((WMTreeNode *) item)->data == data);
|
||||
}
|
||||
|
||||
void WMRemoveLeafForTreeNode(WMTreeNode * aNode, void *leaf)
|
||||
{
|
||||
int index;
|
||||
|
||||
wassertr(aNode != NULL);
|
||||
wassertr(aNode->leaves != NULL);
|
||||
|
||||
index = WMFindInArray(aNode->leaves, sameData, leaf);
|
||||
if (index != WANotFound) {
|
||||
WMDeleteFromArray(aNode->leaves, index);
|
||||
}
|
||||
}
|
||||
|
||||
void *WMReplaceDataForTreeNode(WMTreeNode * aNode, void *newData)
|
||||
{
|
||||
void *old;
|
||||
|
||||
wassertrv(aNode != NULL, NULL);
|
||||
|
||||
old = aNode->data;
|
||||
aNode->data = newData;
|
||||
|
||||
return old;
|
||||
}
|
||||
|
||||
void *WMGetDataForTreeNode(WMTreeNode * aNode)
|
||||
{
|
||||
return aNode->data;
|
||||
}
|
||||
|
||||
int WMGetTreeNodeDepth(WMTreeNode * aNode)
|
||||
{
|
||||
return aNode->depth;
|
||||
}
|
||||
|
||||
WMTreeNode *WMGetParentForTreeNode(WMTreeNode * aNode)
|
||||
{
|
||||
return aNode->parent;
|
||||
}
|
||||
|
||||
void WMSortLeavesForTreeNode(WMTreeNode * aNode, WMCompareDataProc * comparer)
|
||||
{
|
||||
wassertr(aNode != NULL);
|
||||
|
||||
if (aNode->leaves) {
|
||||
WMSortArray(aNode->leaves, comparer);
|
||||
}
|
||||
}
|
||||
|
||||
static void sortLeavesForNode(WMTreeNode * aNode, WMCompareDataProc * comparer)
|
||||
{
|
||||
int i;
|
||||
|
||||
if (!aNode->leaves)
|
||||
return;
|
||||
|
||||
WMSortArray(aNode->leaves, comparer);
|
||||
for (i = 0; i < WMGetArrayItemCount(aNode->leaves); i++) {
|
||||
sortLeavesForNode(WMGetFromArray(aNode->leaves, i), comparer);
|
||||
}
|
||||
}
|
||||
|
||||
void WMSortTree(WMTreeNode * aNode, WMCompareDataProc * comparer)
|
||||
{
|
||||
wassertr(aNode != NULL);
|
||||
|
||||
sortLeavesForNode(aNode, comparer);
|
||||
}
|
||||
|
||||
static WMTreeNode *findNodeInTree(WMTreeNode * aNode, WMMatchDataProc * match, void *cdata, int limit)
|
||||
{
|
||||
if (match == NULL && aNode->data == cdata)
|
||||
return aNode;
|
||||
else if (match && (*match) (aNode->data, cdata))
|
||||
return aNode;
|
||||
|
||||
if (aNode->leaves && limit != 0) {
|
||||
WMTreeNode *leaf;
|
||||
int i;
|
||||
|
||||
for (i = 0; i < WMGetArrayItemCount(aNode->leaves); i++) {
|
||||
leaf = findNodeInTree(WMGetFromArray(aNode->leaves, i),
|
||||
match, cdata, limit > 0 ? limit - 1 : limit);
|
||||
if (leaf)
|
||||
return leaf;
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
WMTreeNode *WMFindInTree(WMTreeNode * aTree, WMMatchDataProc * match, void *cdata)
|
||||
{
|
||||
wassertrv(aTree != NULL, NULL);
|
||||
|
||||
return findNodeInTree(aTree, match, cdata, -1);
|
||||
}
|
||||
|
||||
WMTreeNode *WMFindInTreeWithDepthLimit(WMTreeNode * aTree, WMMatchDataProc * match, void *cdata, int limit)
|
||||
{
|
||||
wassertrv(aTree != NULL, NULL);
|
||||
wassertrv(limit >= 0, NULL);
|
||||
|
||||
return findNodeInTree(aTree, match, cdata, limit);
|
||||
}
|
||||
|
||||
void WMTreeWalk(WMTreeNode * aNode, WMTreeWalkProc * walk, void *data, Bool DepthFirst)
|
||||
{
|
||||
int i;
|
||||
WMTreeNode *leaf;
|
||||
|
||||
wassertr(aNode != NULL);
|
||||
|
||||
if (DepthFirst)
|
||||
(*walk)(aNode, data);
|
||||
|
||||
if (aNode->leaves) {
|
||||
for (i = 0; i < WMGetArrayItemCount(aNode->leaves); i++) {
|
||||
leaf = (WMTreeNode *)WMGetFromArray(aNode->leaves, i);
|
||||
WMTreeWalk(leaf, walk, data, DepthFirst);
|
||||
}
|
||||
}
|
||||
|
||||
if (!DepthFirst)
|
||||
(*walk)(aNode, data);
|
||||
}
|
||||
+2
-36
@@ -46,40 +46,6 @@ static void synchronizeUserDefaults(void *foo);
|
||||
#define UD_SYNC_INTERVAL 2000
|
||||
#endif
|
||||
|
||||
const char *wusergnusteppath(void)
|
||||
{
|
||||
static const char subdir[] = "/" GSUSER_SUBDIR;
|
||||
static char *path = NULL;
|
||||
char *gspath;
|
||||
const char *h;
|
||||
int pathlen;
|
||||
|
||||
if (path)
|
||||
/* Value have been already computed, re-use it */
|
||||
return path;
|
||||
|
||||
gspath = GETENV("WMAKER_USER_ROOT");
|
||||
if (gspath) {
|
||||
gspath = wexpandpath(gspath);
|
||||
if (gspath) {
|
||||
path = gspath;
|
||||
return path;
|
||||
}
|
||||
wwarning(_("variable WMAKER_USER_ROOT defined with invalid path, not used"));
|
||||
}
|
||||
|
||||
h = wgethomedir();
|
||||
if (!h)
|
||||
return NULL;
|
||||
|
||||
pathlen = strlen(h);
|
||||
path = wmalloc(pathlen + sizeof(subdir));
|
||||
strcpy(path, h);
|
||||
strcpy(path + pathlen, subdir);
|
||||
|
||||
return path;
|
||||
}
|
||||
|
||||
const char *wuserdatapath(void)
|
||||
{
|
||||
static char *path = NULL;
|
||||
@@ -331,7 +297,7 @@ WMUserDefaults *WMGetStandardUserDefaults(void)
|
||||
/* terminate list */
|
||||
defaults->searchList[2] = NULL;
|
||||
|
||||
defaults->searchListArray = WMCreatePLArray(NULL, NULL);
|
||||
defaults->searchListArray = WMCreateEmptyPLArray();
|
||||
|
||||
i = 0;
|
||||
while (defaults->searchList[i]) {
|
||||
@@ -404,7 +370,7 @@ WMUserDefaults *WMGetDefaultsFromPath(const char *path)
|
||||
/* terminate list */
|
||||
defaults->searchList[1] = NULL;
|
||||
|
||||
defaults->searchListArray = WMCreatePLArray(NULL, NULL);
|
||||
defaults->searchListArray = WMCreateEmptyPLArray();
|
||||
|
||||
i = 0;
|
||||
while (defaults->searchList[i]) {
|
||||
|
||||
+8
-11
@@ -44,9 +44,6 @@ void WMInitializeApplication(const char *applicationName, int *argc, char **argv
|
||||
WMApplication.argv[i] = wstrdup(argv[i]);
|
||||
}
|
||||
WMApplication.argv[i] = NULL;
|
||||
|
||||
/* initialize notification center */
|
||||
W_InitNotificationCenter();
|
||||
}
|
||||
|
||||
void WMReleaseApplication(void) {
|
||||
@@ -60,7 +57,7 @@ void WMReleaseApplication(void) {
|
||||
*/
|
||||
w_save_defaults_changes();
|
||||
|
||||
W_ReleaseNotificationCenter();
|
||||
W_ClearNotificationCenter();
|
||||
|
||||
if (WMApplication.applicationName) {
|
||||
wfree(WMApplication.applicationName);
|
||||
@@ -101,21 +98,21 @@ static char *checkFile(const char *path, const char *folder, const char *ext, co
|
||||
slen = strlen(path) + strlen(resource) + 1 + extralen;
|
||||
ret = wmalloc(slen);
|
||||
|
||||
if (wstrlcpy(ret, path, slen) >= slen)
|
||||
if (strlcpy(ret, path, slen) >= slen)
|
||||
goto error;
|
||||
|
||||
if (folder &&
|
||||
(wstrlcat(ret, "/", slen) >= slen ||
|
||||
wstrlcat(ret, folder, slen) >= slen))
|
||||
(strlcat(ret, "/", slen) >= slen ||
|
||||
strlcat(ret, folder, slen) >= slen))
|
||||
goto error;
|
||||
|
||||
if (ext &&
|
||||
(wstrlcat(ret, "/", slen) >= slen ||
|
||||
wstrlcat(ret, ext, slen) >= slen))
|
||||
(strlcat(ret, "/", slen) >= slen ||
|
||||
strlcat(ret, ext, slen) >= slen))
|
||||
goto error;
|
||||
|
||||
if (wstrlcat(ret, "/", slen) >= slen ||
|
||||
wstrlcat(ret, resource, slen) >= slen)
|
||||
if (strlcat(ret, "/", slen) >= slen ||
|
||||
strlcat(ret, resource, slen) >= slen)
|
||||
goto error;
|
||||
|
||||
if (access(ret, F_OK) != 0)
|
||||
|
||||
+1
-1
@@ -65,7 +65,7 @@ struct W_Balloon *W_CreateBalloon(WMScreen * scr)
|
||||
W_ResizeView(bPtr->view, DEFAULT_WIDTH, DEFAULT_HEIGHT);
|
||||
bPtr->flags.alignment = DEFAULT_ALIGNMENT;
|
||||
|
||||
bPtr->table = WMCreateHashTable(WMIntHashCallbacks);
|
||||
bPtr->table = WMCreateIdentityHashTable();
|
||||
|
||||
bPtr->delay = DEFAULT_DELAY;
|
||||
|
||||
|
||||
+9
-9
@@ -314,7 +314,7 @@ static void removeColumn(WMBrowser * bPtr, int column)
|
||||
wfree(bPtr->titles[i]);
|
||||
bPtr->titles[i] = NULL;
|
||||
}
|
||||
WMRemoveNotificationObserverWithName(bPtr, WMListSelectionDidChangeNotification, bPtr->columns[i]);
|
||||
WMRemoveNotificationObserver(bPtr->columns[i]);
|
||||
WMDestroyWidget(bPtr->columns[i]);
|
||||
bPtr->columns[i] = NULL;
|
||||
}
|
||||
@@ -720,14 +720,14 @@ char *WMGetBrowserPathToColumn(WMBrowser * bPtr, int column)
|
||||
path = wmalloc(slen);
|
||||
/* ignore first `/' */
|
||||
for (i = 0; i <= column; i++) {
|
||||
if (wstrlcat(path, bPtr->pathSeparator, slen) >= slen)
|
||||
if (strlcat(path, bPtr->pathSeparator, slen) >= slen)
|
||||
goto error;
|
||||
|
||||
item = WMGetListSelectedItem(bPtr->columns[i]);
|
||||
if (!item)
|
||||
break;
|
||||
|
||||
if (wstrlcat(path, item->text, slen) >= slen)
|
||||
if (strlcat(path, item->text, slen) >= slen)
|
||||
goto error;
|
||||
|
||||
}
|
||||
@@ -782,7 +782,7 @@ WMArray *WMGetBrowserPaths(WMBrowser * bPtr)
|
||||
path = wmalloc(slen);
|
||||
/* ignore first `/' */
|
||||
for (i = 0; i <= column; i++) {
|
||||
wstrlcat(path, bPtr->pathSeparator, slen);
|
||||
strlcat(path, bPtr->pathSeparator, slen);
|
||||
if (i == column) {
|
||||
item = lastItem;
|
||||
} else {
|
||||
@@ -790,7 +790,7 @@ WMArray *WMGetBrowserPaths(WMBrowser * bPtr)
|
||||
}
|
||||
if (!item)
|
||||
break;
|
||||
wstrlcat(path, item->text, slen);
|
||||
strlcat(path, item->text, slen);
|
||||
}
|
||||
WMAddToArray(paths, path);
|
||||
}
|
||||
@@ -1130,25 +1130,25 @@ static char *createTruncatedString(WMFont * font, const char *text, int *textLen
|
||||
if (width >= 3 * dLen) {
|
||||
int tmpTextLen = *textLen;
|
||||
|
||||
if (wstrlcpy(textBuf, text, slen) >= slen)
|
||||
if (strlcpy(textBuf, text, slen) >= slen)
|
||||
goto error;
|
||||
|
||||
while (tmpTextLen && (WMWidthOfString(font, textBuf, tmpTextLen) + 3 * dLen > width))
|
||||
tmpTextLen--;
|
||||
|
||||
if (wstrlcpy(textBuf + tmpTextLen, "...", slen) >= slen)
|
||||
if (strlcpy(textBuf + tmpTextLen, "...", slen) >= slen)
|
||||
goto error;
|
||||
|
||||
*textLen = tmpTextLen + 3;
|
||||
|
||||
} else if (width >= 2 * dLen) {
|
||||
if (wstrlcpy(textBuf, "..", slen) >= slen)
|
||||
if (strlcpy(textBuf, "..", slen) >= slen)
|
||||
goto error;
|
||||
|
||||
*textLen = 2;
|
||||
|
||||
} else if (width >= dLen) {
|
||||
if (wstrlcpy(textBuf, ".", slen) >= slen)
|
||||
if (strlcpy(textBuf, ".", slen) >= slen)
|
||||
goto error;
|
||||
|
||||
*textLen = 1;
|
||||
|
||||
+6
-3
@@ -2994,10 +2994,13 @@ static void customPaletteMenuNewFromFile(W_ColorPanel * panel)
|
||||
int i;
|
||||
RImage *tmpImg = NULL;
|
||||
|
||||
if ((!panel->lastBrowseDir) || (strcmp(panel->lastBrowseDir, "\0") == 0))
|
||||
spath = wexpandpath(wgethomedir());
|
||||
else
|
||||
if ((!panel->lastBrowseDir) || (strcmp(panel->lastBrowseDir, "\0") == 0)) {
|
||||
char *homedir = wgethomedir();
|
||||
spath = wexpandpath(homedir);
|
||||
wfree(homedir);
|
||||
} else {
|
||||
spath = wexpandpath(panel->lastBrowseDir);
|
||||
}
|
||||
|
||||
browseP = WMGetOpenPanel(scr);
|
||||
WMSetFilePanelCanChooseDirectories(browseP, 0);
|
||||
|
||||
+8
-10
@@ -513,12 +513,12 @@ static void listDirectoryOnColumn(WMFilePanel * panel, int column, const char *p
|
||||
if (strcmp(dentry->d_name, ".") == 0 || strcmp(dentry->d_name, "..") == 0)
|
||||
continue;
|
||||
|
||||
if (wstrlcpy(pbuf, path, sizeof(pbuf)) >= sizeof(pbuf))
|
||||
if (strlcpy(pbuf, path, sizeof(pbuf)) >= sizeof(pbuf))
|
||||
goto out;
|
||||
if (strcmp(path, "/") != 0 &&
|
||||
wstrlcat(pbuf, "/", sizeof(pbuf)) >= sizeof(pbuf))
|
||||
strlcat(pbuf, "/", sizeof(pbuf)) >= sizeof(pbuf))
|
||||
goto out;
|
||||
if (wstrlcat(pbuf, dentry->d_name, sizeof(pbuf)) >= sizeof(pbuf))
|
||||
if (strlcat(pbuf, dentry->d_name, sizeof(pbuf)) >= sizeof(pbuf))
|
||||
goto out;
|
||||
|
||||
if (stat(pbuf, &stat_buf) != 0) {
|
||||
@@ -626,11 +626,11 @@ static void createDir(WMWidget *widget, void *p_panel)
|
||||
file = wmalloc(slen);
|
||||
|
||||
if (directory &&
|
||||
(wstrlcat(file, directory, slen) >= slen ||
|
||||
wstrlcat(file, "/", slen) >= slen))
|
||||
(strlcat(file, directory, slen) >= slen ||
|
||||
strlcat(file, "/", slen) >= slen))
|
||||
goto out;
|
||||
|
||||
if (wstrlcat(file, dirName, slen) >= slen)
|
||||
if (strlcat(file, dirName, slen) >= slen)
|
||||
goto out;
|
||||
|
||||
if (mkdir(file, 00777) != 0) {
|
||||
@@ -761,17 +761,15 @@ static void goFloppy(WMWidget *widget, void *p_panel)
|
||||
static void goHome(WMWidget *widget, void *p_panel)
|
||||
{
|
||||
WMFilePanel *panel = p_panel;
|
||||
const char *home;
|
||||
char *home;
|
||||
|
||||
/* Parameter not used, but tell the compiler that it is ok */
|
||||
(void) widget;
|
||||
|
||||
/* home is statically allocated. Don't free it! */
|
||||
home = wgethomedir();
|
||||
if (!home)
|
||||
return;
|
||||
|
||||
WMSetFilePanelDirectory(panel, home);
|
||||
wfree(home);
|
||||
}
|
||||
|
||||
static void handleEvents(XEvent * event, void *data)
|
||||
|
||||
+9
-3
@@ -51,12 +51,15 @@ static char *xlfdToFcName(const char *xlfd)
|
||||
{
|
||||
FcPattern *pattern;
|
||||
char *fname;
|
||||
char *result;
|
||||
|
||||
pattern = xlfdToFcPattern(xlfd);
|
||||
fname = (char *)FcNameUnparse(pattern);
|
||||
result = wstrdup(fname);
|
||||
free(fname);
|
||||
FcPatternDestroy(pattern);
|
||||
|
||||
return fname;
|
||||
return result;
|
||||
}
|
||||
|
||||
static Bool hasProperty(FcPattern * pattern, const char *property)
|
||||
@@ -92,6 +95,7 @@ static Bool hasPropertyWithStringValue(FcPattern * pattern, const char *object,
|
||||
static char *makeFontOfSize(const char *font, int size, const char *fallback)
|
||||
{
|
||||
FcPattern *pattern;
|
||||
char *name;
|
||||
char *result;
|
||||
|
||||
if (font[0] == '-') {
|
||||
@@ -115,7 +119,9 @@ static char *makeFontOfSize(const char *font, int size, const char *fallback)
|
||||
|
||||
/*FcPatternPrint(pattern); */
|
||||
|
||||
result = (char *)FcNameUnparse(pattern);
|
||||
name = (char *)FcNameUnparse(pattern);
|
||||
result = wstrdup(name);
|
||||
free(name);
|
||||
FcPatternDestroy(pattern);
|
||||
|
||||
return result;
|
||||
@@ -421,7 +427,7 @@ WMFont *WMCopyFontWithStyle(WMScreen * scrPtr, WMFont * font, WMFontStyle style)
|
||||
name = (char *)FcNameUnparse(pattern);
|
||||
copy = WMCreateFont(scrPtr, name);
|
||||
FcPatternDestroy(pattern);
|
||||
wfree(name);
|
||||
free(name);
|
||||
|
||||
return copy;
|
||||
}
|
||||
+4
-4
@@ -535,7 +535,7 @@ static void listFamilies(WMScreen * scr, WMFontPanel * panel)
|
||||
if (pat)
|
||||
FcPatternDestroy(pat);
|
||||
|
||||
families = WMCreateHashTable(WMStringPointerHashCallbacks);
|
||||
families = WMCreateStringHashTable();
|
||||
|
||||
if (fs) {
|
||||
for (i = 0; i < fs->nfont; i++) {
|
||||
@@ -558,7 +558,7 @@ static void listFamilies(WMScreen * scr, WMFontPanel * panel)
|
||||
WMListItem *item;
|
||||
|
||||
WM_ITERATE_ARRAY(array, fam, i) {
|
||||
wstrlcpy(buffer, fam->name, sizeof(buffer));
|
||||
strlcpy(buffer, fam->name, sizeof(buffer));
|
||||
item = WMAddListItem(panel->famLs, buffer);
|
||||
|
||||
item->clientData = fam;
|
||||
@@ -640,7 +640,7 @@ static void familyClick(WMWidget * w, void *data)
|
||||
int top = 0;
|
||||
WMListItem *fitem;
|
||||
|
||||
wstrlcpy(buffer, face->typeface, sizeof(buffer));
|
||||
strlcpy(buffer, face->typeface, sizeof(buffer));
|
||||
if (strcasecmp(face->typeface, "Roman") == 0)
|
||||
top = 1;
|
||||
if (strcasecmp(face->typeface, "Regular") == 0)
|
||||
@@ -773,7 +773,7 @@ static void setFontPanelFontName(FontPanel * panel, const char *family, const ch
|
||||
int top = 0;
|
||||
WMListItem *fitem;
|
||||
|
||||
wstrlcpy(buffer, face->typeface, sizeof(buffer));
|
||||
strlcpy(buffer, face->typeface, sizeof(buffer));
|
||||
if (strcasecmp(face->typeface, "Roman") == 0)
|
||||
top = 1;
|
||||
if (top)
|
||||
|
||||
+2
-3
@@ -610,10 +610,9 @@ WMScreen *WMCreateScreenWithRContext(Display * display, int screen, RContext * c
|
||||
assert(W_ApplicationInitialized());
|
||||
}
|
||||
|
||||
scrPtr = malloc(sizeof(W_Screen));
|
||||
scrPtr = wmalloc(sizeof(W_Screen));
|
||||
if (!scrPtr)
|
||||
return NULL;
|
||||
memset(scrPtr, 0, sizeof(W_Screen));
|
||||
|
||||
scrPtr->aflags.hasAppIcon = 1;
|
||||
|
||||
@@ -630,7 +629,7 @@ WMScreen *WMCreateScreenWithRContext(Display * display, int screen, RContext * c
|
||||
|
||||
scrPtr->rootWin = RootWindow(display, screen);
|
||||
|
||||
scrPtr->fontCache = WMCreateHashTable(WMStringPointerHashCallbacks);
|
||||
scrPtr->fontCache = WMCreateStringHashTable();
|
||||
|
||||
scrPtr->xftdraw = XftDrawCreate(scrPtr->display, W_DRAWABLE(scrPtr), scrPtr->visual, scrPtr->colormap);
|
||||
|
||||
|
||||
@@ -166,16 +166,6 @@ typedef struct W_Text {
|
||||
WMArray *xdndDestinationTypes;
|
||||
} Text;
|
||||
|
||||
/* not used */
|
||||
#if 0
|
||||
#define NOTIFY(T,C,N,A) {\
|
||||
WMNotification *notif = WMCreateNotification(N,T,A);\
|
||||
if ((T)->delegate && (T)->delegate->C)\
|
||||
(*(T)->delegate->C)((T)->delegate,notif);\
|
||||
WMPostNotification(notif);\
|
||||
WMReleaseNotification(notif);}
|
||||
#endif
|
||||
|
||||
#define TYPETEXT 0
|
||||
|
||||
#if 0
|
||||
|
||||
+41
-32
@@ -68,12 +68,6 @@ typedef struct W_TextField {
|
||||
} flags;
|
||||
} TextField;
|
||||
|
||||
#define NOTIFY(T,C,N,A) { WMNotification *notif = WMCreateNotification(N,T,A);\
|
||||
if ((T)->delegate && (T)->delegate->C)\
|
||||
(*(T)->delegate->C)((T)->delegate,notif);\
|
||||
WMPostNotification(notif);\
|
||||
WMReleaseNotification(notif);}
|
||||
|
||||
#define MIN_TEXT_BUFFER 2
|
||||
#define TEXT_BUFFER_INCR 8
|
||||
|
||||
@@ -404,7 +398,7 @@ void WMInsertTextFieldText(WMTextField * tPtr, const char *text, int position)
|
||||
|
||||
if (position < 0 || position >= tPtr->textLen) {
|
||||
/* append the text at the end */
|
||||
wstrlcat(tPtr->text, text, tPtr->bufferSize);
|
||||
strlcat(tPtr->text, text, tPtr->bufferSize);
|
||||
tPtr->textLen += len;
|
||||
tPtr->cursorPosition += len;
|
||||
incrToFit(tPtr);
|
||||
@@ -473,7 +467,7 @@ void WMSetTextFieldText(WMTextField * tPtr, const char *text)
|
||||
tPtr->bufferSize = tPtr->textLen + TEXT_BUFFER_INCR;
|
||||
tPtr->text = wrealloc(tPtr->text, tPtr->bufferSize);
|
||||
}
|
||||
wstrlcpy(tPtr->text, text, tPtr->bufferSize);
|
||||
strlcpy(tPtr->text, text, tPtr->bufferSize);
|
||||
}
|
||||
|
||||
tPtr->cursorPosition = tPtr->selection.position = tPtr->textLen;
|
||||
@@ -906,7 +900,10 @@ static void handleEvents(XEvent * event, void *data)
|
||||
|
||||
paintTextField(tPtr);
|
||||
|
||||
NOTIFY(tPtr, didBeginEditing, WMTextDidBeginEditingNotification, NULL);
|
||||
if (tPtr->delegate && tPtr->delegate->didBeginEditing) {
|
||||
(*tPtr->delegate->didBeginEditing)(tPtr->delegate, 0);
|
||||
}
|
||||
WMPostNotificationName(WMTextDidBeginEditingNotification, tPtr, NULL);
|
||||
|
||||
tPtr->flags.notIllegalMovement = 0;
|
||||
break;
|
||||
@@ -921,8 +918,10 @@ static void handleEvents(XEvent * event, void *data)
|
||||
|
||||
paintTextField(tPtr);
|
||||
if (!tPtr->flags.notIllegalMovement) {
|
||||
NOTIFY(tPtr, didEndEditing, WMTextDidEndEditingNotification,
|
||||
(void *)WMIllegalTextMovement);
|
||||
if (tPtr->delegate && tPtr->delegate->didEndEditing) {
|
||||
(*tPtr->delegate->didEndEditing)(tPtr->delegate, WMIllegalTextMovement);
|
||||
}
|
||||
WMPostNotificationName(WMTextDidEndEditingNotification, tPtr, (void *)WMIllegalTextMovement);
|
||||
}
|
||||
break;
|
||||
|
||||
@@ -943,7 +942,8 @@ static void handleTextFieldKeyPress(TextField * tPtr, XEvent * event)
|
||||
char buffer[64];
|
||||
KeySym ksym;
|
||||
const char *textEvent = NULL;
|
||||
void *data = NULL;
|
||||
WMTextMovementType movement_type;
|
||||
WMTextFieldSpecialEventType special_field_event_type;
|
||||
int count, refresh = 0;
|
||||
int control_pressed = 0;
|
||||
int cancelSelection = 1;
|
||||
@@ -975,14 +975,14 @@ static void handleTextFieldKeyPress(TextField * tPtr, XEvent * event)
|
||||
tPtr->view->prevFocusChain);
|
||||
tPtr->flags.notIllegalMovement = 1;
|
||||
}
|
||||
data = (void *)WMBacktabTextMovement;
|
||||
movement_type = WMBacktabTextMovement;
|
||||
} else {
|
||||
if (tPtr->view->nextFocusChain) {
|
||||
W_SetFocusOfTopLevel(W_TopLevelOfView(tPtr->view),
|
||||
tPtr->view->nextFocusChain);
|
||||
tPtr->flags.notIllegalMovement = 1;
|
||||
}
|
||||
data = (void *)WMTabTextMovement;
|
||||
movement_type = WMTabTextMovement;
|
||||
}
|
||||
textEvent = WMTextDidEndEditingNotification;
|
||||
|
||||
@@ -994,7 +994,7 @@ static void handleTextFieldKeyPress(TextField * tPtr, XEvent * event)
|
||||
|
||||
case XK_Escape:
|
||||
if (!modified) {
|
||||
data = (void *)WMEscapeTextMovement;
|
||||
movement_type = WMEscapeTextMovement;
|
||||
textEvent = WMTextDidEndEditingNotification;
|
||||
|
||||
relay = False;
|
||||
@@ -1008,7 +1008,7 @@ static void handleTextFieldKeyPress(TextField * tPtr, XEvent * event)
|
||||
/* FALLTHRU */
|
||||
case XK_Return:
|
||||
if (!modified) {
|
||||
data = (void *)WMReturnTextMovement;
|
||||
movement_type = WMReturnTextMovement;
|
||||
textEvent = WMTextDidEndEditingNotification;
|
||||
|
||||
relay = False;
|
||||
@@ -1165,7 +1165,7 @@ static void handleTextFieldKeyPress(TextField * tPtr, XEvent * event)
|
||||
if (!modified) {
|
||||
if (tPtr->selection.count) {
|
||||
WMDeleteTextFieldRange(tPtr, tPtr->selection);
|
||||
data = (void *)WMDeleteTextEvent;
|
||||
special_field_event_type = WMDeleteTextEvent;
|
||||
textEvent = WMTextDidChangeNotification;
|
||||
} else if (tPtr->cursorPosition > 0) {
|
||||
int i = oneUTF8CharBackward(&tPtr->text[tPtr->cursorPosition],
|
||||
@@ -1174,7 +1174,7 @@ static void handleTextFieldKeyPress(TextField * tPtr, XEvent * event)
|
||||
range.position = tPtr->cursorPosition + i;
|
||||
range.count = -i;
|
||||
WMDeleteTextFieldRange(tPtr, range);
|
||||
data = (void *)WMDeleteTextEvent;
|
||||
special_field_event_type = WMDeleteTextEvent;
|
||||
textEvent = WMTextDidChangeNotification;
|
||||
}
|
||||
|
||||
@@ -1197,7 +1197,7 @@ static void handleTextFieldKeyPress(TextField * tPtr, XEvent * event)
|
||||
if (!modified) {
|
||||
if (tPtr->selection.count) {
|
||||
WMDeleteTextFieldRange(tPtr, tPtr->selection);
|
||||
data = (void *)WMDeleteTextEvent;
|
||||
special_field_event_type = WMDeleteTextEvent;
|
||||
textEvent = WMTextDidChangeNotification;
|
||||
} else if (tPtr->cursorPosition < tPtr->textLen) {
|
||||
WMRange range;
|
||||
@@ -1205,7 +1205,7 @@ static void handleTextFieldKeyPress(TextField * tPtr, XEvent * event)
|
||||
range.count = oneUTF8CharForward(&tPtr->text[tPtr->cursorPosition],
|
||||
tPtr->textLen - tPtr->cursorPosition);
|
||||
WMDeleteTextFieldRange(tPtr, range);
|
||||
data = (void *)WMDeleteTextEvent;
|
||||
special_field_event_type = WMDeleteTextEvent;
|
||||
textEvent = WMTextDidChangeNotification;
|
||||
}
|
||||
|
||||
@@ -1220,7 +1220,7 @@ static void handleTextFieldKeyPress(TextField * tPtr, XEvent * event)
|
||||
if (tPtr->selection.count)
|
||||
WMDeleteTextFieldRange(tPtr, tPtr->selection);
|
||||
WMInsertTextFieldText(tPtr, buffer, tPtr->cursorPosition);
|
||||
data = (void *)WMInsertTextEvent;
|
||||
special_field_event_type = WMInsertTextEvent;
|
||||
textEvent = WMTextDidChangeNotification;
|
||||
|
||||
relay = False;
|
||||
@@ -1255,21 +1255,22 @@ static void handleTextFieldKeyPress(TextField * tPtr, XEvent * event)
|
||||
/*printf("(%d,%d)\n", tPtr->selection.position, tPtr->selection.count); */
|
||||
|
||||
if (textEvent) {
|
||||
WMNotification *notif = WMCreateNotification(textEvent, tPtr, data);
|
||||
|
||||
if (tPtr->delegate) {
|
||||
if (textEvent == WMTextDidBeginEditingNotification && tPtr->delegate->didBeginEditing)
|
||||
(*tPtr->delegate->didBeginEditing) (tPtr->delegate, notif);
|
||||
(*tPtr->delegate->didBeginEditing) (tPtr->delegate, movement_type);
|
||||
|
||||
else if (textEvent == WMTextDidEndEditingNotification && tPtr->delegate->didEndEditing)
|
||||
(*tPtr->delegate->didEndEditing) (tPtr->delegate, notif);
|
||||
(*tPtr->delegate->didEndEditing) (tPtr->delegate, movement_type);
|
||||
|
||||
else if (textEvent == WMTextDidChangeNotification && tPtr->delegate->didChange)
|
||||
(*tPtr->delegate->didChange) (tPtr->delegate, notif);
|
||||
(*tPtr->delegate->didChange) (tPtr->delegate, special_field_event_type);
|
||||
}
|
||||
|
||||
WMPostNotification(notif);
|
||||
WMReleaseNotification(notif);
|
||||
if (textEvent == WMTextDidBeginEditingNotification || textEvent == WMTextDidEndEditingNotification) {
|
||||
WMPostNotificationName(textEvent, tPtr, (void *)movement_type);
|
||||
} else if (textEvent == WMTextDidChangeNotification) {
|
||||
WMPostNotificationName(textEvent, tPtr, (void *)special_field_event_type);
|
||||
}
|
||||
}
|
||||
|
||||
if (refresh)
|
||||
@@ -1345,7 +1346,10 @@ static void pasteText(WMView * view, Atom selection, Atom target, Time timestamp
|
||||
str = (char *)WMDataBytes(data);
|
||||
|
||||
WMInsertTextFieldText(tPtr, str, tPtr->cursorPosition);
|
||||
NOTIFY(tPtr, didChange, WMTextDidChangeNotification, (void *)WMInsertTextEvent);
|
||||
if (tPtr->delegate && tPtr->delegate->didChange) {
|
||||
(*tPtr->delegate->didChange)(tPtr->delegate, WMInsertTextEvent);
|
||||
}
|
||||
WMPostNotificationName(WMTextDidChangeNotification, tPtr, (void *)WMInsertTextEvent);
|
||||
} else {
|
||||
int n;
|
||||
|
||||
@@ -1355,7 +1359,10 @@ static void pasteText(WMView * view, Atom selection, Atom target, Time timestamp
|
||||
str[n] = 0;
|
||||
WMInsertTextFieldText(tPtr, str, tPtr->cursorPosition);
|
||||
XFree(str);
|
||||
NOTIFY(tPtr, didChange, WMTextDidChangeNotification, (void *)WMInsertTextEvent);
|
||||
if (tPtr->delegate && tPtr->delegate->didChange) {
|
||||
(*tPtr->delegate->didChange)(tPtr->delegate, WMInsertTextEvent);
|
||||
}
|
||||
WMPostNotificationName(WMTextDidChangeNotification, tPtr, (void *)WMInsertTextEvent);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1477,8 +1484,10 @@ static void handleTextFieldActionEvents(XEvent * event, void *data)
|
||||
text[n] = 0;
|
||||
WMInsertTextFieldText(tPtr, text, tPtr->cursorPosition);
|
||||
XFree(text);
|
||||
NOTIFY(tPtr, didChange, WMTextDidChangeNotification,
|
||||
(void *)WMInsertTextEvent);
|
||||
if (tPtr->delegate && tPtr->delegate->didChange) {
|
||||
(*tPtr->delegate->didChange)(tPtr->delegate, WMInsertTextEvent);
|
||||
}
|
||||
WMPostNotificationName(WMTextDidChangeNotification, tPtr, (void *)WMInsertTextEvent);
|
||||
}
|
||||
} else {
|
||||
tPtr->flags.waitingSelection = 1;
|
||||
|
||||
@@ -1110,7 +1110,7 @@ static void deleteTexture(WMWidget * w, void *data)
|
||||
static void extractTexture(WMWidget * w, void *data)
|
||||
{
|
||||
_Panel *panel = (_Panel *) data;
|
||||
char *path;
|
||||
char *path, *homedir;
|
||||
WMOpenPanel *opanel;
|
||||
WMScreen *scr = WMWidgetScreen(w);
|
||||
|
||||
@@ -1118,13 +1118,17 @@ static void extractTexture(WMWidget * w, void *data)
|
||||
WMSetFilePanelCanChooseDirectories(opanel, False);
|
||||
WMSetFilePanelCanChooseFiles(opanel, True);
|
||||
|
||||
if (WMRunModalFilePanelForDirectory(opanel, panel->parent, wgethomedir(), _("Select File"), NULL)) {
|
||||
homedir = wgethomedir();
|
||||
if (WMRunModalFilePanelForDirectory(opanel, panel->parent, homedir, _("Select File"), NULL)) {
|
||||
path = WMGetFilePanelFileName(opanel);
|
||||
|
||||
OpenExtractPanelFor(panel);
|
||||
|
||||
wfree(path);
|
||||
}
|
||||
if (homedir) {
|
||||
wfree(homedir);
|
||||
}
|
||||
}
|
||||
|
||||
static void changePage(WMWidget * w, void *data)
|
||||
@@ -2224,7 +2228,7 @@ static void prepareForClose(_Panel * panel)
|
||||
WMUserDefaults *udb = WMGetStandardUserDefaults();
|
||||
int i;
|
||||
|
||||
textureList = WMCreatePLArray(NULL, NULL);
|
||||
textureList = WMCreateEmptyPLArray();
|
||||
|
||||
/* store list of textures */
|
||||
for (i = 8; i < WMGetListNumberOfRows(panel->texLs); i++) {
|
||||
@@ -2246,7 +2250,7 @@ static void prepareForClose(_Panel * panel)
|
||||
WMReleasePropList(textureList);
|
||||
|
||||
/* store list of colors */
|
||||
textureList = WMCreatePLArray(NULL, NULL);
|
||||
textureList = WMCreateEmptyPLArray();
|
||||
for (i = 0; i < wlengthof(sample_colors); i++) {
|
||||
WMColor *color;
|
||||
char *str;
|
||||
|
||||
+1
-1
@@ -129,7 +129,7 @@ static void autoDelayChanged(void *observerData, WMNotification *notification)
|
||||
}
|
||||
char *value = WMGetTextFieldText(anAutoDelayT);
|
||||
adjustButtonSelectionBasedOnValue(panel, row, value);
|
||||
free(value);
|
||||
wfree(value);
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
+1
-1
@@ -138,7 +138,7 @@ static void storeData(_Panel * panel)
|
||||
if (sscanf(str, "%i", &i) != 1)
|
||||
i = 0;
|
||||
SetIntegerForKey(i, "RaiseDelay");
|
||||
free(str);
|
||||
wfree(str);
|
||||
|
||||
SetBoolForKey(WMGetButtonSelected(panel->ignB), "IgnoreFocusClick");
|
||||
SetBoolForKey(WMGetButtonSelected(panel->newB), "AutoFocus");
|
||||
|
||||
@@ -288,6 +288,7 @@ static char *getSelectedFont(_Panel * panel, FcChar8 * curfont)
|
||||
WMListItem *item;
|
||||
FcPattern *pat;
|
||||
char *name;
|
||||
char *result;
|
||||
|
||||
if (curfont)
|
||||
pat = FcNameParse(curfont);
|
||||
@@ -321,9 +322,12 @@ static char *getSelectedFont(_Panel * panel, FcChar8 * curfont)
|
||||
}
|
||||
|
||||
name = (char *)FcNameUnparse(pat);
|
||||
result = wstrdup(name);
|
||||
free(name);
|
||||
FcPatternDestroy(pat);
|
||||
|
||||
return name;
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
static void updateSampleFont(_Panel * panel)
|
||||
|
||||
@@ -147,11 +147,11 @@ static void storeData(_Panel * panel)
|
||||
if (sscanf(str, "%i", &i) != 1)
|
||||
i = 0;
|
||||
SetIntegerForKey(i, "HotCornerDelay");
|
||||
free(str);
|
||||
wfree(str);
|
||||
|
||||
SetIntegerForKey(WMGetSliderValue(panel->hceS), "HotCornerEdge");
|
||||
|
||||
list = WMCreatePLArray(NULL, NULL);
|
||||
list = WMCreateEmptyPLArray();
|
||||
for (i = 0; i < sizeof(panel->hcactionsT) / sizeof(WMTextField *); i++) {
|
||||
str = WMGetTextFieldText(panel->hcactionsT[i]);
|
||||
if (strlen(str) == 0)
|
||||
|
||||
@@ -365,7 +365,7 @@ char *capture_shortcut(Display *dpy, Bool *capturing, Bool convert_case)
|
||||
if ((numlock_mask != Mod5Mask) && (ev.xkey.state & Mod5Mask))
|
||||
strcat(buffer, "Mod5+");
|
||||
|
||||
wstrlcat(buffer, key, sizeof(buffer));
|
||||
strlcat(buffer, key, sizeof(buffer));
|
||||
|
||||
return wstrdup(buffer);
|
||||
}
|
||||
|
||||
@@ -66,6 +66,7 @@ AM_CPPFLAGS = -DRESOURCE_PATH=\"$(wpdatadir)\" -DWMAKER_RESOURCE_PATH=\"$(pkgdat
|
||||
WPrefs_DEPENDENCIES = $(top_builddir)/WINGs/libWINGs.la
|
||||
|
||||
WPrefs_LDADD = \
|
||||
$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a\
|
||||
$(top_builddir)/WINGs/libWINGs.la\
|
||||
$(top_builddir)/WINGs/libWUtil.la\
|
||||
$(top_builddir)/wrlib/libwraster.la \
|
||||
|
||||
+2
-2
@@ -203,7 +203,7 @@ static void storeData(_Panel * panel)
|
||||
int i;
|
||||
char *p;
|
||||
|
||||
list = WMCreatePLArray(NULL, NULL);
|
||||
list = WMCreateEmptyPLArray();
|
||||
for (i = 0; i < WMGetListNumberOfRows(panel->icoL); i++) {
|
||||
p = WMGetListItem(panel->icoL, i)->text;
|
||||
tmp = WMCreatePLString(p);
|
||||
@@ -211,7 +211,7 @@ static void storeData(_Panel * panel)
|
||||
}
|
||||
SetObjectForKey(list, "IconPath");
|
||||
|
||||
list = WMCreatePLArray(NULL, NULL);
|
||||
list = WMCreateEmptyPLArray();
|
||||
for (i = 0; i < WMGetListNumberOfRows(panel->pixL); i++) {
|
||||
p = WMGetListItem(panel->pixL, i)->text;
|
||||
tmp = WMCreatePLString(p);
|
||||
|
||||
@@ -627,7 +627,7 @@ static void browseImageCallback(WMWidget *w, void *data)
|
||||
WMSetFilePanelCanChooseFiles(opanel, True);
|
||||
|
||||
if (!ipath)
|
||||
ipath = wstrdup(wgethomedir());
|
||||
ipath = wgethomedir();
|
||||
|
||||
if (WMRunModalFilePanelForDirectory(opanel, panel->win, ipath, _("Open Image"), NULL)) {
|
||||
char *path, *fullpath;
|
||||
|
||||
+2
-2
@@ -705,10 +705,10 @@ static void loadConfigurations(WMScreen * scr, WMWindow * mainw)
|
||||
}
|
||||
|
||||
if (!db) {
|
||||
db = WMCreatePLDictionary(NULL, NULL);
|
||||
db = WMCreateEmptyPLDictionary();
|
||||
}
|
||||
if (!gdb) {
|
||||
gdb = WMCreatePLDictionary(NULL, NULL);
|
||||
gdb = WMCreateEmptyPLDictionary();
|
||||
}
|
||||
|
||||
GlobalDB = gdb;
|
||||
|
||||
@@ -824,18 +824,15 @@ static void stopEditItem(WEditMenu * menu, Bool apply)
|
||||
menu->flags.isEditing = 0;
|
||||
}
|
||||
|
||||
static void textEndedEditing(struct WMTextFieldDelegate *self, WMNotification * notif)
|
||||
static void textEndedEditing(struct WMTextFieldDelegate *self, WMTextMovementType reason)
|
||||
{
|
||||
WEditMenu *menu = (WEditMenu *) self->data;
|
||||
uintptr_t reason;
|
||||
int i;
|
||||
WEditMenuItem *item;
|
||||
|
||||
if (!menu->flags.isEditing)
|
||||
return;
|
||||
|
||||
reason = (uintptr_t)WMGetNotificationClientData(notif);
|
||||
|
||||
switch (reason) {
|
||||
case WMEscapeTextMovement:
|
||||
stopEditItem(menu, False);
|
||||
|
||||
+6
-11
@@ -47,14 +47,6 @@ struct {
|
||||
static pid_t DeadChildren[MAX_DEATHS];
|
||||
static int DeadChildrenCount = 0;
|
||||
|
||||
static noreturn void wAbort(Bool foo)
|
||||
{
|
||||
/* Parameter not used, but tell the compiler that it is ok */
|
||||
(void) foo;
|
||||
|
||||
exit(1);
|
||||
}
|
||||
|
||||
static void print_help(const char *progname)
|
||||
{
|
||||
printf(_("usage: %s [options]\n"), progname);
|
||||
@@ -87,8 +79,6 @@ int main(int argc, char **argv)
|
||||
int i;
|
||||
char *display_name = "";
|
||||
|
||||
wsetabort(wAbort);
|
||||
|
||||
memset(DeadHandlers, 0, sizeof(DeadHandlers));
|
||||
|
||||
WMInitializeApplication("WPrefs", &argc, argv);
|
||||
@@ -155,7 +145,12 @@ int main(int argc, char **argv)
|
||||
exit(0);
|
||||
}
|
||||
|
||||
WMPLSetCaseSensitive(False);
|
||||
/*
|
||||
* Rust rewrite note: this API surface has been removed, but we leave in
|
||||
* a record of where it was invoked to set a value other than the
|
||||
* default, in case it helps to track down bugs in the future.
|
||||
*/
|
||||
/* WMPLSetCaseSensitive(False); */
|
||||
|
||||
Initialize(scr);
|
||||
|
||||
|
||||
+17
-51
@@ -49,6 +49,17 @@ AC_CONFIG_SRCDIR([src/WindowMaker.h])
|
||||
dnl Include at the end of 'config.h', this file is generated by top-level Makefile
|
||||
AH_BOTTOM([@%:@include "config-paths.h"])
|
||||
|
||||
dnl Rust support
|
||||
AC_CHECK_PROG(CARGO, [cargo], [yes], [no])
|
||||
AS_IF(test x$CARGO = xno,
|
||||
AC_MSG_ERROR([cargo is required. Please set the CARGO environment variable or install the Rust toolchain from https://www.rust-lang.org/])
|
||||
)
|
||||
AC_SUBST(CARGO, [cargo])
|
||||
AC_CHECK_PROG(RUSTC, [rustc], [yes], [no])
|
||||
AS_IF(test x$RUSTC = xno,
|
||||
AC_MSG_ERROR([rustc is required. Please set the RUSTC environment variable or install the Rust toolchain from https://www.rust-lang.org/])
|
||||
)
|
||||
AC_SUBST(RUSTC, [rustc])
|
||||
|
||||
dnl libtool library versioning
|
||||
dnl ==========================
|
||||
@@ -342,24 +353,6 @@ AS_IF([test "x$enable_mwm_hints" = "xno"],
|
||||
AM_CONDITIONAL([USE_MWM_HINTS], [test "x$enable_mwm_hints" != "xno"])
|
||||
|
||||
|
||||
dnl Boehm GC
|
||||
dnl ========
|
||||
m4_divert_push([INIT_PREPARE])dnl
|
||||
AC_ARG_ENABLE([boehm-gc],
|
||||
[AS_HELP_STRING([--enable-boehm-gc], [use Boehm GC instead of the default libc malloc() [default=no]])],
|
||||
[AS_CASE(["$enableval"],
|
||||
[yes], [with_boehm_gc=yes],
|
||||
[no], [with_boehm_gc=no],
|
||||
[AC_MSG_ERROR([bad value $enableval for --enable-boehm-gc])] )],
|
||||
[with_boehm_gc=no])
|
||||
m4_divert_pop([INIT_PREPARE])dnl
|
||||
|
||||
AS_IF([test "x$with_boehm_gc" = "xyes"],
|
||||
AC_SEARCH_LIBS([GC_malloc], [gc],
|
||||
[AC_DEFINE(USE_BOEHM_GC, 1, [Define if Boehm GC is to be used])],
|
||||
[AC_MSG_FAILURE([--enable-boehm-gc specified but test for libgc failed])]))
|
||||
|
||||
|
||||
dnl LCOV
|
||||
dnl ====
|
||||
m4_divert_push([INIT_PREPARE])dnl
|
||||
@@ -398,39 +391,6 @@ dnl the flag 'O_NOFOLLOW' for 'open' is used in WINGs
|
||||
WM_FUNC_OPEN_NOFOLLOW
|
||||
|
||||
|
||||
dnl Check for strlcat/strlcpy
|
||||
dnl =========================
|
||||
m4_divert_push([INIT_PREPARE])dnl
|
||||
AC_ARG_WITH([libbsd],
|
||||
[AS_HELP_STRING([--without-libbsd], [do not use libbsd for strlcat and strlcpy [default=check]])],
|
||||
[AS_IF([test "x$with_libbsd" != "xno"],
|
||||
[with_libbsd=bsd],
|
||||
[with_libbsd=]
|
||||
)],
|
||||
[with_libbsd=bsd])
|
||||
m4_divert_pop([INIT_PREPARE])dnl
|
||||
|
||||
tmp_libs=$LIBS
|
||||
AC_SEARCH_LIBS([strlcat],[$with_libbsd],
|
||||
[AC_DEFINE(HAVE_STRLCAT, 1, [Define if strlcat is available])],
|
||||
[],
|
||||
[]
|
||||
)
|
||||
AC_SEARCH_LIBS([strlcpy],[$with_libbsd],
|
||||
[AC_DEFINE(HAVE_STRLCAT, 1, [Define if strlcpy is available])],
|
||||
[],
|
||||
[]
|
||||
)
|
||||
LIBS=$tmp_libs
|
||||
|
||||
LIBBSD=
|
||||
AS_IF([test "x$ac_cv_search_strlcat" = "x-lbsd" -o "x$ac_cv_search_strlcpy" = "x-lbsd"],
|
||||
[LIBBSD=-lbsd
|
||||
AC_CHECK_HEADERS([bsd/string.h])]
|
||||
)
|
||||
AC_SUBST(LIBBSD)
|
||||
|
||||
|
||||
dnl Check for OpenBSD kernel memory interface - kvm(3)
|
||||
dnl ==================================================
|
||||
AS_IF([test "x$WM_OSDEP" = "xbsd"],
|
||||
@@ -964,11 +924,17 @@ AC_CONFIG_FILES(
|
||||
wrlib/Makefile wrlib/po/Makefile
|
||||
wrlib/tests/Makefile
|
||||
|
||||
dnl Rust implementation of WINGs libraries
|
||||
wutil-rs/Makefile
|
||||
|
||||
dnl WINGs toolkit
|
||||
WINGs/Makefile WINGs/WINGs/Makefile WINGs/po/Makefile
|
||||
WINGs/Documentation/Makefile WINGs/Resources/Makefile WINGs/Extras/Makefile
|
||||
WINGs/Examples/Makefile WINGs/Tests/Makefile
|
||||
|
||||
dnl Rust implementation of Window Maker core
|
||||
wmaker-rs/Makefile
|
||||
|
||||
dnl Window Maker's core
|
||||
src/Makefile src/wconfig.h po/Makefile
|
||||
doc/Makefile doc/build/Makefile
|
||||
|
||||
Vendored
-10
@@ -253,14 +253,6 @@ If found, then the library @emph{WRaster} can use the @emph{ImageMagick} library
|
||||
@sc{Window Maker} support more image formats, like @emph{SVG}, @emph{BMP}, @emph{TGA}, ...
|
||||
You can get it from @uref{http://www.imagemagick.org/}
|
||||
|
||||
@item @emph{Boehm GC}
|
||||
|
||||
This library can be used by the @emph{WINGs} utility toolkit to use a
|
||||
@cite{Boehm-Demers-Weiser Garbage Collector} instead of the traditional
|
||||
@command{malloc}/@command{free} functions from the @emph{libc}.
|
||||
You have to explicitly ask for its support though (@pxref{Configure Options}).
|
||||
You can get it from @uref{http://www.hboehm.info/gc/}
|
||||
|
||||
@end itemize
|
||||
|
||||
|
||||
@@ -468,8 +460,6 @@ You can find more information about the libraries in the
|
||||
@ref{Optional Dependencies}.
|
||||
|
||||
@table @option
|
||||
@item --enable-boehm-gc
|
||||
Never enabled by default, use Boehm GC instead of the default @emph{libc} @command{malloc()}
|
||||
|
||||
@item --disable-gif
|
||||
Disable GIF support in @emph{WRaster} library; when enabled use @file{libgif} or @file{libungif}.
|
||||
|
||||
+3
-8
@@ -6,13 +6,7 @@ bin_PROGRAMS = wmaker
|
||||
|
||||
EXTRA_DIST =
|
||||
|
||||
wmakerlib = $(top_builddir)/wmakerlib/target/debug/libwmakerlib.a
|
||||
|
||||
$(wmakerlib):
|
||||
@(cd $(top_builddir)/wmakerlib && cargo build)
|
||||
|
||||
wmaker_SOURCES = \
|
||||
$(wmakerlib) \
|
||||
GNUstep.h \
|
||||
WindowMaker.h \
|
||||
actions.c \
|
||||
@@ -140,7 +134,7 @@ else
|
||||
nodist_wmaker_SOURCES = misc.hack_nf.c \
|
||||
xmodifier.hack_nf.c
|
||||
|
||||
CLEANFILES = $(nodist_wmaker_SOURCES) ../wmakerlib/target
|
||||
CLEANFILES = $(nodist_wmaker_SOURCES)
|
||||
|
||||
misc.hack_nf.c: misc.c $(top_srcdir)/script/nested-func-to-macro.sh
|
||||
$(AM_V_GEN)$(top_srcdir)/script/nested-func-to-macro.sh \
|
||||
@@ -166,7 +160,8 @@ wmaker_LDADD = \
|
||||
$(top_builddir)/WINGs/libWINGs.la\
|
||||
$(top_builddir)/WINGs/libWUtil.la\
|
||||
$(top_builddir)/wrlib/libwraster.la\
|
||||
$(wmakerlib)\
|
||||
$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a\
|
||||
$(top_builddir)/wmaker-rs/target/debug/libwmaker_rs.a\
|
||||
@XLFLAGS@ \
|
||||
@LIBXRANDR@ \
|
||||
@LIBXINERAMA@ \
|
||||
|
||||
+1
-1
@@ -1360,7 +1360,7 @@ static void wApplicationSaveIconPathFor(const char *iconPath, const char *wm_ins
|
||||
val = WMGetFromPLDictionary(adict, iconk);
|
||||
} else {
|
||||
/* no dictionary for app, so create one */
|
||||
adict = WMCreatePLDictionary(NULL, NULL);
|
||||
adict = WMCreateEmptyPLDictionary();
|
||||
WMPutInPLDictionary(dict, key, adict);
|
||||
WMReleasePropList(adict);
|
||||
val = NULL;
|
||||
|
||||
+6
-6
@@ -94,7 +94,7 @@ static WMenu *parseMenuCommand(WScreen * scr, Window win, char **slist, int coun
|
||||
wwarning(_("appmenu: bad menu entry \"%s\" in window %lx"), slist[*index], win);
|
||||
return NULL;
|
||||
}
|
||||
if (wstrlcpy(title, &slist[*index][pos], sizeof(title)) >= sizeof(title)) {
|
||||
if (strlcpy(title, &slist[*index][pos], sizeof(title)) >= sizeof(title)) {
|
||||
wwarning(_("appmenu: menu command size exceeded in window %lx"), win);
|
||||
return NULL;
|
||||
}
|
||||
@@ -127,7 +127,7 @@ static WMenu *parseMenuCommand(WScreen * scr, Window win, char **slist, int coun
|
||||
slist[*index], win);
|
||||
return NULL;
|
||||
}
|
||||
wstrlcpy(title, &slist[*index][pos], sizeof(title));
|
||||
strlcpy(title, &slist[*index][pos], sizeof(title));
|
||||
rtext[0] = 0;
|
||||
} else {
|
||||
if (sscanf(slist[*index], "%i %i %i %i %s %n",
|
||||
@@ -137,9 +137,9 @@ static WMenu *parseMenuCommand(WScreen * scr, Window win, char **slist, int coun
|
||||
slist[*index], win);
|
||||
return NULL;
|
||||
}
|
||||
wstrlcpy(title, &slist[*index][pos], sizeof(title));
|
||||
strlcpy(title, &slist[*index][pos], sizeof(title));
|
||||
}
|
||||
data = malloc(sizeof(WAppMenuData));
|
||||
data = wmalloc(sizeof(WAppMenuData));
|
||||
if (data == NULL) {
|
||||
wwarning(_("appmenu: out of memory creating menu for window %lx"), win);
|
||||
wMenuDestroy(menu, True);
|
||||
@@ -152,7 +152,7 @@ static WMenu *parseMenuCommand(WScreen * scr, Window win, char **slist, int coun
|
||||
if (!entry) {
|
||||
wMenuDestroy(menu, True);
|
||||
wwarning(_("appmenu: out of memory creating menu for window %lx"), win);
|
||||
free(data);
|
||||
wfree(data);
|
||||
return NULL;
|
||||
}
|
||||
if (rtext[0] != 0)
|
||||
@@ -174,7 +174,7 @@ static WMenu *parseMenuCommand(WScreen * scr, Window win, char **slist, int coun
|
||||
|
||||
return NULL;
|
||||
}
|
||||
wstrlcpy(title, &slist[*index][pos], sizeof(title));
|
||||
strlcpy(title, &slist[*index][pos], sizeof(title));
|
||||
*index += 1;
|
||||
|
||||
submenu = parseMenuCommand(scr, win, slist, count, index);
|
||||
|
||||
+2
-2
@@ -307,7 +307,7 @@ void wClientCheckProperty(WWindow * wwin, XPropertyEvent * event)
|
||||
wWindowUpdateName(wwin, tmp);
|
||||
}
|
||||
if (tmp)
|
||||
XFree(tmp);
|
||||
wfree(tmp);
|
||||
}
|
||||
break;
|
||||
|
||||
@@ -616,7 +616,7 @@ void wClientCheckProperty(WWindow * wwin, XPropertyEvent * event)
|
||||
|
||||
wWindowUpdateGNUstepAttr(wwin, attr);
|
||||
|
||||
XFree(attr);
|
||||
wfree(attr);
|
||||
} else {
|
||||
wNETWMCheckClientHintChange(wwin, event);
|
||||
}
|
||||
|
||||
+7
-2
@@ -862,7 +862,12 @@ static void initDefaults(void)
|
||||
unsigned int i;
|
||||
WDefaultEntry *entry;
|
||||
|
||||
WMPLSetCaseSensitive(False);
|
||||
/*
|
||||
* Rust rewrite note: this API surface has been removed, but we leave in
|
||||
* a record of where it was invoked to set a value other than the
|
||||
* default, in case it helps to track down bugs in the future.
|
||||
*/
|
||||
/* WMPLSetCaseSensitive(False); */
|
||||
|
||||
for (i = 0; i < wlengthof(optionList); i++) {
|
||||
entry = &optionList[i];
|
||||
@@ -2200,7 +2205,7 @@ static int getKeybind(WScreen * scr, WDefaultEntry * entry, WMPropList * value,
|
||||
return True;
|
||||
}
|
||||
|
||||
wstrlcpy(buf, val, MAX_SHORTCUT_LENGTH);
|
||||
strlcpy(buf, val, MAX_SHORTCUT_LENGTH);
|
||||
|
||||
b = (char *)buf;
|
||||
|
||||
|
||||
+7
-36
@@ -39,10 +39,6 @@
|
||||
#include <time.h>
|
||||
#include <sys/utsname.h>
|
||||
|
||||
#ifdef HAVE_MALLOC_H
|
||||
#include <malloc.h>
|
||||
#endif
|
||||
|
||||
#include <signal.h>
|
||||
#ifdef __FreeBSD__
|
||||
#include <sys/signal.h>
|
||||
@@ -250,7 +246,7 @@ static void SaveHistory(WMArray * history, const char *filename)
|
||||
int i;
|
||||
WMPropList *plhistory;
|
||||
|
||||
plhistory = WMCreatePLArray(NULL);
|
||||
plhistory = WMCreateEmptyPLArray();
|
||||
|
||||
for (i = 0; i < WMGetArrayItemCount(history); ++i)
|
||||
WMAddToPLArray(plhistory, WMCreatePLString(WMGetFromArray(history, i)));
|
||||
@@ -367,7 +363,7 @@ static void handleHistoryKeyPress(XEvent * event, void *clientData)
|
||||
case XK_Up:
|
||||
if (p->histpos < WMGetArrayItemCount(p->history) - 1) {
|
||||
if (p->histpos == 0)
|
||||
wfree(WMReplaceInArray(p->history, 0, WMGetTextFieldText(p->panel->text)));
|
||||
wfree(WMSetInArray(p->history, 0, WMGetTextFieldText(p->panel->text)));
|
||||
p->histpos++;
|
||||
WMSetTextFieldText(p->panel->text, WMGetFromArray(p->history, p->histpos));
|
||||
}
|
||||
@@ -468,7 +464,7 @@ int wAdvancedInputDialog(WScreen *scr, const char *title, const char *message, c
|
||||
|
||||
if (p->panel->result == WAPRDefault) {
|
||||
result = WMGetTextFieldText(p->panel->text);
|
||||
wfree(WMReplaceInArray(p->history, 0, wstrdup(result)));
|
||||
wfree(WMSetInArray(p->history, 0, wstrdup(result)));
|
||||
SaveHistory(p->history, filename);
|
||||
} else
|
||||
result = NULL;
|
||||
@@ -609,9 +605,9 @@ static void listPixmaps(WScreen *scr, WMList *lPtr, const char *path)
|
||||
if (strcmp(dentry->d_name, ".") == 0 || strcmp(dentry->d_name, "..") == 0)
|
||||
continue;
|
||||
|
||||
if (wstrlcpy(pbuf, apath, sizeof(pbuf)) >= sizeof(pbuf) ||
|
||||
wstrlcat(pbuf, "/", sizeof(pbuf)) >= sizeof(pbuf) ||
|
||||
wstrlcat(pbuf, dentry->d_name, sizeof(pbuf)) >= sizeof(pbuf)) {
|
||||
if (strlcpy(pbuf, apath, sizeof(pbuf)) >= sizeof(pbuf) ||
|
||||
strlcat(pbuf, "/", sizeof(pbuf)) >= sizeof(pbuf) ||
|
||||
strlcat(pbuf, dentry->d_name, sizeof(pbuf)) >= sizeof(pbuf)) {
|
||||
wwarning(_("full path for file \"%s\" in \"%s\" is longer than %d bytes, skipped"),
|
||||
dentry->d_name, path, (int) (sizeof(pbuf) - 1) );
|
||||
continue;
|
||||
@@ -1361,7 +1357,7 @@ void wShowInfoPanel(WScreen *scr)
|
||||
char *posn = getPrettyOSName();
|
||||
if (posn) {
|
||||
snprintf(buffer, sizeof(buffer), _("Running on: %s (%s)\n"), posn, uts.machine);
|
||||
free(posn);
|
||||
wfree(posn);
|
||||
}
|
||||
else
|
||||
snprintf(buffer, sizeof(buffer), _("Running on: %s (%s)\n"), uts.sysname, uts.machine);
|
||||
@@ -1393,31 +1389,6 @@ void wShowInfoPanel(WScreen *scr)
|
||||
break;
|
||||
}
|
||||
|
||||
#if defined(HAVE_MALLOC_H) && defined(HAVE_MALLINFO2)
|
||||
{
|
||||
struct mallinfo2 ma = mallinfo2();
|
||||
snprintf(buffer, sizeof(buffer),
|
||||
#ifdef DEBUG
|
||||
_("Total memory allocated: %lu kB (in use: %lu kB, %lu free chunks)\n"),
|
||||
#else
|
||||
_("Total memory allocated: %lu kB (in use: %lu kB)\n"),
|
||||
#endif
|
||||
(ma.arena + ma.hblkhd) / 1024,
|
||||
(ma.uordblks + ma.hblkhd) / 1024
|
||||
#ifdef DEBUG
|
||||
/*
|
||||
* This information is representative of the memory
|
||||
* fragmentation. In ideal case it should be 1, but
|
||||
* that is never possible
|
||||
*/
|
||||
, ma.ordblks
|
||||
#endif
|
||||
);
|
||||
|
||||
strbuf = wstrappend(strbuf, buffer);
|
||||
}
|
||||
#endif
|
||||
|
||||
strbuf = wstrappend(strbuf, _("Image formats: "));
|
||||
strl = RSupportedFileFormats();
|
||||
separator = NULL;
|
||||
|
||||
+16
-16
@@ -1603,11 +1603,13 @@ static WMPropList *make_icon_state(WAppIcon *btn)
|
||||
snprintf(buffer, sizeof(buffer), "%hi,%hi", wAppIconGetXIndex(btn), wAppIconGetYIndex(btn));
|
||||
position = WMCreatePLString(buffer);
|
||||
|
||||
node = WMCreatePLDictionary(dCommand, command,
|
||||
dName, name,
|
||||
dAutoLaunch, autolaunch,
|
||||
dLock, lock,
|
||||
dForced, forced, dBuggyApplication, buggy, dPosition, position, NULL);
|
||||
node = WMCreatePLDictionary(dCommand, command);
|
||||
WMPutInPLDictionary(node, dName, name);
|
||||
WMPutInPLDictionary(node, dAutoLaunch, autolaunch);
|
||||
WMPutInPLDictionary(node, dLock, lock);
|
||||
WMPutInPLDictionary(node, dForced, forced);
|
||||
WMPutInPLDictionary(node, dBuggyApplication, buggy);
|
||||
WMPutInPLDictionary(node, dPosition, position);
|
||||
WMReleasePropList(command);
|
||||
WMReleasePropList(name);
|
||||
WMReleasePropList(position);
|
||||
@@ -1642,7 +1644,7 @@ static WMPropList *dockSaveState(WDock *dock)
|
||||
WMPropList *value, *key;
|
||||
char buffer[256];
|
||||
|
||||
list = WMCreatePLArray(NULL);
|
||||
list = WMCreateEmptyPLArray();
|
||||
|
||||
for (i = (dock->type == WM_DOCK ? 0 : 1); i < dock->max_icons; i++) {
|
||||
WAppIcon *btn = dock->icon_array[i];
|
||||
@@ -1657,7 +1659,7 @@ static WMPropList *dockSaveState(WDock *dock)
|
||||
}
|
||||
}
|
||||
|
||||
dock_state = WMCreatePLDictionary(dApplications, list, NULL);
|
||||
dock_state = WMCreatePLDictionary(dApplications, list);
|
||||
|
||||
if (dock->type == WM_DOCK) {
|
||||
snprintf(buffer, sizeof(buffer), "Applications%i", dock->screen_ptr->scr_height);
|
||||
@@ -3194,7 +3196,7 @@ static pid_t execCommand(WAppIcon *btn, const char *command, WSavedState *state)
|
||||
setsid();
|
||||
#endif
|
||||
|
||||
args = malloc(sizeof(char *) * (argc + 1));
|
||||
args = wmalloc(sizeof(char *) * (argc + 1));
|
||||
if (!args)
|
||||
exit(111);
|
||||
|
||||
@@ -3338,8 +3340,8 @@ void wDockTrackWindowLaunch(WDock *dock, Window window)
|
||||
char *command = NULL;
|
||||
|
||||
if (!PropGetWMClass(window, &wm_class, &wm_instance)) {
|
||||
free(wm_class);
|
||||
free(wm_instance);
|
||||
wfree(wm_class);
|
||||
wfree(wm_instance);
|
||||
return;
|
||||
}
|
||||
|
||||
@@ -3419,10 +3421,8 @@ void wDockTrackWindowLaunch(WDock *dock, Window window)
|
||||
if (command)
|
||||
wfree(command);
|
||||
|
||||
if (wm_class)
|
||||
free(wm_class);
|
||||
if (wm_instance)
|
||||
free(wm_instance);
|
||||
wfree(wm_class);
|
||||
wfree(wm_instance);
|
||||
}
|
||||
|
||||
void wClipUpdateForWorkspaceChange(WScreen *scr, int workspace)
|
||||
@@ -5072,7 +5072,7 @@ static WMPropList *drawerSaveState(WDock *drawer)
|
||||
ai = drawer->icon_array[0];
|
||||
/* Store its name */
|
||||
pstr = WMCreatePLString(wAppIconGetWmInstance(ai));
|
||||
drawer_state = WMCreatePLDictionary(dName, pstr, NULL); /* we need this final NULL */
|
||||
drawer_state = WMCreatePLDictionary(dName, pstr);
|
||||
WMReleasePropList(pstr);
|
||||
|
||||
/* Store its position */
|
||||
@@ -5114,7 +5114,7 @@ void wDrawersSaveState(WScreen *scr)
|
||||
|
||||
make_keys();
|
||||
|
||||
all_drawers = WMCreatePLArray(NULL);
|
||||
all_drawers = WMCreateEmptyPLArray();
|
||||
for (i=0, dc = scr->drawers;
|
||||
i < scr->drawer_count;
|
||||
i++, dc = dc->next) {
|
||||
|
||||
+5
-5
@@ -141,7 +141,7 @@ WMagicNumber wAddDeathHandler(pid_t pid, WDeathHandler * callback, void *cdata)
|
||||
{
|
||||
DeathHandler *handler;
|
||||
|
||||
handler = malloc(sizeof(DeathHandler));
|
||||
handler = wmalloc(sizeof(DeathHandler));
|
||||
if (!handler)
|
||||
return 0;
|
||||
|
||||
@@ -150,7 +150,7 @@ WMagicNumber wAddDeathHandler(pid_t pid, WDeathHandler * callback, void *cdata)
|
||||
handler->client_data = cdata;
|
||||
|
||||
if (!deathHandlers)
|
||||
deathHandlers = WMCreateArrayWithDestructor(8, free);
|
||||
deathHandlers = WMCreateArrayWithDestructor(8, wfree);
|
||||
|
||||
WMAddToArray(deathHandlers, handler);
|
||||
|
||||
@@ -164,7 +164,7 @@ static void wdelete_death_handler(WMagicNumber id)
|
||||
if (!handler || !deathHandlers)
|
||||
return;
|
||||
|
||||
/* array destructor will call free(handler) */
|
||||
/* array destructor will call wfree(handler) */
|
||||
WMRemoveFromArray(deathHandlers, handler);
|
||||
}
|
||||
|
||||
@@ -1796,7 +1796,7 @@ static void handleKeyPress(XEvent * event)
|
||||
}
|
||||
|
||||
if (wwin->flags.selected && scr->selected_windows) {
|
||||
scr->shortcutWindows[widx] = WMDuplicateArray(scr->selected_windows);
|
||||
scr->shortcutWindows[widx] = WMCreateArrayWithArray(scr->selected_windows);
|
||||
/*WMRemoveFromArray(scr->shortcutWindows[index], wwin);
|
||||
WMInsertInArray(scr->shortcutWindows[index], 0, wwin); */
|
||||
} else {
|
||||
@@ -1816,7 +1816,7 @@ static void handleKeyPress(XEvent * event)
|
||||
if (scr->shortcutWindows[widx]) {
|
||||
WMFreeArray(scr->shortcutWindows[widx]);
|
||||
}
|
||||
scr->shortcutWindows[widx] = WMDuplicateArray(scr->selected_windows);
|
||||
scr->shortcutWindows[widx] = WMCreateArrayWithArray(scr->selected_windows);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
+1
-1
@@ -40,7 +40,7 @@ WGeometryView *WCreateGeometryView(WMScreen * scr)
|
||||
widgetClass = W_RegisterUserWidget();
|
||||
}
|
||||
|
||||
gview = malloc(sizeof(WGeometryView));
|
||||
gview = wmalloc(sizeof(WGeometryView));
|
||||
if (!gview) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
+4
-5
@@ -131,7 +131,7 @@ static void setWVisualID(int screen, int val)
|
||||
/* no array at all, alloc space for screen + 1 entries
|
||||
* and init with default value */
|
||||
wVisualID_len = screen + 1;
|
||||
wVisualID = (int *)malloc(wVisualID_len * sizeof(int));
|
||||
wVisualID = (int *)wmalloc(wVisualID_len * sizeof(int));
|
||||
for (i = 0; i < wVisualID_len; i++) {
|
||||
wVisualID[i] = -1;
|
||||
}
|
||||
@@ -156,7 +156,7 @@ static void setWVisualID(int screen, int val)
|
||||
*/
|
||||
static int initWVisualID(const char *user_str)
|
||||
{
|
||||
char *mystr = strdup(user_str);
|
||||
char *mystr = wstrdup(user_str);
|
||||
int cur_in_pos = 0;
|
||||
int cur_out_pos = 0;
|
||||
int cur_screen = 0;
|
||||
@@ -191,7 +191,7 @@ static int initWVisualID(const char *user_str)
|
||||
cur_in_pos++;
|
||||
}
|
||||
|
||||
free(mystr);
|
||||
wfree(mystr);
|
||||
|
||||
if (cur_screen == 0||error_found != 0)
|
||||
return 1;
|
||||
@@ -383,7 +383,7 @@ Bool RelaunchWindow(WWindow *wwin)
|
||||
setsid();
|
||||
#endif
|
||||
/* argv is not null-terminated */
|
||||
char **a = (char **) malloc(argc + 1);
|
||||
char **a = (char **) wmalloc(argc + 1);
|
||||
if (! a) {
|
||||
werror("out of memory trying to relaunch the application");
|
||||
Exit(-1);
|
||||
@@ -624,7 +624,6 @@ static int real_main(int argc, char **argv)
|
||||
int d, s;
|
||||
|
||||
setlocale(LC_ALL, "");
|
||||
wsetabort(wAbort);
|
||||
|
||||
/* for telling WPrefs what's the name of the wmaker binary being ran */
|
||||
setenv("WMAKER_BIN_NAME", argv[0], 1);
|
||||
|
||||
+3
-2
@@ -2309,7 +2309,8 @@ static void saveMenuInfo(WMPropList * dict, WMenu * menu, WMPropList * key)
|
||||
|
||||
snprintf(buffer, sizeof(buffer), "%i,%i", menu->frame_x, menu->frame_y);
|
||||
value = WMCreatePLString(buffer);
|
||||
list = WMCreatePLArray(value, NULL);
|
||||
list = WMCreateEmptyPLArray();
|
||||
WMAddToPLArray(list, value);
|
||||
if (menu->flags.lowered)
|
||||
WMAddToPLArray(list, WMCreatePLString("lowered"));
|
||||
WMPutInPLDictionary(dict, key, list);
|
||||
@@ -2322,7 +2323,7 @@ void wMenuSaveState(WScreen * scr)
|
||||
WMPropList *menus, *key;
|
||||
int save_menus = 0;
|
||||
|
||||
menus = WMCreatePLDictionary(NULL, NULL);
|
||||
menus = WMCreateEmptyPLDictionary();
|
||||
|
||||
if (scr->switch_menu && scr->switch_menu->flags.buttoned) {
|
||||
key = WMCreatePLString("SwitchMenu");
|
||||
|
||||
+6
-6
@@ -520,7 +520,7 @@ char *ExpandOptions(WScreen *scr, const char *cmdline)
|
||||
|
||||
len = strlen(cmdline);
|
||||
olen = len + 1;
|
||||
out = malloc(olen);
|
||||
out = wmalloc(olen);
|
||||
if (!out) {
|
||||
wwarning(_("out of memory during expansion of \"%s\""), cmdline);
|
||||
return NULL;
|
||||
@@ -573,7 +573,7 @@ char *ExpandOptions(WScreen *scr, const char *cmdline)
|
||||
(unsigned int)scr->focused_window->client_win);
|
||||
slen = strlen(tmpbuf);
|
||||
olen += slen;
|
||||
nout = realloc(out, olen);
|
||||
nout = wrealloc(out, olen);
|
||||
if (!nout) {
|
||||
wwarning(_("out of memory during expansion of '%s' for command \"%s\""), "%w", cmdline);
|
||||
goto error;
|
||||
@@ -590,7 +590,7 @@ char *ExpandOptions(WScreen *scr, const char *cmdline)
|
||||
snprintf(tmpbuf, sizeof(tmpbuf), "0x%x", (unsigned int)scr->current_workspace + 1);
|
||||
slen = strlen(tmpbuf);
|
||||
olen += slen;
|
||||
nout = realloc(out, olen);
|
||||
nout = wrealloc(out, olen);
|
||||
if (!nout) {
|
||||
wwarning(_("out of memory during expansion of '%s' for command \"%s\""), "%W", cmdline);
|
||||
goto error;
|
||||
@@ -607,7 +607,7 @@ char *ExpandOptions(WScreen *scr, const char *cmdline)
|
||||
if (user_input) {
|
||||
slen = strlen(user_input);
|
||||
olen += slen;
|
||||
nout = realloc(out, olen);
|
||||
nout = wrealloc(out, olen);
|
||||
if (!nout) {
|
||||
wwarning(_("out of memory during expansion of '%s' for command \"%s\""), "%a", cmdline);
|
||||
goto error;
|
||||
@@ -630,7 +630,7 @@ char *ExpandOptions(WScreen *scr, const char *cmdline)
|
||||
}
|
||||
slen = strlen(scr->xdestring);
|
||||
olen += slen;
|
||||
nout = realloc(out, olen);
|
||||
nout = wrealloc(out, olen);
|
||||
if (!nout) {
|
||||
wwarning(_("out of memory during expansion of '%s' for command \"%s\""), "%d", cmdline);
|
||||
goto error;
|
||||
@@ -651,7 +651,7 @@ char *ExpandOptions(WScreen *scr, const char *cmdline)
|
||||
}
|
||||
slen = strlen(selection);
|
||||
olen += slen;
|
||||
nout = realloc(out, olen);
|
||||
nout = wrealloc(out, olen);
|
||||
if (!nout) {
|
||||
wwarning(_("out of memory during expansion of '%s' for command \"%s\""), "%s", cmdline);
|
||||
goto error;
|
||||
|
||||
+6
-6
@@ -54,13 +54,13 @@ int PropGetWMClass(Window window, char **wm_class, char **wm_instance)
|
||||
|
||||
class_hint = XAllocClassHint();
|
||||
if (XGetClassHint(dpy, window, class_hint) == 0) {
|
||||
*wm_class = strdup("default");
|
||||
*wm_instance = strdup("default");
|
||||
*wm_class = wstrdup("default");
|
||||
*wm_instance = wstrdup("default");
|
||||
XFree(class_hint);
|
||||
return False;
|
||||
}
|
||||
*wm_instance = strdup(class_hint->res_name);
|
||||
*wm_class = strdup(class_hint->res_class);
|
||||
*wm_instance = wstrdup(class_hint->res_name);
|
||||
*wm_class = wstrdup(class_hint->res_class);
|
||||
|
||||
XFree(class_hint->res_name);
|
||||
XFree(class_hint->res_class);
|
||||
@@ -133,7 +133,7 @@ int PropGetGNUstepWMAttr(Window window, GNUstepWMAttributes ** attr)
|
||||
if (!data)
|
||||
return False;
|
||||
|
||||
*attr = malloc(sizeof(GNUstepWMAttributes));
|
||||
*attr = wmalloc(sizeof(GNUstepWMAttributes));
|
||||
if (!*attr) {
|
||||
XFree(data);
|
||||
return False;
|
||||
@@ -183,7 +183,7 @@ void PropSetIconTileHint(WScreen * scr, RImage * image)
|
||||
imageAtom = XInternAtom(dpy, "_RGBA_IMAGE", False);
|
||||
}
|
||||
|
||||
tmp = malloc(image->width * image->height * 4 + 4);
|
||||
tmp = wmalloc(image->width * image->height * 4 + 4);
|
||||
if (!tmp) {
|
||||
wwarning("could not allocate memory to set _WINDOWMAKER_ICON_TILE hint");
|
||||
return;
|
||||
|
||||
+5
-5
@@ -406,7 +406,7 @@ static Bool addShortcut(const char *file, const char *shortcutDefinition, WMenu
|
||||
|
||||
ptr = wmalloc(sizeof(Shortcut));
|
||||
|
||||
wstrlcpy(buf, shortcutDefinition, MAX_SHORTCUT_LENGTH);
|
||||
strlcpy(buf, shortcutDefinition, MAX_SHORTCUT_LENGTH);
|
||||
b = (char *)buf;
|
||||
|
||||
/* get modifiers */
|
||||
@@ -1243,7 +1243,7 @@ static WMenu *readMenuDirectory(WScreen *scr, const char *title, char **path, co
|
||||
if (dentry->d_name[0] == '.')
|
||||
continue;
|
||||
|
||||
buffer = malloc(strlen(path[i]) + strlen(dentry->d_name) + 4);
|
||||
buffer = wmalloc(strlen(path[i]) + strlen(dentry->d_name) + 4);
|
||||
if (!buffer) {
|
||||
werror(_("out of memory while constructing directory menu %s"), path[i]);
|
||||
break;
|
||||
@@ -1288,7 +1288,7 @@ static WMenu *readMenuDirectory(WScreen *scr, const char *title, char **path, co
|
||||
}
|
||||
}
|
||||
}
|
||||
free(buffer);
|
||||
wfree(buffer);
|
||||
}
|
||||
|
||||
closedir(dir);
|
||||
@@ -1315,7 +1315,7 @@ static WMenu *readMenuDirectory(WScreen *scr, const char *title, char **path, co
|
||||
length += 7;
|
||||
if (command)
|
||||
length += strlen(command) + 6;
|
||||
buffer = malloc(length);
|
||||
buffer = wmalloc(length);
|
||||
if (!buffer) {
|
||||
werror(_("out of memory while constructing directory menu %s"), path[data->index]);
|
||||
break;
|
||||
@@ -1353,7 +1353,7 @@ static WMenu *readMenuDirectory(WScreen *scr, const char *title, char **path, co
|
||||
if (command)
|
||||
length += strlen(command);
|
||||
|
||||
buffer = malloc(length);
|
||||
buffer = wmalloc(length);
|
||||
if (!buffer) {
|
||||
werror(_("out of memory while constructing directory menu %s"), path[data->index]);
|
||||
break;
|
||||
|
||||
+6
-3
@@ -968,8 +968,6 @@ void wScreenSaveState(WScreen * scr)
|
||||
old_state = scr->session_state;
|
||||
scr->session_state = WMCreatePLDictionary(NULL, NULL);
|
||||
|
||||
WMPLSetCaseSensitive(True);
|
||||
|
||||
/* save dock state to file */
|
||||
if (!wPreferences.flags.nodock) {
|
||||
wDockSaveState(scr, old_state);
|
||||
@@ -1009,8 +1007,13 @@ void wScreenSaveState(WScreen * scr)
|
||||
WMPutInPLDictionary(scr->session_state, dWorkspace, foo);
|
||||
}
|
||||
|
||||
/*
|
||||
* Rust rewrite note: this API surface has been removed, but we leave in
|
||||
* a record of where it was invoked to set a value other than the
|
||||
* default, in case it helps to track down bugs in the future.
|
||||
*/
|
||||
/* clean up */
|
||||
WMPLSetCaseSensitive(False);
|
||||
/* WMPLSetCaseSensitive(False); */
|
||||
|
||||
wMenuSaveState(scr);
|
||||
|
||||
|
||||
+25
-18
@@ -241,14 +241,15 @@ static WMPropList *makeWindowState(WWindow * wwin, WApplication * wapp)
|
||||
snprintf(buffer, sizeof(buffer), "%u", mask);
|
||||
shortcut = WMCreatePLString(buffer);
|
||||
|
||||
win_state = WMCreatePLDictionary(sName, name,
|
||||
sCommand, cmd,
|
||||
sWorkspace, workspace,
|
||||
sShaded, shaded,
|
||||
sMiniaturized, miniaturized,
|
||||
sMaximized, maximized,
|
||||
sHidden, hidden,
|
||||
sShortcutMask, shortcut, sGeometry, geometry, NULL);
|
||||
win_state = WMCreatePLDictionary(sName, name);
|
||||
WMPutInPLDictionary(win_state, sCommand, cmd);
|
||||
WMPutInPLDictionary(win_state, sWorkspace, workspace);
|
||||
WMPutInPLDictionary(win_state, sShaded, shaded);
|
||||
WMPutInPLDictionary(win_state, sMiniaturized, miniaturized);
|
||||
WMPutInPLDictionary(win_state, sMaximized, maximized);
|
||||
WMPutInPLDictionary(win_state, sHidden, hidden);
|
||||
WMPutInPLDictionary(win_state, sShortcutMask, shortcut);
|
||||
WMPutInPLDictionary(win_state, sGeometry, geometry);
|
||||
|
||||
WMReleasePropList(name);
|
||||
WMReleasePropList(cmd);
|
||||
@@ -289,9 +290,9 @@ static WMPropList *makeWindowState(WWindow * wwin, WApplication * wapp)
|
||||
}
|
||||
|
||||
if (instance)
|
||||
free(instance);
|
||||
wfree(instance);
|
||||
if (class)
|
||||
free(class);
|
||||
wfree(class);
|
||||
if (command)
|
||||
wfree(command);
|
||||
|
||||
@@ -313,7 +314,7 @@ void wSessionSaveState(WScreen * scr)
|
||||
return;
|
||||
}
|
||||
|
||||
list = WMCreatePLArray(NULL);
|
||||
list = WMCreateEmptyPLArray();
|
||||
|
||||
wapp_list = WMCreateArray(16);
|
||||
|
||||
@@ -382,7 +383,7 @@ static pid_t execCommand(WScreen *scr, char *command)
|
||||
|
||||
SetupEnvironment(scr);
|
||||
|
||||
args = malloc(sizeof(char *) * (argc + 1));
|
||||
args = wmalloc(sizeof(char *) * (argc + 1));
|
||||
if (!args)
|
||||
exit(111);
|
||||
for (i = 0; i < argc; i++) {
|
||||
@@ -487,8 +488,6 @@ void wSessionRestoreState(WScreen *scr)
|
||||
if (!scr->session_state)
|
||||
return;
|
||||
|
||||
WMPLSetCaseSensitive(True);
|
||||
|
||||
apps = WMGetFromPLDictionary(scr->session_state, sApplications);
|
||||
if (!apps)
|
||||
return;
|
||||
@@ -579,8 +578,13 @@ void wSessionRestoreState(WScreen *scr)
|
||||
if (class)
|
||||
wfree(class);
|
||||
}
|
||||
/*
|
||||
* Rust rewrite note: this API surface has been removed, but we leave in
|
||||
* a record of where it was invoked to set a value other than the
|
||||
* default, in case it helps to track down bugs in the future.
|
||||
*/
|
||||
/* clean up */
|
||||
WMPLSetCaseSensitive(False);
|
||||
/* WMPLSetCaseSensitive(False); */
|
||||
}
|
||||
|
||||
void wSessionRestoreLastWorkspace(WScreen * scr)
|
||||
@@ -594,8 +598,6 @@ void wSessionRestoreLastWorkspace(WScreen * scr)
|
||||
if (!scr->session_state)
|
||||
return;
|
||||
|
||||
WMPLSetCaseSensitive(True);
|
||||
|
||||
wks = WMGetFromPLDictionary(scr->session_state, sWorkspace);
|
||||
if (!wks || !WMIsPLString(wks))
|
||||
return;
|
||||
@@ -605,8 +607,13 @@ void wSessionRestoreLastWorkspace(WScreen * scr)
|
||||
if (!value)
|
||||
return;
|
||||
|
||||
/*
|
||||
* Rust rewrite note: this API surface has been removed, but we leave in
|
||||
* a record of where it was invoked to set a value other than the
|
||||
* default, in case it helps to track down bugs in the future.
|
||||
*/
|
||||
/* clean up */
|
||||
WMPLSetCaseSensitive(False);
|
||||
/* WMPLSetCaseSensitive(False); */
|
||||
|
||||
/* Get the workspace number for the workspace name */
|
||||
w = wGetWorkspaceNumber(scr, value);
|
||||
|
||||
+6
-5
@@ -109,16 +109,16 @@ void Shutdown(WShutdownMode mode)
|
||||
}
|
||||
}
|
||||
|
||||
static void restoreWindows(WMBag * bag, WMBagIterator iter)
|
||||
static void restoreWindows(WMBag * bag, WMBagIterator *iter)
|
||||
{
|
||||
WCoreWindow *next;
|
||||
WCoreWindow *core;
|
||||
WWindow *wwin;
|
||||
|
||||
if (iter == NULL) {
|
||||
core = WMBagFirst(bag, &iter);
|
||||
if (*iter < 0) {
|
||||
core = WMBagFirst(bag, iter);
|
||||
} else {
|
||||
core = WMBagNext(bag, &iter);
|
||||
core = WMBagNext(bag, iter);
|
||||
}
|
||||
|
||||
if (core == NULL)
|
||||
@@ -168,7 +168,8 @@ void RestoreDesktop(WScreen * scr)
|
||||
wDestroyInspectorPanels();
|
||||
|
||||
/* reparent windows back to the root window, keeping the stacking order */
|
||||
restoreWindows(scr->stacking_list, NULL);
|
||||
WMBagIterator iter = -1;
|
||||
restoreWindows(scr->stacking_list, &iter);
|
||||
|
||||
XUngrabServer(dpy);
|
||||
XSetInputFocus(dpy, PointerRoot, RevertToParent, CurrentTime);
|
||||
|
||||
+2
-2
@@ -244,7 +244,7 @@ reinit:
|
||||
wApplicationSetBouncing(data->wapp, 0);
|
||||
WMDeleteTimerHandler(data->timer);
|
||||
wApplicationDestroy(data->wapp);
|
||||
free(data);
|
||||
wfree(data);
|
||||
}
|
||||
|
||||
static int bounceDirection(WAppIcon *aicon)
|
||||
@@ -324,7 +324,7 @@ void wAppBounce(WApplication *wapp)
|
||||
wApplicationIncrementRefcount(wapp);
|
||||
wApplicationSetBouncing(wapp, 1);
|
||||
|
||||
AppBouncerData *data = (AppBouncerData *)malloc(sizeof(AppBouncerData));
|
||||
AppBouncerData *data = (AppBouncerData *)wmalloc(sizeof(AppBouncerData));
|
||||
data->wapp = wapp;
|
||||
data->count = data->pow = 0;
|
||||
data->dir = bounceDirection(wApplicationGetAppIcon(wapp));
|
||||
|
||||
+2
-3
@@ -132,7 +132,7 @@ static void changeImage(WSwitchPanel *panel, int idecks, int selected, Bool dim,
|
||||
if (flags == desired && !force)
|
||||
return;
|
||||
|
||||
WMReplaceInArray(panel->flags, idecks, (void *) (uintptr_t) desired);
|
||||
WMSetInArray(panel->flags, idecks, (void *) (uintptr_t) desired);
|
||||
|
||||
if (!panel->bg && !panel->tile && !selected)
|
||||
WMSetFrameRelief(icon, WRFlat);
|
||||
@@ -357,8 +357,7 @@ static void drawTitle(WSwitchPanel *panel, int idecks, const char *title)
|
||||
WMSetLabelText(panel->label, ntitle);
|
||||
}
|
||||
|
||||
if (ntitle)
|
||||
free(ntitle);
|
||||
wfree(ntitle);
|
||||
}
|
||||
|
||||
static WMArray *makeWindowListArray(WScreen *scr, int include_unmapped, Bool class_only)
|
||||
|
||||
+32
-17
@@ -174,15 +174,18 @@ static WMPropList *get_value_from_instanceclass(const char *value)
|
||||
|
||||
key = WMCreatePLString(value);
|
||||
|
||||
WMPLSetCaseSensitive(True);
|
||||
|
||||
if (w_global.domain.window_attr->dictionary)
|
||||
val = key ? WMGetFromPLDictionary(w_global.domain.window_attr->dictionary, key) : NULL;
|
||||
|
||||
if (key)
|
||||
WMReleasePropList(key);
|
||||
|
||||
WMPLSetCaseSensitive(False);
|
||||
/*
|
||||
* Rust rewrite note: this API surface has been removed, but we leave in
|
||||
* a record of where it was invoked to set a value other than the
|
||||
* default, in case it helps to track down bugs in the future.
|
||||
*/
|
||||
/* WMPLSetCaseSensitive(False); */
|
||||
|
||||
return val;
|
||||
}
|
||||
@@ -219,8 +222,6 @@ void wDefaultFillAttributes(const char *instance, const char *class,
|
||||
dn = get_value_from_instanceclass(instance);
|
||||
dc = get_value_from_instanceclass(class);
|
||||
|
||||
WMPLSetCaseSensitive(True);
|
||||
|
||||
if ((w_global.domain.window_attr->dictionary) && (useGlobalDefault))
|
||||
da = WMGetFromPLDictionary(w_global.domain.window_attr->dictionary, AnyWindow);
|
||||
|
||||
@@ -311,8 +312,13 @@ void wDefaultFillAttributes(const char *instance, const char *class,
|
||||
APPLY_VAL(value, no_language_button, ANoLanguageButton);
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Rust rewrite note: this API surface has been removed, but we leave in
|
||||
* a record of where it was invoked to set a value other than the
|
||||
* default, in case it helps to track down bugs in the future.
|
||||
*/
|
||||
/* clean up */
|
||||
WMPLSetCaseSensitive(False);
|
||||
/* WMPLSetCaseSensitive(False); */
|
||||
}
|
||||
|
||||
static WMPropList *get_generic_value(const char *instance, const char *class,
|
||||
@@ -322,8 +328,6 @@ static WMPropList *get_generic_value(const char *instance, const char *class,
|
||||
|
||||
value = NULL;
|
||||
|
||||
WMPLSetCaseSensitive(True);
|
||||
|
||||
/* Search the icon name using class and instance */
|
||||
if (class && instance) {
|
||||
char *buffer;
|
||||
@@ -371,7 +375,12 @@ static WMPropList *get_generic_value(const char *instance, const char *class,
|
||||
value = WMGetFromPLDictionary(dict, option);
|
||||
}
|
||||
|
||||
WMPLSetCaseSensitive(False);
|
||||
/*
|
||||
* Rust rewrite note: this API surface has been removed, but we leave in
|
||||
* a record of where it was invoked to set a value other than the
|
||||
* default, in case it helps to track down bugs in the future.
|
||||
*/
|
||||
/* WMPLSetCaseSensitive(False); */
|
||||
|
||||
return value;
|
||||
}
|
||||
@@ -545,15 +554,13 @@ void wDefaultChangeIcon(const char *instance, const char *class, const char *fil
|
||||
int same = 0;
|
||||
|
||||
if (!dict) {
|
||||
dict = WMCreatePLDictionary(NULL, NULL);
|
||||
dict = WMCreateEmptyPLDictionary();
|
||||
if (dict)
|
||||
db->dictionary = dict;
|
||||
else
|
||||
return;
|
||||
}
|
||||
|
||||
WMPLSetCaseSensitive(True);
|
||||
|
||||
if (instance && class) {
|
||||
char *buffer;
|
||||
|
||||
@@ -570,7 +577,7 @@ void wDefaultChangeIcon(const char *instance, const char *class, const char *fil
|
||||
|
||||
if (file) {
|
||||
value = WMCreatePLString(file);
|
||||
icon_value = WMCreatePLDictionary(AIcon, value, NULL);
|
||||
icon_value = WMCreatePLDictionary(AIcon, value);
|
||||
WMReleasePropList(value);
|
||||
|
||||
def_win = WMGetFromPLDictionary(dict, AnyWindow);
|
||||
@@ -600,7 +607,12 @@ void wDefaultChangeIcon(const char *instance, const char *class, const char *fil
|
||||
if (icon_value)
|
||||
WMReleasePropList(icon_value);
|
||||
|
||||
WMPLSetCaseSensitive(False);
|
||||
/*
|
||||
* Rust rewrite note: this API surface has been removed, but we leave in
|
||||
* a record of where it was invoked to set a value other than the
|
||||
* default, in case it helps to track down bugs in the future.
|
||||
*/
|
||||
/* WMPLSetCaseSensitive(False); */
|
||||
}
|
||||
|
||||
void wDefaultPurgeInfo(const char *instance, const char *class)
|
||||
@@ -612,8 +624,6 @@ void wDefaultPurgeInfo(const char *instance, const char *class)
|
||||
init_wdefaults();
|
||||
}
|
||||
|
||||
WMPLSetCaseSensitive(True);
|
||||
|
||||
buffer = wmalloc(strlen(class) + strlen(instance) + 2);
|
||||
sprintf(buffer, "%s.%s", instance, class);
|
||||
key = WMCreatePLString(buffer);
|
||||
@@ -631,7 +641,12 @@ void wDefaultPurgeInfo(const char *instance, const char *class)
|
||||
|
||||
wfree(buffer);
|
||||
WMReleasePropList(key);
|
||||
WMPLSetCaseSensitive(False);
|
||||
/*
|
||||
* Rust rewrite note: this API surface has been removed, but we leave in
|
||||
* a record of where it was invoked to set a value other than the
|
||||
* default, in case it helps to track down bugs in the future.
|
||||
*/
|
||||
/* WMPLSetCaseSensitive(False); */
|
||||
}
|
||||
|
||||
/* --------------------------- Local ----------------------- */
|
||||
|
||||
+9
-9
@@ -283,10 +283,10 @@ void wWindowDestroy(WWindow *wwin)
|
||||
XFree(wwin->wm_hints);
|
||||
|
||||
if (wwin->wm_instance)
|
||||
XFree(wwin->wm_instance);
|
||||
wfree(wwin->wm_instance);
|
||||
|
||||
if (wwin->wm_class)
|
||||
XFree(wwin->wm_class);
|
||||
wfree(wwin->wm_class);
|
||||
|
||||
if (wwin->wm_gnustep_attr)
|
||||
wfree(wwin->wm_gnustep_attr);
|
||||
@@ -950,10 +950,10 @@ WWindow *wManageWindow(WScreen *scr, Window window)
|
||||
}
|
||||
|
||||
if (instance)
|
||||
free(instance);
|
||||
wfree(instance);
|
||||
|
||||
if (class)
|
||||
free(class);
|
||||
wfree(class);
|
||||
#undef ADEQUATE
|
||||
}
|
||||
|
||||
@@ -1413,7 +1413,7 @@ WWindow *wManageWindow(WScreen *scr, Window window)
|
||||
/* Update name must come after WApplication stuff is done */
|
||||
wWindowUpdateName(wwin, title);
|
||||
if (title)
|
||||
XFree(title);
|
||||
wfree(title);
|
||||
|
||||
XUngrabServer(dpy);
|
||||
|
||||
@@ -2602,7 +2602,7 @@ void wWindowSetShape(WWindow * wwin)
|
||||
if (!rects)
|
||||
goto alt_code;
|
||||
|
||||
urec = malloc(sizeof(XRectangle) * (count + 2));
|
||||
urec = wmalloc(sizeof(XRectangle) * (count + 2));
|
||||
if (!urec) {
|
||||
XFree(rects);
|
||||
goto alt_code;
|
||||
@@ -2779,7 +2779,7 @@ WMagicNumber wWindowAddSavedState(const char *instance, const char *class,
|
||||
{
|
||||
WWindowState *wstate;
|
||||
|
||||
wstate = malloc(sizeof(WWindowState));
|
||||
wstate = wmalloc(sizeof(WWindowState));
|
||||
if (!wstate)
|
||||
return NULL;
|
||||
|
||||
@@ -2841,9 +2841,9 @@ WMagicNumber wWindowGetSavedState(Window win)
|
||||
if (command)
|
||||
wfree(command);
|
||||
if (instance)
|
||||
free(instance);
|
||||
wfree(instance);
|
||||
if (class)
|
||||
free(class);
|
||||
wfree(class);
|
||||
|
||||
return wstate;
|
||||
}
|
||||
|
||||
+1
-1
@@ -346,7 +346,7 @@ static void makeShortcutCommand(WMenu * menu, WMenuEntry * entry)
|
||||
}
|
||||
|
||||
if (wwin->flags.selected && scr->selected_windows) {
|
||||
scr->shortcutWindows[index] = WMDuplicateArray(scr->selected_windows);
|
||||
scr->shortcutWindows[index] = WMCreateArrayWithArray(scr->selected_windows);
|
||||
/*WMRemoveFromArray(scr->shortcutWindows[index], wwin);
|
||||
WMInsertInArray(scr->shortcutWindows[index], 0, wwin); */
|
||||
} else {
|
||||
|
||||
+9
-6
@@ -597,7 +597,7 @@ static void saveSettings(WMWidget *button, void *client_data)
|
||||
|
||||
dict = db->dictionary;
|
||||
if (!dict) {
|
||||
dict = WMCreatePLDictionary(NULL, NULL);
|
||||
dict = WMCreateEmptyPLDictionary();
|
||||
if (dict) {
|
||||
db->dictionary = dict;
|
||||
} else {
|
||||
@@ -609,10 +609,8 @@ static void saveSettings(WMWidget *button, void *client_data)
|
||||
if (showIconFor(WMWidgetScreen(button), panel, NULL, NULL, USE_TEXT_FIELD) < 0)
|
||||
return;
|
||||
|
||||
WMPLSetCaseSensitive(True);
|
||||
|
||||
winDic = WMCreatePLDictionary(NULL, NULL);
|
||||
appDic = WMCreatePLDictionary(NULL, NULL);
|
||||
winDic = WMCreateEmptyPLDictionary();
|
||||
appDic = WMCreateEmptyPLDictionary();
|
||||
|
||||
/* Save the icon info */
|
||||
/* The flag "Ignore client suplied icon is not selected" */
|
||||
@@ -709,8 +707,13 @@ static void saveSettings(WMWidget *button, void *client_data)
|
||||
|
||||
UpdateDomainFile(db);
|
||||
|
||||
/*
|
||||
* Rust rewrite note: this API surface has been removed, but we leave in
|
||||
* a record of where it was invoked to set a value other than the
|
||||
* default, in case it helps to track down bugs in the future.
|
||||
*/
|
||||
/* clean up */
|
||||
WMPLSetCaseSensitive(False);
|
||||
/* WMPLSetCaseSensitive(False); */
|
||||
}
|
||||
|
||||
static void applySettings(WMWidget *button, void *client_data)
|
||||
|
||||
+3
-3
@@ -797,7 +797,7 @@ void wWorkspaceMenuUpdate(WScreen * scr, WMenu * menu)
|
||||
i = scr->workspace_count - (menu->entry_no - MC_WORKSPACE1);
|
||||
ws = menu->entry_no - MC_WORKSPACE1;
|
||||
while (i > 0) {
|
||||
wstrlcpy(title, scr->workspaces[ws]->name, MAX_WORKSPACENAME_WIDTH);
|
||||
strlcpy(title, scr->workspaces[ws]->name, MAX_WORKSPACENAME_WIDTH);
|
||||
|
||||
entry = wMenuAddCallback(menu, title, switchWSCommand, (void *)ws);
|
||||
entry->flags.indicator = 1;
|
||||
@@ -852,10 +852,10 @@ void wWorkspaceSaveState(WScreen * scr, WMPropList * old_state)
|
||||
make_keys();
|
||||
|
||||
old_wks_state = WMGetFromPLDictionary(old_state, dWorkspaces);
|
||||
parr = WMCreatePLArray(NULL);
|
||||
parr = WMCreateEmptyPLArray();
|
||||
for (i = 0; i < scr->workspace_count; i++) {
|
||||
pstr = WMCreatePLString(scr->workspaces[i]->name);
|
||||
wks_state = WMCreatePLDictionary(dName, pstr, NULL);
|
||||
wks_state = WMCreatePLDictionary(dName, pstr);
|
||||
WMReleasePropList(pstr);
|
||||
if (!wPreferences.flags.noclip) {
|
||||
pstr = wClipSaveWorkspaceState(scr, i);
|
||||
|
||||
+2
-2
@@ -256,7 +256,7 @@ static void wXDNDGetTypeList(Display *dpy, Window window)
|
||||
return;
|
||||
}
|
||||
|
||||
typelist = malloc((count + 1) * sizeof(Atom));
|
||||
typelist = wmalloc((count + 1) * sizeof(Atom));
|
||||
a = (Atom *) data;
|
||||
for (i = 0; i < count; i++) {
|
||||
typelist[i] = a[i];
|
||||
@@ -267,7 +267,7 @@ static void wXDNDGetTypeList(Display *dpy, Window window)
|
||||
}
|
||||
typelist[count] = 0;
|
||||
XFree(data);
|
||||
free(typelist);
|
||||
wfree(typelist);
|
||||
}
|
||||
|
||||
Bool wXDNDProcessClientMessage(XClientMessageEvent *event)
|
||||
|
||||
Executable
+94
@@ -0,0 +1,94 @@
|
||||
#!/bin/sh
|
||||
|
||||
set -e
|
||||
|
||||
project_base="$(dirname $0)"
|
||||
|
||||
export WMAKER_USER_ROOT="$HOME/tmp/GNUstep"
|
||||
gs_base="$WMAKER_USER_ROOT"
|
||||
gs_defaults="$gs_base/Defaults"
|
||||
gs_system_defaults="$project_base"/WindowMaker/Defaults
|
||||
wm_base="$gs_base/Library/WindowMaker"
|
||||
wm_backgrounds="$wm_base/Backgrounds"
|
||||
wm_iconsets="$wm_base/IconSets"
|
||||
wm_pixmaps="$wm_base/Pixmaps"
|
||||
gs_icons="$gs_base/Library/Icons"
|
||||
wm_style="$wm_base/Style"
|
||||
wm_styles="$wm_base/Styles"
|
||||
wm_themes="$wm_base/Themes"
|
||||
WindowMaker="$project_base/src/.libs/wmaker"
|
||||
convertfonts="$project_base/util/convertfonts"
|
||||
|
||||
make_dir_if_needed ()
|
||||
{
|
||||
if [ ! -d "$1" ] ; then
|
||||
install -m 0755 -d "$1"
|
||||
fi
|
||||
}
|
||||
|
||||
rename_dir_if_possible ()
|
||||
{
|
||||
if [ ! -d "$2" ] ; then
|
||||
if [ -d "$1" ] ; then
|
||||
mv "$1" "$2"
|
||||
fi
|
||||
fi
|
||||
}
|
||||
|
||||
copy_defaults_if_needed ()
|
||||
{
|
||||
file="$gs_defaults/$1"
|
||||
system_file="$gs_system_defaults/$1"
|
||||
if [ ! -f "$file" ] ; then
|
||||
install -m 0644 "$system_file" "$file"
|
||||
fi
|
||||
}
|
||||
|
||||
make_dir_if_needed "$gs_defaults"
|
||||
make_dir_if_needed "$wm_base"
|
||||
make_dir_if_needed "$wm_backgrounds"
|
||||
make_dir_if_needed "$wm_iconsets"
|
||||
make_dir_if_needed "$wm_pixmaps"
|
||||
make_dir_if_needed "$gs_icons"
|
||||
rename_dir_if_possible "$wm_style" "$wm_styles"
|
||||
make_dir_if_needed "$wm_styles"
|
||||
make_dir_if_needed "$wm_themes"
|
||||
|
||||
export LD_LIBRARY_PATH="$project_base/wrlib/.libs:$project_base/WINGs/.libs:$LD_LIBRARY_PATH"
|
||||
|
||||
copy_defaults_if_needed WindowMaker
|
||||
copy_defaults_if_needed WMRootMenu
|
||||
copy_defaults_if_needed WMState
|
||||
#copy_defaults_if_needed WMWindowAttributes
|
||||
|
||||
if [ -x $convertfonts -a ! -e "$wm_base/.fonts_converted" ] ; then
|
||||
# --keep-xlfd is used in order to preserve the original information
|
||||
$convertfonts --keep-xlfd "$gs_defaults/WindowMaker"
|
||||
if [ -f "$gs_defaults/WMGLOBAL" ] ; then
|
||||
$convertfonts --keep-xlfd "$gs_defaults/WMGLOBAL"
|
||||
fi
|
||||
find "$wm_styles" -mindepth 1 -maxdepth 1 -type f -print0 |
|
||||
xargs -0 -r -n 1 $convertfonts --keep-xlfd
|
||||
touch "$wm_base/.fonts_converted"
|
||||
fi
|
||||
|
||||
if [ -n "$1" -a -x "$WindowMaker$1" ] ; then
|
||||
WindowMaker="$WindowMaker$1"
|
||||
shift
|
||||
fi
|
||||
|
||||
for i in $(seq 5 10) ; do
|
||||
if [ "x$DISPLAY" != "x:$i" ] ; then
|
||||
xephyr_display=":$i"
|
||||
break
|
||||
fi
|
||||
done
|
||||
echo "Running Xephyr on display $xephyr_display"
|
||||
|
||||
Xephyr -screen 640x480 "$xephyr_display" &
|
||||
xephyr_pid=$!
|
||||
DISPLAY="$xephyr_display" gdb \
|
||||
--directory "$project_base" \
|
||||
--quiet \
|
||||
--args "$WindowMaker" -display "$xephyr_display" --for-real "$@"
|
||||
kill $xephyr_pid
|
||||
+32
-7
@@ -18,31 +18,51 @@ AM_CPPFLAGS = \
|
||||
|
||||
liblist= @LIBRARY_SEARCH_PATH@ @INTLIBS@
|
||||
|
||||
wdwrite_LDADD = $(top_builddir)/WINGs/libWUtil.la $(liblist)
|
||||
wdwrite_LDADD = \
|
||||
$(top_builddir)/WINGs/libWUtil.la \
|
||||
$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a \
|
||||
$(liblist)
|
||||
|
||||
wdread_LDADD = $(top_builddir)/WINGs/libWUtil.la $(liblist)
|
||||
wdread_LDADD = \
|
||||
$(top_builddir)/WINGs/libWUtil.la \
|
||||
$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a \
|
||||
$(liblist)
|
||||
|
||||
wxcopy_LDADD = @XLFLAGS@ @XLIBS@
|
||||
wxcopy_LDADD = @XLFLAGS@ @XLIBS@ \
|
||||
$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a
|
||||
|
||||
wxpaste_LDADD = @XLFLAGS@ @XLIBS@
|
||||
|
||||
getstyle_LDADD = $(top_builddir)/WINGs/libWUtil.la $(liblist)
|
||||
getstyle_LDADD = \
|
||||
$(top_builddir)/WINGs/libWUtil.la \
|
||||
$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a \
|
||||
$(liblist)
|
||||
|
||||
getstyle_SOURCES = getstyle.c fontconv.c common.h
|
||||
|
||||
setstyle_LDADD = \
|
||||
$(top_builddir)/WINGs/libWUtil.la \
|
||||
$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a \
|
||||
@XLFLAGS@ @XLIBS@ $(liblist)
|
||||
|
||||
setstyle_SOURCES = setstyle.c fontconv.c common.h
|
||||
|
||||
convertfonts_LDADD = $(top_builddir)/WINGs/libWUtil.la $(liblist)
|
||||
convertfonts_LDADD = \
|
||||
$(top_builddir)/WINGs/libWUtil.la \
|
||||
$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a \
|
||||
$(liblist)
|
||||
|
||||
convertfonts_SOURCES = convertfonts.c fontconv.c common.h
|
||||
|
||||
seticons_LDADD= $(top_builddir)/WINGs/libWUtil.la $(liblist)
|
||||
seticons_LDADD= \
|
||||
$(top_builddir)/WINGs/libWUtil.la \
|
||||
$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a \
|
||||
$(liblist)
|
||||
|
||||
geticonset_LDADD= $(top_builddir)/WINGs/libWUtil.la $(liblist)
|
||||
geticonset_LDADD= \
|
||||
$(top_builddir)/WINGs/libWUtil.la \
|
||||
$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a \
|
||||
$(liblist)
|
||||
|
||||
wmagnify_LDADD = \
|
||||
$(top_builddir)/WINGs/libWINGs.la \
|
||||
@@ -52,17 +72,20 @@ wmagnify_LDADD = \
|
||||
|
||||
wmsetbg_LDADD = \
|
||||
$(top_builddir)/WINGs/libWINGs.la \
|
||||
$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a \
|
||||
$(top_builddir)/WINGs/libWUtil.la \
|
||||
$(top_builddir)/wrlib/libwraster.la \
|
||||
@XLFLAGS@ @LIBXINERAMA@ @XLIBS@ @INTLIBS@
|
||||
|
||||
wmgenmenu_LDADD = \
|
||||
$(top_builddir)/WINGs/libWUtil.la \
|
||||
$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a \
|
||||
@INTLIBS@
|
||||
|
||||
wmgenmenu_SOURCES = wmgenmenu.c wmgenmenu.h
|
||||
|
||||
wmmenugen_LDADD = \
|
||||
$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a \
|
||||
$(top_builddir)/WINGs/libWUtil.la \
|
||||
@INTLIBS@
|
||||
|
||||
@@ -75,6 +98,8 @@ wmiv_CFLAGS = @PANGO_CFLAGS@ @PTHREAD_CFLAGS@
|
||||
wmiv_LDADD = \
|
||||
$(top_builddir)/wrlib/libwraster.la \
|
||||
$(top_builddir)/WINGs/libWINGs.la \
|
||||
$(top_builddir)/WINGs/libWUtil.la \
|
||||
$(top_builddir)/wutil-rs/target/debug/libwutil_rs.a \
|
||||
@XLFLAGS@ @XLIBS@ @GFXLIBS@ \
|
||||
@PANGO_LIBS@ @PTHREAD_LIBS@ @LIBEXIF@
|
||||
|
||||
|
||||
+6
-1
@@ -131,7 +131,12 @@ int main(int argc, char **argv)
|
||||
/* this contradicts big time with getstyle */
|
||||
setlocale(LC_ALL, "");
|
||||
|
||||
WMPLSetCaseSensitive(False);
|
||||
/*
|
||||
* Rust rewrite note: this API surface has been removed, but we leave in
|
||||
* a record of where it was invoked to set a value other than the
|
||||
* default, in case it helps to track down bugs in the future.
|
||||
*/
|
||||
/* WMPLSetCaseSensitive(False); */
|
||||
|
||||
style = WMReadPropListFromFile(file);
|
||||
if (!style) {
|
||||
|
||||
+1
-1
@@ -109,7 +109,7 @@ int main(int argc, char **argv)
|
||||
if (window_attrs && WMIsPLDictionary(window_attrs)) {
|
||||
icon_value = WMGetFromPLDictionary(window_attrs, icon_key);
|
||||
if (icon_value) {
|
||||
icondic = WMCreatePLDictionary(icon_key, icon_value, NULL);
|
||||
icondic = WMCreatePLDictionary(icon_key, icon_value);
|
||||
WMPutInPLDictionary(iconset, window_name, icondic);
|
||||
}
|
||||
}
|
||||
|
||||
+10
-5
@@ -242,7 +242,7 @@ static void makeThemePack(WMPropList * style, const char *themeName)
|
||||
|
||||
WMDeleteFromPLArray(value, 1);
|
||||
WMInsertInPLArray(value, 1, WMCreatePLString(newPath));
|
||||
free(newPath);
|
||||
wfree(newPath);
|
||||
} else {
|
||||
findCopyFile(themeDir, WMGetFromPLString(file));
|
||||
}
|
||||
@@ -262,7 +262,7 @@ static void makeThemePack(WMPropList * style, const char *themeName)
|
||||
|
||||
WMDeleteFromPLArray(value, 1);
|
||||
WMInsertInPLArray(value, 1, WMCreatePLString(newPath));
|
||||
free(newPath);
|
||||
wfree(newPath);
|
||||
} else {
|
||||
findCopyFile(themeDir, WMGetFromPLString(file));
|
||||
}
|
||||
@@ -277,7 +277,7 @@ static void makeThemePack(WMPropList * style, const char *themeName)
|
||||
|
||||
WMDeleteFromPLArray(value, 2);
|
||||
WMInsertInPLArray(value, 2, WMCreatePLString(newPath));
|
||||
free(newPath);
|
||||
wfree(newPath);
|
||||
} else {
|
||||
findCopyFile(themeDir, WMGetFromPLString(file));
|
||||
}
|
||||
@@ -337,7 +337,12 @@ int main(int argc, char **argv)
|
||||
return 1;
|
||||
}
|
||||
|
||||
WMPLSetCaseSensitive(False);
|
||||
/*
|
||||
* Rust rewrite note: this API surface has been removed, but we leave in
|
||||
* a record of where it was invoked to set a value other than the
|
||||
* default, in case it helps to track down bugs in the future.
|
||||
*/
|
||||
/* WMPLSetCaseSensitive(False); */
|
||||
|
||||
path = wdefaultspathfordomain("WindowMaker");
|
||||
|
||||
@@ -357,7 +362,7 @@ int main(int argc, char **argv)
|
||||
prop = val;
|
||||
}
|
||||
|
||||
style = WMCreatePLDictionary(NULL, NULL);
|
||||
style = WMCreateEmptyPLDictionary();
|
||||
|
||||
for (i = 0; options[i] != NULL; i++) {
|
||||
key = WMCreatePLString(options[i]);
|
||||
|
||||
+7
-2
@@ -427,7 +427,12 @@ int main(int argc, char **argv)
|
||||
|
||||
file = argv[0];
|
||||
|
||||
WMPLSetCaseSensitive(False);
|
||||
/*
|
||||
* Rust rewrite note: this API surface has been removed, but we leave in
|
||||
* a record of where it was invoked to set a value other than the
|
||||
* default, in case it helps to track down bugs in the future.
|
||||
*/
|
||||
/* WMPLSetCaseSensitive(False); */
|
||||
|
||||
path = wdefaultspathfordomain("WindowMaker");
|
||||
|
||||
@@ -465,7 +470,7 @@ int main(int argc, char **argv)
|
||||
}
|
||||
|
||||
buf[strlen(buf) - 6 /* strlen("/style") */] = '\0';
|
||||
homedir = wstrdup(wgethomedir());
|
||||
homedir = wgethomedir();
|
||||
if (strlen(homedir) > 1 && /* this is insane, wgethomedir() returns `/' on error */
|
||||
strncmp(homedir, buf, strlen(homedir)) == 0) {
|
||||
/* theme pack is under ${HOME}; exchange ${HOME} part
|
||||
|
||||
+1
-1
@@ -103,7 +103,7 @@ int main(int argc, char **argv)
|
||||
|
||||
dict = WMReadPropListFromFile(path);
|
||||
if (!dict) {
|
||||
dict = WMCreatePLDictionary(key, value, NULL);
|
||||
dict = WMCreatePLDictionary(key, value);
|
||||
} else {
|
||||
WMPutInPLDictionary(dict, key, value);
|
||||
}
|
||||
|
||||
+9
-9
@@ -202,7 +202,7 @@ int change_title(XTextProperty *prop, char *filename)
|
||||
XSetWMName(dpy, win, prop);
|
||||
if (prop->value)
|
||||
XFree(prop->value);
|
||||
free(combined_title);
|
||||
wfree(combined_title);
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
@@ -596,8 +596,8 @@ int linked_list_add(linked_list_t *list, const void *data)
|
||||
{
|
||||
link_t *link;
|
||||
|
||||
/* calloc sets the "next" field to zero. */
|
||||
link = calloc(1, sizeof(link_t));
|
||||
/* wmalloc zeros the buffer it returns, so the "next" is zero. */
|
||||
link = wmalloc(sizeof(link_t));
|
||||
if (!link) {
|
||||
fprintf(stderr, "Error: memory allocation failed\n");
|
||||
return EXIT_FAILURE;
|
||||
@@ -627,8 +627,8 @@ void linked_list_free(linked_list_t *list)
|
||||
/* Store the next value so that we don't access freed memory. */
|
||||
next = link->next;
|
||||
if (link->data)
|
||||
free((char *)link->data);
|
||||
free(link);
|
||||
wfree((char *)link->data);
|
||||
wfree(link);
|
||||
}
|
||||
}
|
||||
|
||||
@@ -651,7 +651,7 @@ link_t *connect_dir(char *dirpath, linked_list_t *li)
|
||||
/* maybe it's a file */
|
||||
struct stat stDirInfo;
|
||||
if (lstat(dirpath, &stDirInfo) == 0) {
|
||||
linked_list_add(li, strdup(dirpath));
|
||||
linked_list_add(li, wstrdup(dirpath));
|
||||
return li->first;
|
||||
} else {
|
||||
return NULL;
|
||||
@@ -664,11 +664,11 @@ link_t *connect_dir(char *dirpath, linked_list_t *li)
|
||||
else
|
||||
snprintf(path, PATH_MAX, "%s%c%s", dirpath, FILE_SEPARATOR, dir[idx]->d_name);
|
||||
|
||||
free(dir[idx]);
|
||||
wfree(dir[idx]);
|
||||
if ((lstat(path, &stDirInfo) == 0) && !S_ISDIR(stDirInfo.st_mode))
|
||||
linked_list_add(li, strdup(path));
|
||||
linked_list_add(li, wstrdup(path));
|
||||
}
|
||||
free(dir);
|
||||
wfree(dir);
|
||||
return li->first;
|
||||
}
|
||||
|
||||
|
||||
+8
-8
@@ -35,8 +35,8 @@
|
||||
static void addWMMenuEntryCallback(WMMenuEntry *aEntry);
|
||||
static void assemblePLMenuFunc(WMTreeNode *aNode, void *data);
|
||||
static int dirParseFunc(const char *filename, const struct stat *st, int tflags, struct FTW *ftw);
|
||||
static int menuSortFunc(const void *left, const void *right);
|
||||
static int nodeFindSubMenuByNameFunc(const void *item, const void *cdata);
|
||||
static int menuSortFunc(const WMTreeNode *left, const WMTreeNode *right);
|
||||
static int nodeFindSubMenuByNameFunc(const WMTreeNode *tree, const void *cdata);
|
||||
static WMTreeNode *findPositionInMenu(const char *submenu);
|
||||
|
||||
|
||||
@@ -178,7 +178,7 @@ int main(int argc, char **argv)
|
||||
}
|
||||
|
||||
WMSortTree(menu, menuSortFunc);
|
||||
WMTreeWalk(menu, assemblePLMenuFunc, previousDepth, True);
|
||||
WMTreeWalk(menu, assemblePLMenuFunc, previousDepth);
|
||||
|
||||
i = WMGetArrayItemCount(plMenuNodes);
|
||||
if (i > 2) { /* more than one submenu unprocessed is almost certainly an error */
|
||||
@@ -324,13 +324,13 @@ static void assemblePLMenuFunc(WMTreeNode *aNode, void *data)
|
||||
|
||||
/* sort the menu tree; callback for WMSortTree()
|
||||
*/
|
||||
static int menuSortFunc(const void *left, const void *right)
|
||||
static int menuSortFunc(const WMTreeNode *left, const WMTreeNode *right)
|
||||
{
|
||||
WMMenuEntry *leftwm;
|
||||
WMMenuEntry *rightwm;
|
||||
|
||||
leftwm = (WMMenuEntry *)WMGetDataForTreeNode(*(WMTreeNode **)left);
|
||||
rightwm = (WMMenuEntry *)WMGetDataForTreeNode(*(WMTreeNode **)right);
|
||||
leftwm = (WMMenuEntry *)WMGetDataForTreeNode(left);
|
||||
rightwm = (WMMenuEntry *)WMGetDataForTreeNode(right);
|
||||
|
||||
/* submenus first */
|
||||
if (!leftwm->CmdLine && rightwm->CmdLine)
|
||||
@@ -380,11 +380,11 @@ static WMTreeNode *findPositionInMenu(const char *submenu)
|
||||
|
||||
/* find node where Name = cdata and node is a submenu
|
||||
*/
|
||||
static int nodeFindSubMenuByNameFunc(const void *item, const void *cdata)
|
||||
static int nodeFindSubMenuByNameFunc(const WMTreeNode *tree, const void *cdata)
|
||||
{
|
||||
WMMenuEntry *wm;
|
||||
|
||||
wm = (WMMenuEntry *)item;
|
||||
wm = (WMMenuEntry *)WMGetDataForTreeNode(tree);
|
||||
|
||||
if (wm->CmdLine) /* if it has a cmdline, it can't be a submenu */
|
||||
return 0;
|
||||
|
||||
@@ -121,7 +121,7 @@ void parse_locale(const char *what, char **language, char **country, char **enco
|
||||
*language = wstrdup(e);
|
||||
|
||||
out:
|
||||
free(e);
|
||||
wfree(e);
|
||||
return;
|
||||
|
||||
}
|
||||
|
||||
+4
-4
@@ -398,7 +398,7 @@ static BackgroundTexture *parseTexture(RContext * rc, char *text)
|
||||
RGradientStyle gtype;
|
||||
int iwidth, iheight;
|
||||
|
||||
colors = malloc(sizeof(RColor *) * (count - 1));
|
||||
colors = wmalloc(sizeof(RColor *) * (count - 1));
|
||||
if (!colors) {
|
||||
wwarning("out of memory while parsing texture");
|
||||
goto error;
|
||||
@@ -425,7 +425,7 @@ static BackgroundTexture *parseTexture(RContext * rc, char *text)
|
||||
wfree(colors);
|
||||
goto error;
|
||||
}
|
||||
if (!(colors[i - 2] = malloc(sizeof(RColor)))) {
|
||||
if (!(colors[i - 2] = wmalloc(sizeof(RColor)))) {
|
||||
wwarning("out of memory while parsing texture");
|
||||
|
||||
for (j = 0; colors[j] != NULL; j++)
|
||||
@@ -1199,14 +1199,14 @@ static void changeTextureForWorkspace(const char *domain, char *texture, int wor
|
||||
array = getValueForKey("WindowMaker", "WorkspaceSpecificBack");
|
||||
|
||||
if (!array) {
|
||||
array = WMCreatePLArray(NULL, NULL);
|
||||
array = WMCreateEmptyPLArray();
|
||||
}
|
||||
|
||||
j = WMGetPropListItemCount(array);
|
||||
if (workspace >= j) {
|
||||
WMPropList *empty;
|
||||
|
||||
empty = WMCreatePLArray(NULL, NULL);
|
||||
empty = WMCreateEmptyPLArray();
|
||||
|
||||
while (j++ < workspace - 1) {
|
||||
WMAddToPLArray(array, empty);
|
||||
|
||||
+4
-7
@@ -26,6 +26,8 @@
|
||||
#include <X11/Xlib.h>
|
||||
#include <X11/Xatom.h>
|
||||
|
||||
#include <WINGs/WUtil.h>
|
||||
|
||||
#include "../src/wconfig.h"
|
||||
|
||||
#define LINESIZE (4*1024)
|
||||
@@ -197,7 +199,7 @@ int main(int argc, char **argv)
|
||||
break;
|
||||
}
|
||||
if (buf_len == 0) {
|
||||
nbuf = malloc(buf_len = l + nl + 1);
|
||||
nbuf = wmalloc(buf_len = l + nl + 1);
|
||||
} else if (buf_len < l + nl + 1) {
|
||||
/*
|
||||
* To avoid terrible performance on big input buffers,
|
||||
@@ -205,12 +207,7 @@ int main(int argc, char **argv)
|
||||
* current line.
|
||||
*/
|
||||
buf_len = 2 * buf_len + nl + 1;
|
||||
/* some realloc implementations don't do malloc if buf==NULL */
|
||||
if (buf == NULL) {
|
||||
nbuf = malloc(buf_len);
|
||||
} else {
|
||||
nbuf = realloc(buf, buf_len);
|
||||
}
|
||||
nbuf = wrealloc(buf, buf_len);
|
||||
} else {
|
||||
nbuf = buf;
|
||||
}
|
||||
|
||||
@@ -1,5 +1,5 @@
|
||||
[package]
|
||||
name = "wmakerlib"
|
||||
name = "wmaker-rs"
|
||||
version = "0.1.0"
|
||||
edition = "2024"
|
||||
|
||||
@@ -0,0 +1,33 @@
|
||||
# automake input file for wmaker-rs
|
||||
|
||||
AUTOMAKE_OPTIONS =
|
||||
|
||||
RUST_SOURCES = \
|
||||
src/app_icon.rs \
|
||||
src/application.rs \
|
||||
src/app_menu.rs \
|
||||
src/defaults.rs \
|
||||
src/dock.rs \
|
||||
src/global.rs \
|
||||
src/icon.rs \
|
||||
src/lib.rs \
|
||||
src/menu.rs \
|
||||
src/properties.rs \
|
||||
src/screen.rs \
|
||||
src/window.rs \
|
||||
src/wings.rs \
|
||||
src/wrlib.rs
|
||||
|
||||
RUST_EXTRA = \
|
||||
Cargo.lock
|
||||
|
||||
target/debug/libwmaker_rs.a: $(RUST_SOURCES) $(RUST_EXTRA)
|
||||
$(CARGO) build
|
||||
|
||||
check-local:
|
||||
$(CARGO) test
|
||||
|
||||
clean-local:
|
||||
$(CARGO) clean
|
||||
|
||||
all: target/debug/libwmaker_rs.a
|
||||
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
+2
-1
@@ -6,7 +6,8 @@ lib_LTLIBRARIES = libWMaker.la
|
||||
|
||||
include_HEADERS = WMaker.h
|
||||
|
||||
AM_CPPFLAGS = $(DFLAGS) @XCFLAGS@
|
||||
AM_CPPFLAGS = $(DFLAGS) @XCFLAGS@ \
|
||||
-I$(top_srcdir)/WINGs -I$(top_builddir)/WINGs
|
||||
|
||||
libWMaker_la_LIBADD = @XLFLAGS@ @XLIBS@
|
||||
|
||||
|
||||
Loaded 100 of 139 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user