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

#ifndef _TREEWND_H
#define _TREEWND_H

// BU: lots of changes
// - all items must be deletable, and will be deleted on destructor
// - root items list not allocated w/ new
// - items set sorting within their PtrListSorted instead of manually calling it
// - setting an item to auto-sort does *not* make subitems autosort too

#include <api/wnd/wndclass/scbkgwnd.h>
#include <bfc/ptrlist.h>
#include <api/wnd/wndclass/editwnd.h>
#include <bfc/common.h>
#include <tataki/color/skinclr.h>

#define TREEWND_PARENT ScrlBkgWnd

#define STATUS_EXPANDED  0
#define STATUS_COLLAPSED 1

#define HITTEST_BEFORE   0
#define HITTEST_IN       1
#define HITTEST_AFTER    2

#define LINK_RIGHT       1
#define LINK_TOP         2
#define LINK_BOTTOM      4

#define TAB_NO           FALSE
#define TAB_YES          TRUE
#define TAB_AUTO         2

#define WM_SETITEMDEFERRED WM_USER+6546

#define DC_SETITEM	10
#define DC_DELITEM	20
#define DC_EXPAND	30
#define DC_COLLAPSE	40

// Forward references

class TreeItemList;
class TreeItem;
class TreeWnd;

class FontSize;

// classes & structs
class CompareTreeItem {
public:
  static int compareItem(TreeItem *p1, TreeItem *p2);
};

class TreeItemList : public PtrListQuickSorted<TreeItem, CompareTreeItem> { };

class TreeItem 
{
friend class TreeWnd;
public:
  TreeItem(const wchar_t *label=NULL);
  virtual ~TreeItem();

  virtual SkinBitmap *getIcon();
  virtual void setIcon(SkinBitmap *newicon);

  virtual void onTreeAdd() {}
  virtual void onTreeRemove() {}
  virtual void onChildItemRemove(TreeItem *item) {}
  // override this to keep from being selected
  virtual int isHitTestable() { return 1; }
  virtual void onSelect() {}
  virtual void onDeselect() {}
  virtual int onLeftDoubleClick() { return 0; }
  virtual int onRightDoubleClick() { return 0; }
  virtual int onContextMenu(int x, int y);
  virtual int onChar(UINT key) { return 0; }	// return 1 if you eat the key

  // these are called after the expand/collapse happens
  virtual void onExpand() {}
  virtual void onCollapse() {}

  virtual int onBeginLabelEdit();
  virtual int onEndLabelEdit(const wchar_t *newlabel);

  virtual void setLabel(const wchar_t *label);
  virtual const wchar_t *getLabel();

  void setTip(const wchar_t *tip);
  const wchar_t *getTip();

  // override to draw by yourself. Return the width of what you've drawn
  virtual int customDraw(Canvas *canvas, const POINT &pt, int defaultTxtHeight, int indentation, const RECT &clientRect, const Wasabi::FontInfo *fontInfo); 

  // return 0 to refuse being dragged
  // else return 1 and install the droptype and dropitem
  // also, write suggested title into suggestedTitle if any
  virtual int onBeginDrag(wchar_t *suggestedTitle) { return 0; }

  virtual int dragOver(ifc_window *sourceWnd) { return 0; }
  virtual int dragLeave(ifc_window *sourceWnd) { return 0; }
  virtual int dragDrop(ifc_window *sourceWnd) { return 0; }

  virtual int dragComplete(int success) { return 0; }

  void ensureVisible();

  TreeItem *getNthChild(int nth); // enumerates children (zero based)
  TreeItem *getChild();
  TreeItem *getChildSibling(TreeItem *item);
  TreeItem *getSibling();
  TreeItem *getParent();

  void editLabel();
	
  int getNumChildren();
  bool hasSubItems();

  void setSorted(int issorted);
  void setChildTab(int haschildtab);
  bool isSorted();

  bool isCollapsed();
  bool isExpanded();

  void invalidate();
  bool isSelected();
  bool isHilited();
  void setHilited(bool ishilited);

  int collapse();
  int expand();

  int getCurRect(RECT *r);

  void setCurrent(bool tf);

  TreeWnd *getTree() const;

protected:

  bool isHilitedDrop();
  void setHilitedDrop(bool ishilitedDrop);

  void linkTo(TreeItem *linkto);
//  void childDeleted(TreeItem *child);
  void setTree(TreeWnd *newtree);
  void addSubItem(TreeItem *item);
  void setCurRect(int x1, int y1, int x2, int y2, int z);
  int getIndent();

