1646 lines
36 KiB
C++
1646 lines
36 KiB
C++
#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();
|
|
}
|
|
|