1
0
mirror of https://github.com/gryf/wmaker.git synced 2026-01-04 12:54:20 +01:00

Change to the linux kernel coding style

for arq in `git ls-files *.c`; do
    echo $arq;
    indent -linux -l115 $arq;
    done

The different line break at 115 columns is because
I use a widescreen monitor :-)
This commit is contained in:
Carlos R. Mafra
2009-08-20 00:59:40 +02:00
parent 59fc927dc9
commit 688a56e8ab
209 changed files with 87034 additions and 98138 deletions

View File

@@ -1,279 +1,234 @@
#include <string.h>
#include "WUtil.h"
typedef struct W_TreeNode {
void *data;
void *data;
/*unsigned int uflags:16;*/
/*unsigned int uflags:16; */
WMArray *leaves;
WMArray *leaves;
int depth;
int depth;
struct W_TreeNode *parent;
struct W_TreeNode *parent;
WMFreeDataProc *destructor;
WMFreeDataProc *destructor;
} W_TreeNode;
void
destroyNode(void *data)
void destroyNode(void *data)
{
WMTreeNode *aNode = (WMTreeNode*) data;
WMTreeNode *aNode = (WMTreeNode *) data;
if (aNode->destructor) {
(*aNode->destructor)(aNode->data);
}
if (aNode->leaves) {
WMFreeArray(aNode->leaves);
}
wfree(aNode);
if (aNode->destructor) {
(*aNode->destructor) (aNode->data);
}
if (aNode->leaves) {
WMFreeArray(aNode->leaves);
}
wfree(aNode);
}
WMTreeNode*
WMCreateTreeNode(void *data)
WMTreeNode *WMCreateTreeNode(void *data)
{
return WMCreateTreeNodeWithDestructor(data, NULL);
return WMCreateTreeNodeWithDestructor(data, NULL);
}
WMTreeNode*
WMCreateTreeNodeWithDestructor(void *data, WMFreeDataProc *destructor)
WMTreeNode *WMCreateTreeNodeWithDestructor(void *data, WMFreeDataProc * destructor)
{
WMTreeNode *aNode;
WMTreeNode *aNode;
aNode = (WMTreeNode*) wmalloc(sizeof(W_TreeNode));
memset(aNode, 0, sizeof(W_TreeNode));
aNode = (WMTreeNode *) wmalloc(sizeof(W_TreeNode));
memset(aNode, 0, sizeof(W_TreeNode));
aNode->destructor = destructor;
aNode->destructor = destructor;
aNode->data = data;
aNode->parent = NULL;
aNode->depth = 0;
aNode->leaves = NULL;
/*aNode->leaves = WMCreateArrayWithDestructor(1, destroyNode);*/
aNode->data = data;
aNode->parent = NULL;
aNode->depth = 0;
aNode->leaves = NULL;
/*aNode->leaves = WMCreateArrayWithDestructor(1, destroyNode); */
return aNode;
return aNode;
}
WMTreeNode*
WMInsertItemInTree(WMTreeNode *parent, int index, void *item)
WMTreeNode *WMInsertItemInTree(WMTreeNode * parent, int index, void *item)
{
WMTreeNode *aNode;
WMTreeNode *aNode;
wassertrv(parent!=NULL, NULL);
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);
}
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;
return aNode;
}
static void
updateNodeDepth(WMTreeNode *aNode, int depth)
static void updateNodeDepth(WMTreeNode * aNode, int depth)
{
int i;
int i;
aNode->depth = depth;
aNode->depth = depth;
if (aNode->leaves) {
for (i=0; i<WMGetArrayItemCount(aNode->leaves); i++) {
updateNodeDepth(WMGetFromArray(aNode->leaves, i), depth+1);
}
}
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)
WMTreeNode *WMInsertNodeInTree(WMTreeNode * parent, int index, WMTreeNode * aNode)
{
wassertrv(parent!=NULL, NULL);
wassertrv(aNode!=NULL, NULL);
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);
}
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;
return aNode;
}
void
WMDestroyTreeNode(WMTreeNode *aNode)
void WMDestroyTreeNode(WMTreeNode * aNode)
{
wassertr(aNode!=NULL);
wassertr(aNode != NULL);
if (aNode->parent && aNode->parent->leaves) {
WMRemoveFromArray(aNode->parent->leaves, aNode);
} else {
destroyNode(aNode);
}
if (aNode->parent && aNode->parent->leaves) {
WMRemoveFromArray(aNode->parent->leaves, aNode);
} else {
destroyNode(aNode);
}
}
void
WMDeleteLeafForTreeNode(WMTreeNode *aNode, int index)
void WMDeleteLeafForTreeNode(WMTreeNode * aNode, int index)
{
wassertr(aNode!=NULL);
wassertr(aNode->leaves!=NULL);
wassertr(aNode != NULL);
wassertr(aNode->leaves != NULL);
WMDeleteFromArray(aNode->leaves, index);
WMDeleteFromArray(aNode->leaves, index);
}
static int
sameData(void *item, void *data)
static int sameData(void *item, void *data)
{
return (((WMTreeNode*)item)->data == data);
return (((WMTreeNode *) item)->data == data);
}
void
WMRemoveLeafForTreeNode(WMTreeNode *aNode, void *leaf)
void WMRemoveLeafForTreeNode(WMTreeNode * aNode, void *leaf)
{
int index;
int index;
wassertr(aNode!=NULL);
wassertr(aNode->leaves!=NULL);
wassertr(aNode != NULL);
wassertr(aNode->leaves != NULL);
index = WMFindInArray(aNode->leaves, sameData, leaf);
if (index != WANotFound) {
WMDeleteFromArray(aNode->leaves, index);
}
index = WMFindInArray(aNode->leaves, sameData, leaf);
if (index != WANotFound) {
WMDeleteFromArray(aNode->leaves, index);
}
}
void*
WMReplaceDataForTreeNode(WMTreeNode *aNode, void *newData)
void *WMReplaceDataForTreeNode(WMTreeNode * aNode, void *newData)
{
void *old;
void *old;
wassertrv(aNode!=NULL, NULL);
wassertrv(aNode != NULL, NULL);
old = aNode->data;
aNode->data = newData;
old = aNode->data;
aNode->data = newData;
return old;
return old;
}
void*
WMGetDataForTreeNode(WMTreeNode *aNode)
void *WMGetDataForTreeNode(WMTreeNode * aNode)
{
return aNode->data;
return aNode->data;
}
int
WMGetTreeNodeDepth(WMTreeNode *aNode)
int WMGetTreeNodeDepth(WMTreeNode * aNode)
{
return aNode->depth;
return aNode->depth;
}
WMTreeNode*
WMGetParentForTreeNode(WMTreeNode *aNode)
WMTreeNode *WMGetParentForTreeNode(WMTreeNode * aNode)
{
return aNode->parent;
return aNode->parent;
}
void
WMSortLeavesForTreeNode(WMTreeNode *aNode, WMCompareDataProc *comparer)
void WMSortLeavesForTreeNode(WMTreeNode * aNode, WMCompareDataProc * comparer)
{
wassertr(aNode!=NULL);
wassertr(aNode != NULL);
if (aNode->leaves) {
WMSortArray(aNode->leaves, comparer);
}
if (aNode->leaves) {
WMSortArray(aNode->leaves, comparer);
}
}
static void
sortLeavesForNode(WMTreeNode *aNode, WMCompareDataProc *comparer)
static void sortLeavesForNode(WMTreeNode * aNode, WMCompareDataProc * comparer)
{
int i;
int i;
if (!aNode->leaves)
return;
if (!aNode->leaves)
return;
WMSortArray(aNode->leaves, comparer);
for (i=0; i<WMGetArrayItemCount(aNode->leaves); i++) {
sortLeavesForNode(WMGetFromArray(aNode->leaves, i), comparer);
}
WMSortArray(aNode->leaves, comparer);
for (i = 0; i < WMGetArrayItemCount(aNode->leaves); i++) {
sortLeavesForNode(WMGetFromArray(aNode->leaves, i), comparer);
}
}
void
WMSortTree(WMTreeNode *aNode, WMCompareDataProc *comparer)
void WMSortTree(WMTreeNode * aNode, WMCompareDataProc * comparer)
{
wassertr(aNode!=NULL);
wassertr(aNode != NULL);
sortLeavesForNode(aNode, comparer);
sortLeavesForNode(aNode, comparer);
}
static WMTreeNode*
findNodeInTree(WMTreeNode *aNode, WMMatchDataProc *match, void *cdata)
static WMTreeNode *findNodeInTree(WMTreeNode * aNode, WMMatchDataProc * match, void *cdata)
{
if (match==NULL) {
if (aNode->data == cdata) {
return aNode;
}
} else {
if ((*match)(aNode->data, cdata)) {
return aNode;
}
}
if (match == NULL) {
if (aNode->data == cdata) {
return aNode;
}
} else {
if ((*match) (aNode->data, cdata)) {
return aNode;
}
}
if (aNode->leaves) {
WMTreeNode *leaf;
int i;
if (aNode->leaves) {
WMTreeNode *leaf;
int i;
for (i=0; i<WMGetArrayItemCount(aNode->leaves); i++) {
leaf = findNodeInTree(WMGetFromArray(aNode->leaves, i), match, cdata);
if (leaf) {
return leaf;
}
}
}
for (i = 0; i < WMGetArrayItemCount(aNode->leaves); i++) {
leaf = findNodeInTree(WMGetFromArray(aNode->leaves, i), match, cdata);
if (leaf) {
return leaf;
}
}
}
return NULL;
return NULL;
}
WMTreeNode*
WMFindInTree(WMTreeNode *aTree, WMMatchDataProc *match, void *cdata)
WMTreeNode *WMFindInTree(WMTreeNode * aTree, WMMatchDataProc * match, void *cdata)
{
wassertrv(aTree!=NULL, NULL);
wassertrv(aTree != NULL, NULL);
return findNodeInTree(aTree, match, cdata);
return findNodeInTree(aTree, match, cdata);
}