  bool needTab();
  void sortItems(); // sorts the children of this item
  void setEdition(bool isedited);
  bool getEdition();

private:
  void setSelected(bool isselected, bool expandCollapse=false, bool editifselected=false);
  // this really calls delete on the subitems
  void deleteSubitems();

  int removeSubitem(TreeItem *item);

  int getItemWidth(int txtHeight, int indentation);

  StringW label;
  class TreeItem *parent;
  TreeItemList subitems;	// children
  RECT curRect;
  int childTab;
  TreeWnd *tree;
  int expandStatus;
  SkinBitmap *icon;
  int _z;
  StringW tooltip;	// if empty, falls back to livetip

  bool selected:1;
  bool hilitedDrop:1;
  bool hilited:1;
  bool being_edited:1;
};


/**
  
  
  @short Tree-like view with leaf items.
  @ver 1.0
  @author Nullsoft
  @see TreeItem
*/
class TreeWnd : public TREEWND_PARENT {

friend class TreeItem;

public:
	
	/**
	  Sets up the default values for the TreeWnd. These defaults are 
	  auto collapse enabled and sets the TreeWnd bitmaps to the default Wasabi
	  values.
	*/
  TreeWnd();
  
  /**
    Deletes all the root items (including subitems).
  */
  virtual ~TreeWnd();

  /**  
    Event is triggered when the button is about to be initialized.
    Override this event to implement your own behavior.
  
    @ret 1
  */
  virtual int onInit();
  
  /**
    Paints the bitmap on canvas according 
	  to current options (centering, tiling, stretching, title).

    @ret 0 for failure, 1 for success
    @param canvas The canvas on which to paint.
  */
  virtual int onPaint(Canvas *canvas);
  
  /**
    Notify a child window via a generic message system.

    @see addChild()
    @ret 
    @param child A pointer to the child window which will receive the notify.
    @param msg The message you want to send to the child.
    @param p1 A user parameter.
    @param p2 A user parameter.
  */
  virtual int childNotify(ifc_window *child, int msg, intptr_t param1=0, intptr_t param2=0);

  /**
    Event triggered when the left mouse
    button is pressed over the TreeWnd.
    
    Override this to implement your own behavior.
    
    Default behavior is to stop editing a TreeItem label
    (if editing was occuring). Also will cause a collapse
    or expansion of the subitems if an item was previously
    selected. 
    
    @ret 1, If you handle the event.
    @param x The X coordinate of the mouse.
    @param y The Y coordinate of the mouse.
  */
  virtual int onLeftButtonDown(int x, int y);
  
  /**
    Event is triggered when the left mouse button 
    is released from a previously pressed state.
    
    Override this to implement your own behavior.
    
    @ret 1, If you handle the event.
    @param x The X coordinate of the mouse.
    @param y The Y coordinate of the mouse.
  */
  virtual int onLeftButtonUp(int x, int y);
  
  /**
    Event is triggered when the right mouse button 
    is released from a previously pressed state.
    
    Override this to implement your own behavior.
    
    @ret 1, If you handle the event.
    @param x The X coordinate of the mouse.
    @param y The Y coordinate of the mouse.
  */
  virtual int onRightButtonUp(int x, int y);
  
  /**
    Event is triggered when the mouse is moved 
    over the TreeWnd.
    
    Override this to implement your own behavior.
    
    Default is to handle drops (drag and drop).
    
    @ret 1, If you handle the event.
    @param x The X coordinate of the mouse.
    @param y The Y coordinate of the mouse.
  */
  virtual int onMouseMove(int x, int y);
  
  /**
    Do we want the context command menu to pop-up
    on right clicks?
    
    Default is no.
    
    @see ContextCmdI
    @ret 0, AutoContextMenu off; 1, AutoContextMenu on;
  */
  virtual int wantAutoContextMenu() { return 0; }

  /**
    Event is triggered when the left mouse button
    is double clicked and the cursor is over the
    TreeWnd.
    
    Default is to check if the doubleclick
    happened over an item, if it did, it calls
    the item's handler of this event.
    
    @ret 1, if you handle the event.
    @param x The X coordinate of the mouse.
    @param y The Y coordinate of the mouse.
  */
  virtual int onLeftButtonDblClk(int x, int y);
  
  /**
    Event is triggered when the right mouse button
    is double clicked and the cursor is over the
    TreeWnd.
    
    Default is to check if the doubleclick
    happened over an item, if it did, it calls
    the item's handler of this event.
    
    @ret 1, If you handle the event.
    @param x The X coordinate of the mouse.
    @param y The y coordinate of the mouse.
  */
  virtual int onRightButtonDblClk(int x, int y);

