winamp/Src/Wasabi/api/wnd/wndclass/treewnd.cpp

1646 lines
36 KiB
C++
Raw Normal View History

2024-09-24 12:54:57 +00:00
#include "precomp.h"
#include "treewnd.h"
#include <tataki/canvas/ifc_canvas.h>
#include <bfc/stack.h>
#include <api/wnd/wndclass/scrollbar.h>
#include <tataki/color/skinclr.h>
#include <api/wnd/notifmsg.h>
#include <api/wnd/accessible.h>
#include <api/wnd/PaintCanvas.h>
#define DEF_TEXT_SIZE 14
#define CHILD_INDENT itemHeight
#define X_SHIFT 2
#define Y_SHIFT 2
#define DRAG_THRESHOLD 4
#define TIMER_EDIT_DELAY 1000
#define TIMER_EDIT_ID 1249
///////////////////////////////////////////////////////////////////////////////
// TreeWnd
///////////////////////////////////////////////////////////////////////////////
static SkinColor textcolor(L"wasabi.tree.text");
static SkinColor drophilitecolor(L"wasabi.tree.hiliteddrop");
static SkinColor selectedcolor(L"wasabi.tree.selected");
int CompareTreeItem::compareItem(TreeItem *p1, TreeItem *p2) {
return p1->getTree()->compareItem(p1, p2);
}
TreeWnd::TreeWnd() {
tabClosed = NULL;
tabOpen = NULL;
linkTopBottom = NULL;
linkTopRight = NULL;
linkTopRightBottom = NULL;
linkTabTopBottom = NULL;
linkTabTopRight = NULL;
linkTabTopRightBottom = NULL;
curSelected = NULL;
mousedown_item = NULL;
hitItem = NULL;
draggedItem = NULL;
tipitem = NULL;
edited = NULL;
editwnd = NULL;
metrics_ok = FALSE;
setSorted(TRUE);
setFontSize(DEF_TEXT_SIZE);
redraw = TRUE;
prevbdownitem = NULL;
autoedit=0;
autocollapse=1;
tabClosed = L"wasabi.tree.tab.closed";
tabOpen = L"wasabi.tree.tab.open";
linkTopBottom = L"wasabi.tree.link.top.bottom";
linkTopRight = L"wasabi.tree.link.top.right";
linkTopRightBottom = L"wasabi.tree.link.top.rightBottom";
linkTabTopBottom = L"wasabi.tree.link.tab.top.bottom";
linkTabTopRight = L"wasabi.tree.link.tab.top.right";
linkTabTopRightBottom = L"wasabi.tree.link.tab.top.rightBottom";
}
TreeWnd::~TreeWnd() {
// delete all root items
deleteAllItems();
drawList.removeAll();
}
int TreeWnd::onInit() {
TREEWND_PARENT::onInit();
setBgBitmap(L"wasabi.tree.background");
setLineHeight(itemHeight);
return 1;
}
void TreeWnd::setRedraw(bool r) {
int old = redraw;
redraw = r;
if (!old && redraw)
invalidate();
}
int TreeWnd::onPaint(Canvas *canvas) {
PaintCanvas paintcanvas;
PaintBltCanvas paintbcanvas;
if (canvas == NULL) {
if (needDoubleBuffer()) {
if (!paintbcanvas.beginPaintNC(this)) return 0;
canvas = &paintbcanvas;
} else {
if (!paintcanvas.beginPaint(this)) return 0;
canvas = &paintcanvas;
}
}
TREEWND_PARENT::onPaint(canvas);
/* uncomment if you add columns or anything that should be not be drawn over by onPaint in which case you'll have to clip->subtract(your_region)
api_region *clip = new RegionI();
canvas->getClipRgn(clip); */
/*RECT r;
getNonClientRect(&r);
int y = -getScrollY()+Y_SHIFT+r.top;
int x = -getScrollX()+X_SHIFT;*/
Wasabi::FontInfo fontInfo;
fontInfo.color = textcolor;
fontInfo.opaque=false;
fontInfo.pointSize = getFontSize();
firstItemVisible = NULL;
lastItemVisible = NULL;
ensureMetricsValid();
//drawSubItems(canvas, x, &y, items, r.top, r.bottom, 0);
drawItems(canvas, &fontInfo);
canvas->selectClipRgn(NULL); // reset cliping region - NEEDED;
// delete clip; uncomment if necessary
return 1;
}
void TreeWnd::drawItems(Canvas *canvas, const Wasabi::FontInfo *fontInfo)
{
RECT r, c, ir;
RegionI *orig=NULL;
getClientRect(&r);
if (!canvas->getClipBox(&c)) {
getClientRect(&c);
orig = new RegionI(&c);
} else
orig = new RegionI(canvas);
int first = ((c.top-r.top) + getScrollY() - Y_SHIFT) / itemHeight;
int last = ((c.bottom-r.top) + getScrollY() - Y_SHIFT) / itemHeight + 1;
POINT pt;
TreeItem *item;
bool hastab;
for (int i=first;i<=last;i++)
{
if (i >= drawList.getNumItems()) break;
item = drawList[i];
if (!item) continue;
item->getCurRect(&ir);
pt.x = r.left + X_SHIFT+item->getIndent()*itemHeight - getScrollX();//ir.left;
pt.y = ir.top;
// if we need the +/- icon and any of the link lines, draw them
if (item->needTab()) {
// pt.x += itemHeight;
RECT _r={pt.x-itemHeight, pt.y, pt.x, pt.y+itemHeight};
(item->isCollapsed() ? tabClosed : tabOpen).stretchToRectAlpha(canvas, &_r);
hastab=TRUE;
} else hastab = FALSE;
int indent = item->getIndent();
for (int j=0;j<indent;j++)
{
RECT _r={pt.x-itemHeight*(j+1), pt.y, pt.x-itemHeight*j, pt.y+itemHeight};
int l = getLinkLine(item, j);
if (l == (LINK_RIGHT | LINK_TOP)) {
((hastab && j == 0) ? linkTabTopRight : linkTopRight).stretchToRectAlpha(canvas, &_r);
}
if (l == (LINK_RIGHT | LINK_TOP | LINK_BOTTOM)) {
((hastab && j == 0) ? linkTabTopRightBottom : linkTopRightBottom).stretchToRectAlpha(canvas, &_r);
}
if (l == (LINK_BOTTOM | LINK_TOP)) {
((hastab && j == 0) ? linkTabTopBottom : linkTopBottom).stretchToRectAlpha(canvas, &_r);
}
}
item->customDraw(canvas, pt, itemHeight, (pt.x+getScrollX())-r.left-X_SHIFT, r, fontInfo);
}
delete orig;
}
TreeItem *TreeWnd::hitTest(int x, int y) {
POINT pt={x,y};
return hitTest(pt);
}
TreeItem *TreeWnd::hitTest(POINT pt) {
RECT r, ir;
getClientRect(&r);
int first = (getScrollY() - Y_SHIFT) / itemHeight;
int last = ((r.bottom-r.top) + getScrollY() - Y_SHIFT) / itemHeight + 1;
for (int i=first;i<=last;i++) {
if (i >= drawList.getNumItems()) break;
TreeItem *item = drawList.enumItem(i);
if (item) {
item->getCurRect(&ir);
if (Wasabi::Std::pointInRect(ir, pt) && item->isHitTestable())
return item;
}
}
return NULL;
}
void TreeWnd::getMetrics(int *numItemsShown, int *mWidth) {
*mWidth=0;
*numItemsShown=0;
drawList.removeAll();
countSubItems(drawList, &items, X_SHIFT, numItemsShown, mWidth, 0);
}
void TreeWnd::countSubItems(PtrList<TreeItem> &drawlist, TreeItemList *_list, int indent, int *count, int *maxwidth, int z) {
TreeItemList &list = *_list;
for (int i=0;i<list.getNumItems();i++) {
TreeItem *nextitem = list[i];
int w = nextitem->getItemWidth(itemHeight, indent-X_SHIFT);
if (indent+w > *maxwidth) *maxwidth = w+indent;
int j = indent-(nextitem->needTab() ? itemHeight : 0);
int k;
k = indent + w;
nextitem->setCurRect(j, Y_SHIFT+(*count * itemHeight), k, Y_SHIFT+((*count+1) * itemHeight), z);
(*count)++;
drawlist.addItem(nextitem);
if (nextitem->isExpanded())
countSubItems(drawlist, &nextitem->subitems, indent+CHILD_INDENT, count, maxwidth, z+1);
}
}
void TreeWnd::timerCallback(int c) {
switch (c) {
case TIMER_EDIT_ID:
prevbdownitem = NULL;
killTimer(TIMER_EDIT_ID);
break;
default:
TREEWND_PARENT::timerCallback(c);
}
}
int TreeWnd::onLeftButtonDown(int x, int y) {
if (edited)
{
delete editwnd; editwnd = NULL;
endEditLabel(editbuffer);
}
POINT pt={x,y};
TreeItem *item = hitTest(pt);
if (item) {
mousedown_item = item;
mousedown_anchor.x = pt.x;
mousedown_anchor.y = pt.y;
mousedown_dragdone = FALSE;
// only do expand/collapse if was already selected
setCurItem(item, autocollapse?(curSelected == item):0, FALSE);
beginCapture();
}
return 1;
}
int TreeWnd::onLeftButtonUp(int x, int y) {
if (getCapture())
endCapture();
TREEWND_PARENT::onLeftButtonUp(x, y);
POINT pt={x,y};
TreeItem *item = hitTest(pt);
if (autoedit && item == mousedown_item && item == prevbdownitem)
setCurItem(item, FALSE, TRUE);
else
if (autoedit) {
prevbdownitem = getCurItem();
setTimer(TIMER_EDIT_ID, TIMER_EDIT_DELAY);
}
mousedown_item = NULL;
return 1;
}
int TreeWnd::onRightButtonUp(int x, int y){
TREEWND_PARENT::onRightButtonUp(x, y);
POINT pos={x,y};
TreeItem *ti = hitTest(pos);
if (ti != NULL) {
selectItem(ti);
if (onPreItemContextMenu(ti, x, y) == 0) {
int ret = ti->onContextMenu(x, y);
onPostItemContextMenu(ti, x, y, ret);
return ret;
}
return 1;
} else {
return onContextMenu(x, y);
}
}
int TreeWnd::onMouseMove(int x, int y) {
TREEWND_PARENT::onMouseMove(x, y);
POINT pt={x,y};
if (mousedown_item) {
if (!mousedown_dragdone && (ABS(pt.x - mousedown_anchor.x) > DRAG_THRESHOLD || ABS(pt.y - mousedown_anchor.y) > DRAG_THRESHOLD)) {
mousedown_dragdone = TRUE;
if (getCapture())
endCapture();
onBeginDrag(mousedown_item);
}
}
else
{
TreeItem *item = hitTest(pt);
if (item) {
if (tipitem != item) {
tipitem = item;
RECT r;
RECT c;
getClientRect(&c);
item->getCurRect(&r);
const wchar_t *tt = item->getTip();
if (tt != NULL && *tt != '\0')
setLiveTip(tt);
else if (r.right > c.right || r.bottom > c.bottom || r.top < c.top || r.left < c.left)
setLiveTip(item->getLabel());
else
setLiveTip(NULL);
}
} else {
setLiveTip(NULL);
}
}
return 1;
}
int TreeWnd::onLeftButtonDblClk(int x, int y) {
TreeItem *item = hitTest(x, y);
if (item == NULL) return 0;
return item->onLeftDoubleClick();
}
int TreeWnd::onRightButtonDblClk(int x, int y) {
TreeItem *item = hitTest(x, y);
if (item == NULL) return 0;
return item->onRightDoubleClick();
}
void TreeWnd::setLiveTip(const wchar_t *tip)
{
if (!tip)
{
setTip(oldtip);
oldtip = L"";
return;
}
oldtip = TREEWND_PARENT::getTip();
setTip(tip);
}
int TreeWnd::onBeginDrag(TreeItem *treeitem)
{
wchar_t title[WA_MAX_PATH]=L"";
// item calls addDragItem()
if (!treeitem->onBeginDrag(title)) return 0;
ASSERT(draggedItem == NULL);
draggedItem = treeitem;
if (*title != 0) setSuggestedDropTitle(title);
handleDrag();
return 1;
}
int TreeWnd::dragEnter(ifc_window *sourceWnd) {
// uh... we don't know yet, but we can accept drops in general
hitItem = NULL;
return 1;
}
int TreeWnd::dragOver(int x, int y, ifc_window *sourceWnd) {
POINT pos={x,y};
screenToClient(&pos);
TreeItem *prevItem;
prevItem = hitItem;
hitItem = hitTest(pos);
// no dropping on yourself! :)
if (hitItem == draggedItem) hitItem = NULL;
// unselect previous item
if (prevItem != hitItem && prevItem != NULL) {
unhiliteDropItem(prevItem);
repaint(); // commit invalidation of unhilited item so no trouble with scrolling
prevItem->dragLeave(sourceWnd);
}
RECT r;
getClientRect(&r);
if (pos.y < r.top + 16) {
if (getScrollY() >= 0) {
scrollToY(MAX(0, getScrollY()-itemHeight));
}
} else if (pos.y > r.bottom - 16) {
if (getScrollY() < getMaxScrollY()) {
scrollToY(MIN(getMaxScrollY(), getScrollY()+itemHeight));
}
}
if (hitItem != NULL) {
// hilight it
if (prevItem != hitItem) {
hiliteDropItem(hitItem);
repaint(); // commit invalidation of hilited so no trouble with scrolling
}
}
if (hitItem == NULL) return defaultDragOver(x, y, sourceWnd);
// ask the item if it can really accept such a drop
return hitItem->dragOver(sourceWnd);
}
int TreeWnd::dragLeave(ifc_window *sourceWnd) {
if (hitItem != NULL) {
unhiliteDropItem(hitItem);
hitItem->dragLeave(sourceWnd);
}
hitItem = NULL;
return 1;
}
int TreeWnd::dragDrop(ifc_window *sourceWnd, int x, int y) {
int res;
if (hitItem == NULL) return defaultDragDrop(sourceWnd, x, y);
// unhilite the dest
unhiliteDropItem(hitItem);
// the actual drop
res = hitItem->dragDrop(sourceWnd);
if (res) {
onItemRecvDrop(hitItem);
}
hitItem = NULL;
return res;
}
int TreeWnd::dragComplete(int success) {
int ret;
ASSERT(draggedItem != NULL);
ret = draggedItem->dragComplete(success);
draggedItem = NULL;
return ret;
}
void TreeItem::setTip(const wchar_t *tip)
{
tooltip = tip;
}
const wchar_t *TreeItem::getTip()
{
return tooltip;
}
void TreeWnd::hiliteDropItem(TreeItem *item) {
if (item)
item->setHilitedDrop(TRUE);
}
void TreeWnd::hiliteItem(TreeItem *item) {
if (item)
item->setHilited(TRUE);
}
void TreeWnd::selectItem(TreeItem *item) {
setCurItem(item, FALSE);
}
void TreeWnd::selectItemDeferred(TreeItem *item) {
postDeferredCallback(DC_SETITEM, (intptr_t)item);
}
void TreeWnd::delItemDeferred(TreeItem *item) {
postDeferredCallback(DC_DELITEM, (intptr_t)item);
}
void TreeWnd::unhiliteItem(TreeItem *item) {
if (item)
item->setHilited(FALSE);
}
void TreeWnd::unhiliteDropItem(TreeItem *item) {
if (item)
item->setHilitedDrop(FALSE);
}
void TreeWnd::setCurItem(TreeItem *item, bool expandCollapse, bool editifselected) {
if (curSelected && curSelected != item) {
onDeselectItem(curSelected);
curSelected->setSelected(FALSE);
}
if (item) {
curSelected = item;
onSelectItem(curSelected);
item->setSelected(TRUE, expandCollapse, editifselected);
setSlidersPosition();
}
}
// Returns the current tree width in pixels
int TreeWnd::getContentsWidth() {
ensureMetricsValid();
return maxWidth;
}
// Returns the current tree height in pixels
int TreeWnd::getContentsHeight() {
ensureMetricsValid();
return maxHeight;
}
void TreeWnd::ensureMetricsValid() {
if (metrics_ok) return;
int n;
getMetrics(&n, &maxWidth);
maxWidth += X_SHIFT*2;
maxHeight = n*itemHeight+Y_SHIFT*2;
metrics_ok = TRUE;
setSlidersPosition();
}
// Gets notification from sliders
int TreeWnd::childNotify(ifc_window *child, int msg, intptr_t param1, intptr_t param2) {
switch (msg) {
case ChildNotify::EDITWND_ENTER_PRESSED:
if (child == editwnd && editwnd != NULL) {
endEditLabel(editbuffer);
return 1;
}
break;
case ChildNotify::EDITWND_CANCEL_PRESSED:
if (child == editwnd && editwnd != NULL) {
cancelEditLabel();
return 1;
}
break;
case ChildNotify::EDITWND_DATA_MODIFIED:
if (child == editwnd && editwnd != NULL) {
editUpdate();
return 1;
}
break;
}
return TREEWND_PARENT::childNotify(child, msg, param1, param2);
}
void TreeWnd::editUpdate() {
ASSERT(edited != NULL && editwnd != NULL);
if (!edited || !editwnd) return;
int w = editwnd->getTextLength()+16;
RECT i, r, e;
edited->getCurRect(&i);
getClientRect(&r);
editwnd->getClientRect(&e);
e.left += i.left;
e.right += i.left;
e.top += i.top;
e.bottom += i.top;
e.right = i.left+w;
e.right = MIN<int>(r.right - X_SHIFT, e.right);
editwnd->resize(&e);
editwnd->invalidate();
}
TreeItem *TreeWnd::addTreeItem(TreeItem *item, TreeItem *par, int _sorted, int haschildtab) {
ASSERT(item != NULL);
ASSERTPR(item->getTree() == NULL, "can't transplant TreeItems");
ASSERTPR(item->getLabel() != NULL, "tree items must have a label to be inserted");
item->setSorted(_sorted);
item->setChildTab(haschildtab ? TAB_AUTO : TAB_NO/*&& par != NULL*/);
item->setTree(this);
item->linkTo(par);
if (par == NULL)
items.addItem(item);
all_items.addItem(item);
metrics_ok = FALSE;
if (redraw)
invalidate();
item->onTreeAdd();
return item;
}
int TreeWnd::removeTreeItem(TreeItem *item) {
ASSERT(item != NULL);
ASSERT(item->getTree() == this);
if (item->isSelected()) item->setSelected(FALSE);
if (curSelected == item) curSelected = NULL;
//CUT item->deleteSubitems();
TreeItem *par = item->getParent();
if (!par) { // is root item ?
ASSERT(items.haveItem(item));
items.removeItem(item);
} else {
if (!par->removeSubitem(item))
return 0;
}
all_items.removeItem(item);
metrics_ok = FALSE;
drawList.removeItem(item);
if (redraw)
invalidate();
item->setTree(NULL);
item->onTreeRemove();
if (par != NULL) par->onChildItemRemove(item);
return 1;
}
void TreeWnd::moveTreeItem(TreeItem *item, TreeItem *newparent) {
ASSERT(item != NULL);
ASSERTPR(item->getTree() == this, "can't move between trees (fucks up Freelist)");
removeTreeItem(item);
addTreeItem(item, newparent, item->subitems.getAutoSort(), item->childTab);
}
void TreeWnd::deleteAllItems() {
bool save_redraw = redraw;
setRedraw(FALSE);
TreeItem *item;
while ((item = enumRootItem(0)) != NULL)
delete item;
setRedraw(save_redraw);
}
void TreeWnd::setSorted(bool dosort) {
items.setAutoSort(dosort);
}
bool TreeWnd::getSorted() {
return items.getAutoSort();
}
void TreeWnd::sortTreeItems() {
items.sort(TRUE);
metrics_ok = FALSE;
if (redraw)
invalidate();
}
TreeItem *TreeWnd::getSibling(TreeItem *item) {
for (int i=0;i<items.getNumItems();i++) {
if (items[i] == item) {
if (i == items.getNumItems()-1) return NULL;
return items[i+1];
}
}
return NULL;
}
void TreeWnd::setAutoCollapse(bool doautocollase) {
autocollapse=doautocollase;
}
int TreeWnd::onContextMenu(int x, int y) {
POINT pos={x,y};
screenToClient(&pos);
TreeItem *ti = hitTest(pos);
if (ti != NULL) {
selectItem(ti);
return ti->onContextMenu(x, y);
}
return 0;
}
int TreeWnd::onDeferredCallback(intptr_t param1, intptr_t param2) {
switch (param1) {
case DC_SETITEM:
setCurItem((TreeItem *)param2, FALSE);
return 1;
case DC_DELITEM:
delete (TreeItem *)param2;
return 1;
case DC_EXPAND:
expandItem((TreeItem *)param2);
return 1;
case DC_COLLAPSE:
collapseItem((TreeItem *)param2);
return 1;
}
return 0;
}
int TreeWnd::getNumRootItems() {
return items.getNumItems();
}
TreeItem *TreeWnd::enumRootItem(int which) {
return items[which];
}
void TreeWnd::invalidateMetrics() {
metrics_ok = FALSE;
}
int TreeWnd::getLinkLine(TreeItem *item, int level) {
ASSERT(item != NULL);
int l = 0;
int r = 0;
if (item->parent == NULL)
return 0;
TreeItem *cur=item;
while (cur->getParent() && l < level) {
cur = cur->getParent();
l++;
}
if (cur->getSibling()) r |= LINK_BOTTOM | LINK_TOP;
if (level == 0) r |= LINK_RIGHT;
if (level == 0 && cur->getParent()) r |= LINK_TOP;
return r;
}
int TreeWnd::onMouseWheelDown(int clicked, int lines) {
if (!clicked)
scrollToY(MIN(getMaxScrollY(), getScrollY()+itemHeight));
else
scrollToX(MIN(getMaxScrollX(), getScrollX()+itemHeight));
return 1;
}
int TreeWnd::onMouseWheelUp(int clicked, int lines) {
if (!clicked)
scrollToY(MAX(0, getScrollY()-itemHeight));
else
scrollToX(MAX(0, getScrollX()-itemHeight));
return 1;
}
int TreeWnd::expandItem(TreeItem *item) {
ASSERT(item != NULL);
return item->expand();
}
void TreeWnd::expandItemDeferred(TreeItem *item) {
postDeferredCallback(DC_EXPAND, (intptr_t)item);
}
int TreeWnd::collapseItem(TreeItem *item) {
ASSERT(item != NULL);
return item->collapse();
}
void TreeWnd::collapseItemDeferred(TreeItem *item) {
postDeferredCallback(DC_COLLAPSE, (intptr_t)item);
}
TreeItem *TreeWnd::getCurItem() {
return curSelected;
}
int TreeWnd::getItemRect(TreeItem *item, RECT *r) {
ASSERT(item != NULL);
return item->getCurRect(r);
}
void TreeWnd::editItemLabel(TreeItem *item) {
if (edited) {
edited->setEdition(FALSE);
edited->invalidate();
}
ASSERT(item != NULL);
if (item == NULL) return;
if (item->onBeginLabelEdit()) return;
item->setEdition(TRUE);
edited = item;
editwnd = new EditWnd();
editwnd->setModal(TRUE);
editwnd->setAutoSelect(TRUE);
editwnd->setStartHidden(TRUE);
editwnd->init(getOsModuleHandle(), getOsWindowHandle());
editwnd->setParent(this);
RECT r;
edited->getCurRect(&r);
RECT cr;
getClientRect(&cr);
r.right = cr.right;
if (r.bottom - r.top < 24) r.bottom = r.top + 24;
editwnd->resize(&r);
wcsncpy(editbuffer, edited->getLabel(), 256);
editwnd->setBuffer(editbuffer, 255);
editUpdate();
editwnd->setVisible(TRUE);
}
void TreeWnd::endEditLabel(const wchar_t *newlabel)
{
editwnd = NULL; // editwnd self destructs
if (edited->onEndLabelEdit(newlabel))
edited->setLabel(newlabel);
edited->setEdition(FALSE);
edited->invalidate();
onLabelChange(edited);
edited = NULL;
invalidateMetrics();
setSlidersPosition();
}
void TreeWnd::cancelEditLabel(int destroyit) {
ASSERT(edited != NULL);
if (!edited) return;
if (destroyit)
delete editwnd;
editwnd = NULL; // editwnd self destructs (update> except if destroyit for cancelling from treewnd)
edited->setEdition(FALSE);
edited->invalidate();
edited = NULL;
}
void TreeWnd::setAutoEdit(int ae) {
autoedit = ae;
}
int TreeWnd::getAutoEdit() {
return autoedit;
}
TreeItem *TreeWnd::getByLabel(TreeItem *item, const wchar_t *name)
{
TreeItem *ti;
// handle root-level searching
if (item == NULL) {
int n = getNumRootItems();
for (int i = 0; i < n; i++) {
ti = enumRootItem(i);
if (!wcscmp(name, ti->getLabel())) return ti;
ti = getByLabel(ti, name);
if (ti) return ti;
}
return NULL;
}
// check the given item
if (!wcscmp(name, item->getLabel())) return item;
// depth first search
ti = item->getChild();
if (ti != NULL) {
ti = getByLabel(ti, name);
if (ti != NULL) return ti;
}
// recursively check siblings
ti = item->getSibling();
if (ti != NULL) ti = getByLabel(ti, name);
return ti;
}
int TreeWnd::onGetFocus() {
int r = TREEWND_PARENT::onGetFocus();
#if 0
DebugString("yay got focus");
TreeItem *ti = getCurItem();
if (ti != NULL) {
ti->setSelected(FALSE);
selectItemDeferred(ti);
}
#endif
return r;
}
int TreeWnd::onKillFocus() {
TREEWND_PARENT::onKillFocus();
mousedown_item=NULL;
/* if (edited)
cancelEditLabel();*/
#if 0
DebugString("no mo focus");
#endif
return 1;
}
int TreeWnd::onChar(unsigned int c)
{
int r = 0;
if (c == 27) {
if (edited)
cancelEditLabel(1);
}
if (curSelected != NULL && (r = curSelected->onChar(c)) != 0) return r;
wchar_t b = TOUPPERW(c);
if (b >= 'A' && b <= 'Z')
{
jumpToNext(b);
r = 1;
}
return r ? r : TREEWND_PARENT::onChar(c);
}
int TreeWnd::getNumVisibleChildItems(TreeItem *c) {
int nb=0;
for(int i=0;i<c->getNumChildren();i++) {
TreeItem *t=c->getNthChild(i);
if(t->hasSubItems() && t->isExpanded())
nb+=getNumVisibleChildItems(t);
nb++;
}
return nb;
}
int TreeWnd::getNumVisibleItems() {
int nb=0;
for(int i=0;i<items.getNumItems();i++) {
TreeItem *t=items.enumItem(i);
if(t->hasSubItems() && t->isExpanded())
nb+=getNumVisibleChildItems(t);
nb++;
}
return nb;
}
TreeItem *TreeWnd::enumVisibleChildItems(TreeItem *c, int n) {
int nb=0;
for(int i=0;i<c->getNumChildren();i++) {
TreeItem *t=c->getNthChild(i);
if(nb==n) return t;
if(t->hasSubItems() && t->isExpanded()) {
TreeItem *t2=enumVisibleChildItems(t, n-nb-1);
if(t2) return t2;
nb+=getNumVisibleChildItems(t);
}
nb++;
}
return NULL;
}
TreeItem *TreeWnd::enumVisibleItems(int n) {
int nb=0;
for(int i=0;i<items.getNumItems();i++) {
TreeItem *t=items.enumItem(i);
if(nb==n) return t;
if(t->hasSubItems() && t->isExpanded()) {
TreeItem *t2=enumVisibleChildItems(t, n-nb-1);
if(t2) return t2;
nb+=getNumVisibleChildItems(t);
}
nb++;
}
return NULL;
}
int TreeWnd::findChildItem(TreeItem *c, TreeItem *i, int *nb) {
for(int j=0;j<c->getNumChildren();j++) {
TreeItem *t=c->getNthChild(j); (*nb)++;
if (t == i) return *nb;
if(t->hasSubItems() && t->isExpanded()) {
int n = findChildItem(t, i, nb);
if (n != -1) return *nb;
}
}
return -1;
}
int TreeWnd::findItem(TreeItem *i) {
int nb=-1;
for(int j=0;j<items.getNumItems();j++) {
TreeItem *t=items.enumItem(j); nb++;
if (t == i) return nb;
if(t->hasSubItems() && t->isExpanded()) {
int n = findChildItem(t, i, &nb);
if (n != -1) return nb;
}
}
return -1;
}
TreeItem *TreeWnd::enumAllItems(int n) {
return all_items[n];
}
int TreeWnd::onKeyDown(int keycode)
{
switch(keycode)
{
case 113: {
TreeItem *item = getCurItem();
if (item)
item->editLabel();
return 1;
}
case STDKEY_UP: {
TreeItem *t=getCurItem();
int l=getNumVisibleItems();
if (t == NULL) {
if (l > 0) setCurItem(enumVisibleItems(getNumVisibleItems()-1), FALSE, FALSE);
} else {
for(int i=0;i<l;i++)
if(enumVisibleItems(i)==t) {
if(i-1>=0) {
TreeItem *t2=enumVisibleItems(i-1);
if(t2) setCurItem(t2,FALSE,FALSE);
}
}
}
return 1;
}
case STDKEY_DOWN: {
TreeItem *t=getCurItem();
int l=getNumVisibleItems();
if (t == NULL) {
if (l > 0) setCurItem(enumVisibleItems(0), FALSE, FALSE);
} else {
for(int i=0;i<l;i++)
if(enumVisibleItems(i)==t) {
TreeItem *t2=enumVisibleItems(i+1);
if(t2) setCurItem(t2,FALSE,FALSE);
}
}
return 1;
}
case VK_PRIOR: {
TreeItem *t=getCurItem();
int l=getNumVisibleItems();
for(int i=0;i<l;i++)
if(enumVisibleItems(i)==t) {
int a=MAX(i-5,0);
TreeItem *t2=enumVisibleItems(a);
if(t2) setCurItem(t2,FALSE,FALSE);
}
return 1;
}
case VK_NEXT: {
TreeItem *t=getCurItem();
int l=getNumVisibleItems();
for(int i=0;i<l;i++)
if(enumVisibleItems(i)==t) {
int a=MIN(i+5,l-1);
TreeItem *t2=enumVisibleItems(a);
if(t2) setCurItem(t2,FALSE,FALSE);
}
return 1;
}
case STDKEY_HOME: {
TreeItem *t=enumVisibleItems(0);
if(t) setCurItem(t,FALSE,FALSE);
return 1;
}
case STDKEY_END: {
TreeItem *t=enumVisibleItems(getNumVisibleItems()-1);
if(t) setCurItem(t,FALSE,FALSE);
return 1;
}
case STDKEY_LEFT: {
TreeItem *t=getCurItem();
if(t) t->collapse();
return 1;
}
case STDKEY_RIGHT: {
TreeItem *t=getCurItem();
if(t) t->expand();
return 1;
}
}
return TREEWND_PARENT::onKeyDown(keycode);
}
void TreeWnd::jumpToNext(wchar_t c) {
firstFound=FALSE;
if (jumpToNextSubItems(&items, c)) return;
firstFound=TRUE;
jumpToNextSubItems(&items, c);
}
int TreeWnd::jumpToNextSubItems(TreeItemList *list, wchar_t c) {
for (int i=0;i<list->getNumItems();i++) {
TreeItem *nextitem = list->enumItem(i);
const wchar_t *l = nextitem->getLabel();
wchar_t b = l ? TOUPPERW(*l) : 0;
if (b == c && firstFound)
{
selectItem(nextitem);
nextitem->ensureVisible();
return 1;
}
if (nextitem->isSelected()) firstFound = TRUE;
if (nextitem->isExpanded())
if (jumpToNextSubItems(&nextitem->subitems, c)) return 1;
}
return 0;
}
void TreeWnd::ensureItemVisible(TreeItem *item) {
ASSERT(item != NULL);
// walk the parent tree to make sure item is visible
for (TreeItem *cur = item->getParent(); cur; cur = cur->getParent()) {
if (cur->isCollapsed()) cur->expand();
}
RECT r;
RECT c;
item->getCurRect(&r);
getClientRect(&c);
if (r.top < c.top || r.bottom > c.bottom) {
if (r.top + (c.bottom - c.top) <= getContentsHeight())
scrollToY(r.top);
else {
scrollToY(getContentsHeight()-(c.bottom-c.top));
}
}
}
void TreeWnd::setHilitedColor(const wchar_t *colorname) {
// we have to store it in a String because SkinColor does not make a copy
hilitedColorName = colorname;
hilitedColor = hilitedColorName;
}
ARGB32 TreeWnd::getHilitedColor() {
return hilitedColor;
}
int TreeWnd::compareItem(TreeItem *p1, TreeItem *p2)
{
int r = wcscmp(p1->getLabel(), p2->getLabel());
if (r == 0) return CMP3(p1, p2);
return r;
}
int TreeWnd::setFontSize(int newsize)
{
TREEWND_PARENT::setFontSize(newsize);
if (newsize >= 0) textsize = newsize;
TextInfoCanvas c(this);
Wasabi::FontInfo fontInfo;
fontInfo.pointSize = getFontSize();
itemHeight = c.getTextHeight(&fontInfo);
redraw = 1;
metrics_ok = 0;
invalidate();
return 1;
}
int TreeWnd::getFontSize() {
#ifndef WASABINOMAINAPI
return textsize + api->metrics_getDelta();
#else
//MULTIAPI-FIXME: not handling delta
return textsize;
#endif
}
void TreeWnd::onSelectItem(TreeItem *i) {
Accessible *a = getAccessibleObject();
if (a != NULL)
a->onGetFocus(findItem(i));
}
void TreeWnd::onDeselectItem(TreeItem *i) {
}
////////////////////////////////////////////////////////////////////////////////////
// TreeItem
////////////////////////////////////////////////////////////////////////////////////
TreeItem::TreeItem(const wchar_t *label) {
parent=NULL;
MEMZERO(&curRect, sizeof(RECT));
childTab = TAB_AUTO;
tree = NULL;
expandStatus = STATUS_COLLAPSED;
icon = NULL;
_z = 0;
if (label != NULL)
setLabel(label);
selected = FALSE;
hilitedDrop = FALSE;
hilited = FALSE;
being_edited = FALSE;
setSorted(TRUE);
}
TreeItem::~TreeItem() {
// the subitem will call parent tree which will remove item from our list
deleteSubitems();
// remove from parent tree
if (tree) tree->removeTreeItem(this);
delete icon;
}
void TreeItem::deleteSubitems() {
while (subitems.getNumItems() > 0) {
delete subitems.enumItem(0);
}
}
void TreeItem::setSorted(int issorted) {
subitems.setAutoSort(!!issorted);
}
void TreeItem::setChildTab(int haschildtab) {
childTab = haschildtab;
}
void TreeItem::linkTo(TreeItem *par) {
parent = par;
if (par == NULL) return;
par->addSubItem(this);
}
void TreeItem::addSubItem(TreeItem *item) {
subitems.addItem(item);
}
int TreeItem::removeSubitem(TreeItem *item) {
if (subitems.searchItem(item) == -1) return 0;
subitems.removeItem(item);
if (tree->redraw)
tree->invalidate();
return 1;
}
TreeItem *TreeItem::getChild() {
return subitems.getFirst();
}
TreeItem *TreeItem::getChildSibling(TreeItem *item) { // locate item in children and return its sibling
for (int i=0;i<subitems.getNumItems();i++) {
if (subitems.enumItem(i) == item) {
if (i == subitems.getNumItems()-1) return NULL;
return subitems.enumItem(i+1);
}
}
return NULL;
}
TreeItem *TreeItem::getSibling() { // returns next item
if (!parent)
return tree->getSibling(this);
else
return parent->getChildSibling(this);
}
void TreeItem::setTree(TreeWnd *newtree) {
tree = newtree;
// recursively reset tree for children, if any
for (int i = 0; ; i++) {
TreeItem *item = getNthChild(i);
if (item == NULL) break;
item->setTree(tree);
}
}
void TreeItem::ensureVisible()
{
if (tree) tree->ensureItemVisible(this);
}
const wchar_t *TreeItem::getLabel()
{
return label;
}
void TreeItem::setLabel(const wchar_t *newlabel)
{
label = newlabel;
if (newlabel) {
if (tree)
tree->invalidateMetrics();
invalidate();
}
}
int TreeItem::customDraw(Canvas *canvas, const POINT &pt, int txtHeight, int indentation, const RECT &clientRect, const Wasabi::FontInfo *fontInfo)
{
if (being_edited) return 0;
SkinBitmap *icon = getIcon();
int cw = clientRect.right - clientRect.left;
int iconw = MIN(icon ? icon->getWidth() : 0, cw);
if (isSelected() || isHilitedDrop())
{
RECT r;
r.left = pt.x;
r.top = pt.y;
//r.right = r.left + canvas->getTextWidth(label)+2+(icon ? txtHeight : 0);
r.right = r.left + canvas->getTextWidth(label, fontInfo)+2+iconw;
r.bottom = r.top + txtHeight;
canvas->fillRect(&r, isHilitedDrop() ? drophilitecolor : selectedcolor);
}
if (isHilited())
{
RECT r;
r.left = pt.x;
r.top = pt.y;
//r.right = r.left + canvas->getTextWidth(label)+2+(icon ? txtHeight : 0);
r.right = r.left + canvas->getTextWidth(label, fontInfo)+2+iconw;
r.bottom = r.top + txtHeight;
canvas->drawRect(&r, 1, tree->getHilitedColor());
}
POINT d=pt;
if (icon) {
RECT i;
i.left = pt.x+1;
i.right = i.left + iconw;
// i.top = pt.y+1;
int lh = MIN(icon->getHeight(), txtHeight);
i.top = pt.y + (txtHeight - lh) / 2;
// i.bottom = i.top + txtHeight-2;
i.bottom = i.top + lh;
icon->stretchToRectAlpha(canvas, &i);
//d.x += txtHeight;
d.x += icon->getWidth();
}
canvas->textOut(d.x+1, d.y, label, fontInfo);
return canvas->getTextWidth(label, fontInfo)+2+iconw;
}
int TreeItem::getItemWidth(int txtHeight, int indentation) {
SkinBitmap *icon = getIcon();
if (!label) return (icon ? txtHeight : 0);
TextInfoCanvas c(tree);
Wasabi::FontInfo fontInfo;
fontInfo.pointSize = getTree()->getFontSize();
int width = c.getTextWidth(label, &fontInfo)+2;
width += (icon ? txtHeight : 0);
return width;
}
int TreeItem::getNumChildren() {
return subitems.getNumItems();
}
TreeItem *TreeItem::getNthChild(int nth) {
if (nth >= subitems.getNumItems()) return NULL;
return subitems.enumItem(nth);
}
void TreeItem::setCurRect(int x1, int y1, int x2, int y2, int z) {
curRect.left = x1;
curRect.right = x2;
curRect.top = y1;
curRect.bottom = y2;
_z = z;
}
int TreeItem::getIndent() {
return _z;
}
bool TreeItem::hasSubItems() {
return subitems.getNumItems()>0;
}
bool TreeItem::needTab() {
return (childTab == TAB_YES || (childTab == TAB_AUTO && hasSubItems()));
}
bool TreeItem::isExpanded() {
if (!hasSubItems()) return FALSE;
return expandStatus == STATUS_EXPANDED;
}
bool TreeItem::isCollapsed() {
if (!hasSubItems()) return TRUE;
return expandStatus == STATUS_COLLAPSED;
}
int TreeItem::getCurRect(RECT *r) {
r->left = curRect.left-tree->getScrollX();
r->top = curRect.top-tree->getScrollY();
r->right = curRect.right-tree->getScrollX();
r->bottom = curRect.bottom-tree->getScrollY();
RECT c;
tree->getClientRect(&c);
r->top += c.top;
r->bottom += c.top;
r->left += c.left;
r->right += c.left;
return 1;
}
TreeWnd *TreeItem::getTree() const {
return tree;
}
void TreeItem::setSelected(bool isSelected, bool expandCollapse, bool editifselected) {
bool wasselected = selected;
selected = !!isSelected;
if (selected != wasselected) {
invalidate();
tree->repaint();
if (selected) {
onSelect();
ASSERT(tree != NULL);
tree->onItemSelected(this);
} else {
onDeselect();
ASSERT(tree != NULL);
tree->onItemDeselected(this);
}
} else {
if (selected && editifselected) {
editLabel();
}
}
if (expandCollapse) {
if (isCollapsed())
expand();
else
collapse();
}
}
void TreeItem::invalidate() {
if (tree) {
RECT r;
getCurRect(&r);
tree->invalidateRect(&r);
}
}
bool TreeItem::isSelected() {
return selected;
}
int TreeItem::collapse() {
int old = expandStatus;
if (hasSubItems()) {
if (expandStatus == STATUS_COLLAPSED)
return 0;
expandStatus = STATUS_COLLAPSED;
RECT c;
tree->getClientRect(&c);
RECT r;
getCurRect(&r);
r.bottom = c.bottom;
r.left = c.left;
r.right = c.right;
if (tree) {
tree->invalidateRect(&r);
tree->invalidateMetrics();
}
}
onCollapse();
return old != expandStatus;
}
int TreeItem::expand() {
int old = expandStatus;
if (hasSubItems()) {
if (expandStatus == STATUS_EXPANDED)
return 0;
expandStatus = STATUS_EXPANDED;
RECT c;
tree->getClientRect(&c);
RECT r;
getCurRect(&r);
r.bottom = c.bottom;
r.left = c.left;
r.right = c.right;
if (tree) {
tree->invalidateRect(&r);
tree->invalidateMetrics();
}
}
onExpand();
return old != expandStatus;
}
int TreeItem::onContextMenu(int x, int y) {
return 0;
}
void TreeItem::setHilitedDrop(bool ishilitedDrop) {
bool washilighted = hilitedDrop;
hilitedDrop = !!ishilitedDrop;
if (washilighted != hilitedDrop)
invalidate();
}
void TreeItem::setHilited(bool ishilited) {
bool washilighted = hilited;
hilited = !!ishilited;
if (washilighted != hilited)
invalidate();
}
TreeItem *TreeItem::getParent() {
return parent;
}
bool TreeItem::isHilitedDrop() {
return hilitedDrop;
}
bool TreeItem::isHilited() {
return hilited;
}
void TreeItem::setIcon(SkinBitmap *newicon) {
if (icon) {
delete icon;
icon = NULL;
}
icon = newicon;
invalidate();
}
SkinBitmap *TreeItem::getIcon() {
return icon;
}
void TreeItem::sortItems() {
subitems.sort();
}
void TreeItem::editLabel() {
if (!tree) return;
tree->editItemLabel(this);
}
int TreeItem::onBeginLabelEdit() {
return 1; // disable editing by default
}
int TreeItem::onEndLabelEdit(const wchar_t *newlabel)
{
return 1; // accept new label by default
}
void TreeItem::setEdition(bool isedited) {
being_edited = !!isedited;
invalidate();
}
bool TreeItem::getEdition() {
return being_edited;
}
bool TreeItem::isSorted()
{
return subitems.getAutoSort();
}