void WMDeleteLeafForTreeNode(WMTreeNode * aNode, int index)
{
wassertr(aNode != NULL);
wassertr(aNode->leaves != NULL);
WMDeleteFromArray(aNode->leaves, index);
}
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
WMInsertItemInTabView(WMTabView *tPtr, int index, WMTabViewItem *item)
{
wassertr(W_TabViewItemView(item) != NULL);
if (tPtr->maxItems == tPtr->itemCount) {
WMTabViewItem **items;
items = wrealloc(tPtr->items,
sizeof(WMTabViewItem*) * (tPtr->maxItems + 10));
memset(&items[tPtr->maxItems], 0, sizeof(WMTabViewItem*) * 10);
tPtr->items = items;
tPtr->maxItems += 10;
}
if (index > tPtr->itemCount)
index = tPtr->itemCount;
if (index == 0 && tPtr->items[0]) {
W_UnmapTabViewItem(tPtr->items[0]);
}
if (index < tPtr->itemCount) {
memmove(tPtr->items + index + 1, tPtr->items + index,
(tPtr->itemCount - index) * sizeof(WMTabViewItem*));
}
tPtr->items[index] = item;
tPtr->itemCount++;
recalcTabWidth(tPtr);
W_SetTabViewItemParent(item, tPtr);
W_UnmapTabViewItem(item);
if (tPtr->flags.bordered) {
W_ReparentView(W_TabViewItemView(item), tPtr->view, 1,
tPtr->tabHeight + 1);
W_ResizeView(W_TabViewItemView(item), tPtr->view->size.width - 3,
tPtr->view->size.height - tPtr->tabHeight - 3);
} else {
W_ReparentView(W_TabViewItemView(item), tPtr->view, 0,
tPtr->tabHeight);
W_ResizeView(W_TabViewItemView(item), tPtr->view->size.width,
tPtr->view->size.height - tPtr->tabHeight);
}
if (index == 0) {
W_MapTabViewItem(item);
}
if (tPtr->delegate && tPtr->delegate->didChangeNumberOfItems)
(*tPtr->delegate->didChangeNumberOfItems)(tPtr->delegate, tPtr);
if (W_VIEW_REALIZED(tPtr->view))
paintTabView(tPtr);
}
static void W_UnmapTabViewItem(WMTabViewItem * item)
{
wassertr(item->view);
W_UnmapView(item->view);
item->flags.visible = 0;
}
void WMSortLeavesForTreeNode(WMTreeNode * aNode, WMCompareDataProc * comparer)
{
wassertr(aNode != NULL);
if (aNode->leaves) {
WMSortArray(aNode->leaves, comparer);
}
}
/* set default drag handler for view */
void WMSetViewDraggable(WMView * view, WMDragSourceProcs * dragSourceProcs, WMPixmap * dragImage)
{
wassertr(dragImage != NULL);
view->dragImage = WMRetainPixmap(dragImage);
WMSetViewDragSourceProcs(view, dragSourceProcs);
WMCreateDragHandler(view, dragImageHandler, view);
}
void
WMDrawImageString(WMScreen *scr, Drawable d, WMColor *color, WMColor *background,
WMFont *font, int x, int y, char *text, int length)
{
XftColor textColor;
XftColor bgColor;
wassertr(font!=NULL);
textColor.color.red = color->color.red;
textColor.color.green = color->color.green;
textColor.color.blue = color->color.blue;
textColor.color.alpha = color->alpha;;
textColor.pixel = W_PIXEL(color);
bgColor.color.red = background->color.red;
bgColor.color.green = background->color.green;
bgColor.color.blue = background->color.blue;
bgColor.color.alpha = background->alpha;;
bgColor.pixel = W_PIXEL(background);
XftDrawChange(scr->xftdraw, d);
XftDrawRect(scr->xftdraw, &bgColor, x, y,
WMWidthOfString(font, text, length),
font->height);
if (font->screen->useWideChar) {
wchar_t *wtext;
const char *mtext;
int len;
mtext = text;
wtext = (wchar_t *)wmalloc(sizeof(wchar_t)*(length+1));
len = wmbsnrtowcs(wtext, &mtext, length, length);
if (len>0) {
XftDrawString32(scr->xftdraw, &textColor, font->font,
x, y + font->y, (XftChar32*)wtext, len);
} else if (len==-1) {
wwarning(_("Conversion to widechar failed (possible invalid "
"multibyte sequence): '%s':(pos %d)\n"),
text, mtext-text+1);
/* we can draw normal text, or we can draw as much widechar
* text as was already converted until the error. go figure */
/*XftDrawString8(scr->xftdraw, &textColor, font->font,
x, y + font->y, (XftChar8*)text, length);*/
}
wfree(wtext);
} else if (font->screen->useMultiByte) {
XftDrawStringUtf8(scr->xftdraw, &textColor, font->font,
x, y + font->y, (XftChar8*)text, length);
} else {
XftDrawString8(scr->xftdraw, &textColor, font->font,
x, y + font->y, (XftChar8*)text, length);
}
}
void WMDestroyTreeNode(WMTreeNode * aNode)
{
wassertr(aNode != NULL);
if (aNode->parent && aNode->parent->leaves) {
WMRemoveFromArray(aNode->parent->leaves, aNode);
} else {
destroyNode(aNode);
}
}
void WMReleasePixmap(WMPixmap * pixmap)
{
wassertr(pixmap != NULL);
pixmap->refCount--;
if (pixmap->refCount < 1) {
if (pixmap->pixmap)
XFreePixmap(pixmap->screen->display, pixmap->pixmap);
if (pixmap->mask)
XFreePixmap(pixmap->screen->display, pixmap->mask);
wfree(pixmap);
}
}
void
WMReleaseFont(WMFont *font)
{
wassertr(font!=NULL);
font->refCount--;
if (font->refCount < 1) {
XftFontClose(font->screen->display, font->font);
if (font->name) {
WMHashRemove(font->screen->fontCache, font->name);
wfree(font->name);
}
wfree(font);
}
}
static void releasePropListByCount(WMPropList * plist, int count)
{
WMPropList *key, *value;
WMHashEnumerator e;
int i;
plist->retainCount -= count;
switch (plist->type) {
case WPLString:
if (plist->retainCount < 1) {
wfree(plist->d.string);
wfree(plist);
}
break;
case WPLData:
if (plist->retainCount < 1) {
WMReleaseData(plist->d.data);
wfree(plist);
}
break;
case WPLArray:
for (i = 0; i < WMGetArrayItemCount(plist->d.array); i++) {
releasePropListByCount(WMGetFromArray(plist->d.array, i), count);
}
if (plist->retainCount < 1) {
WMFreeArray(plist->d.array);
wfree(plist);
}
break;
case WPLDictionary:
e = WMEnumerateHashTable(plist->d.dict);
while (WMNextHashEnumeratorItemAndKey(&e, (void **)&value, (void **)&key)) {
releasePropListByCount(key, count);
releasePropListByCount(value, count);
}
if (plist->retainCount < 1) {
WMFreeHashTable(plist->d.dict);
wfree(plist);
}
break;
default:
wwarning(_("Used proplist functions on non-WMPropLists objects"));
wassertr(False);
break;
}
}
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);
}
static void storeDestinationProtocolVersion(WMDraggingInfo * info)
{
Atom type;
int format;
unsigned long count, remain;
unsigned char *winXdndVersion;
WMScreen *scr = W_VIEW_SCREEN(XDND_SOURCE_VIEW(info));
wassertr(XDND_DEST_WIN(info) != None);
if (XGetWindowProperty(scr->display, XDND_DEST_WIN(info),
scr->xdndAwareAtom,
0, 1, False, XA_ATOM, &type, &format,
&count, &remain, &winXdndVersion) == Success) {
XDND_DEST_VERSION(info) = *winXdndVersion;
XFree(winXdndVersion);
} else {
XDND_DEST_VERSION(info) = 0;
wwarning("failed to read XDND version of drop target");
}
}
void WMSortTree(WMTreeNode * aNode, WMCompareDataProc * comparer)
{
wassertr(aNode != NULL);
sortLeavesForNode(aNode, comparer);
}
static void W_MapTabViewItem(WMTabViewItem * item)
{
wassertr(item->view);
W_MapView(item->view);
W_RaiseView(item->view);
item->flags.visible = 1;
}