  /**
    Event is triggered when the mouse wheel 
    is rolled up.
    
    Override this to implement your own behavior.
    
    Default is to scroll vertically as required.
    When the wheel is clicked and rolled, the
    TreeWnd is scrolled horizontally.
    
    @ret 1, If you handle the event.
    @param clicked The pushed state of the mouse wheel.
    @param lines The number of lines to scroll (or columns if horizontally scrolling).
  */
  virtual int onMouseWheelUp(int clicked, int lines);
  
  /**
    Event is triggered when the mouse wheel 
    is rolled down.
    
    Override this to implement your own behavior.
    
    Default is to scroll vertically as required.
    When the wheel is clicked and rolled, the
    TreeWnd is scrolled horizontally.
    
    @ret 1, If you handle the event.
    @param clicked The pushed state of the mouse wheel.
    @param lines The number of lines to scroll (or columns if horizontally scrolling).
  */
  virtual int onMouseWheelDown(int clicked, int lines);
  
  /**
  */
  virtual void timerCallback(int c);

  /**
    Event is triggered when the right click occurs over 
    the TreeWnd, but not on a TreeItem.
    
    Override this to implement your own behavior.
        
    @ret 1, If you handle the event.
    @param x The X coordinate of the mouse.
    @param y The Y coordinate of the mouse.
  */
  virtual int onContextMenu(int x, int y);

  // override and return 1 to abort calling context menu on item
  virtual int onPreItemContextMenu(TreeItem *item, int x, int y) { return 0; }
  // override to catch when item context menu complete
  virtual void onPostItemContextMenu(TreeItem *item, int x, int y, int retval) { }
  
  /**
    Event is triggered when a scheduled deferred callback
    occurs.
    
    Override this to implement your own behavior.
    
    @ret 1, If you handle this event; 0, If you do not handle this event;
    @param param1 Generic user paramater 1.
    @param param2 Generic user paramater 2.
  */
  virtual int onDeferredCallback(intptr_t param1, intptr_t param2);

  /**
    Event is triggered when a key is pressed
    and the TreeWnd has focus.
    
    Override this to implement your own behavior.
    
    @ret 1, If you handle the event.
    @param c The key that was pressed.
  */
  virtual int onChar(unsigned int c);
  
  /**
    Event is triggered when a key is pressed
    and the TreeWnd has focus.
    
    This method handles extended keys.
    
    @ret 1, If you handle the event.
  */
  virtual int onKeyDown(int keycode);
  
  /**
    
  */
  virtual void jumpToNext(wchar_t c);
  
  /**
    Verifies if the item received is in the 
    viewable area of the TreeWnd. If not, it
    will make it visible by scrolling to the
    appropriate position.
    
    @param item A pointer to the item to verify.
  */
  void ensureItemVisible(TreeItem *item);

  // don't need to override this: just calls thru to the treeitem
  virtual int onBeginDrag(TreeItem *treeitem);

  virtual int dragEnter(ifc_window *sourceWnd);
  virtual int dragOver(int x, int y, ifc_window *sourceWnd);
  virtual int dragLeave(ifc_window *sourceWnd);
  virtual int dragDrop(ifc_window *sourceWnd, int x, int y);

  virtual int dragComplete(int success);

  int wantFocus() { return 1; }

  // override this if you want to control the item sort order
  virtual int compareItem(TreeItem *p1, TreeItem *p2);

protected:
  // these will be called if the pointer is not over a treeitem
  virtual int defaultDragOver(int x, int y, ifc_window *sourceWnd) { return 0; }
  virtual int defaultDragDrop(ifc_window *sourceWnd, int x, int y) { return 0; }

  // called with item that received a drop
  virtual void onItemRecvDrop(TreeItem *item) {}

  virtual void onLabelChange(TreeItem *item) {}

  virtual void onItemSelected(TreeItem *item) {}
  virtual void onItemDeselected(TreeItem *item) {}

  virtual int onGetFocus();
  virtual int onKillFocus();

public:

  virtual int getContentsWidth();
  virtual int getContentsHeight();

  void setRedraw(bool r);

  TreeItem *addTreeItem(TreeItem *item, TreeItem *par=NULL, int sorted=TRUE, int haschildtab=FALSE);

  // just removes a TreeItem from the tree, doesn't delete it... this is for
  // ~TreeItem to call only
  int removeTreeItem(TreeItem *item);

  void moveTreeItem(TreeItem *item, TreeItem *newparent);

  void deleteAllItems();

  int expandItem(TreeItem *item);
  void expandItemDeferred(TreeItem *item);
  int collapseItem(TreeItem *item);
  void collapseItemDeferred(TreeItem *item);

  void selectItem(TreeItem *item);	// selects.
  void selectItemDeferred(TreeItem *item);// selects. posted.
  void delItemDeferred(TreeItem *item);
  void hiliteItem(TreeItem *item);
  void unhiliteItem(TreeItem *item);
  void setHilitedColor(const wchar_t *colorname);
  ARGB32 getHilitedColor();

  TreeItem *getCurItem();

  TreeItem *hitTest(POINT pos);
  TreeItem *hitTest(int x, int y);

  void editItemLabel(TreeItem *item);
  void cancelEditLabel(int destroyit=0);
  void setAutoEdit(int ae);
  int getAutoEdit();
  // use a NULL item to search all items. returns first item found
  TreeItem *getByLabel(TreeItem *item, const wchar_t *name);

  int getItemRect(TreeItem *item, RECT *r);

  int ownerDraw();

  int getNumRootItems();
  TreeItem *enumRootItem(int which);

  void setSorted(bool dosort);
  bool getSorted();

  void sortTreeItems();

  TreeItem *getSibling(TreeItem *item);

  TreeItem *getItemFromPoint(POINT *pt);

  void setAutoCollapse(bool doautocollapse);

  virtual int setFontSize(int newsize);
  int getFontSize();

  int getNumVisibleChildItems(TreeItem *c);
  int getNumVisibleItems();
  TreeItem *enumVisibleItems(int n);
  TreeItem *enumVisibleChildItems(TreeItem *c, int n);
  int findItem(TreeItem *i); // reverse
  int findChildItem(TreeItem *c, TreeItem *i, int *n);

  TreeItem *enumAllItems(int n);	// unsorted

  void onSelectItem(TreeItem *i);
  void onDeselectItem(TreeItem *i);

protected:
  void hiliteDropItem(TreeItem *item);  
  void unhiliteDropItem(TreeItem *item);
  void invalidateMetrics();

private:
  TreeItemList items;	// root-level stuff

  PtrList<TreeItem> all_items;	// unsorted

  TreeItem *curSelected;

	BltCanvas *dCanvas;

	void drawItems(Canvas *c, const Wasabi::FontInfo *fontInfo);
  void setCurItem(TreeItem *item, bool expandCollapse=true, bool editifselected=false);
  void countSubItems(PtrList<TreeItem> &drawlist, TreeItemList *list, int indent, int *c, int *m, int z);
  void getMetrics(int *numItemsShow, int *maxWidth);
  void ensureMetricsValid();
  int getLinkLine(TreeItem *item, int level);
  void endEditLabel(const wchar_t *newlabel);
  void editUpdate();
  int jumpToNextSubItems(TreeItemList *list, wchar_t c);

  int itemHeight;

  AutoSkinBitmap tabClosed, tabOpen;
  AutoSkinBitmap linkTopRight, linkTopBottom, linkTopRightBottom;
  AutoSkinBitmap linkTabTopRight, linkTabTopBottom, linkTabTopRightBottom;
  
  TreeItem *firstItemVisible;
  TreeItem *lastItemVisible;

  TreeItem *mousedown_item, *prevbdownitem;
  POINT mousedown_anchor;
  bool mousedown_dragdone;
  TreeItem *hitItem,		// the dest item
           *draggedItem;	// the source item

  int inHitTest;

  bool metrics_ok;
  int maxWidth;
  int maxHeight;

  StringW defaultTip;

  const wchar_t *getLiveTip();
  void setLiveTip(const wchar_t *tip);
  TreeItem *tipitem;

  bool redraw;

  PtrList<TreeItem> drawList;
  TreeItem *edited;

  EditWnd *editwnd;
  wchar_t editbuffer[256];

  int deleteItems;
  bool firstFound;

  TreeItem *currentItem;
  StringW hilitedColorName;
  SkinColor hilitedColor;
  int autoedit;
  int autocollapse;
  int textsize;
  StringW oldtip;
  StringW accValue;
};

template<class T> class TreeItemParam : public TreeItem {
public:
  TreeItemParam(T _param, const wchar_t *label=NULL) : TreeItem(label) { param = _param; }

  T getParam() { return param; }
  operator T() { return getParam(); }

private:
  T param;
};

#endif