From 4cbcabff5f0612db5ec10cd62155236bf099bd07 Mon Sep 17 00:00:00 2001 From: John Scipione Date: Thu, 25 Apr 2013 17:58:13 -0400 Subject: [PATCH] Add documentation for BListView and BListItem classes --- docs/user/interface/ListItem.dox | 205 ++++ docs/user/interface/ListView.dox | 943 ++++++++++++++++++ .../interface/images/BListView_example.png | Bin 0 -> 19024 bytes 3 files changed, 1148 insertions(+) create mode 100644 docs/user/interface/ListItem.dox create mode 100644 docs/user/interface/ListView.dox create mode 100644 docs/user/interface/images/BListView_example.png diff --git a/docs/user/interface/ListItem.dox b/docs/user/interface/ListItem.dox new file mode 100644 index 0000000000..0c6319e6a8 --- /dev/null +++ b/docs/user/interface/ListItem.dox @@ -0,0 +1,205 @@ +/* + * Copyright 2013 Haiku Inc. All rights reserved. + * Distributed under the terms of the MIT License. + * + * Authors: + * John Scipione, jscipione@gmail.com + * + * Corresponds to: + * headers/os/interface/ListItem.h hrev45555 + * src/kits/interface/ListItem.cpp hrev45555 + */ + + +/*! + \file ListItem.h + \ingroup interface + \ingroup libbe + \brief ListItem class definition. +*/ + + +/*! + \class BListItem + \ingroup interface + \ingroup libbe + \brief A list item, a member of a BListView or BOutlineListView. +*/ + + +/*! + \fn BListItem::BListItem(uint32 level, bool expanded) + \brief Create a new list item with the specified \a level. + + The \a level and \a expanded arguments are only used if the item is added to + a BOutlineListView. + + \param level The level to create the list item on, default level is 0. + \param expanded Whether or not the item is expanded. + + \see BOutlineListView::AddItem() +*/ + + +/*! + \fn BListItem::BListItem(BMessage* data) + \brief Create a new list item from archived message. + + \param data The message to create the list item from. +*/ + + +/*! + \fn BListItem::~BListItem() + \brief Destroy the list item freeing any memory used. + + The default destructor is empty. +*/ + + +/*! + \fn status_t BListItem::Archive(BMessage* archive, bool deep) const + \brief Archive the list item to a message. + + \param archive The message to archive the list item to. + \param deep If \c true also archive child views. +*/ + + +/*! + \fn void DrawItem(BView* owner, BRect frame, bool complete) + \brief Hook method called when the item is drawn. + + \param owner The view that the list item is a child of. + \param frame The frame of the item. + \param complete Whether or not to draw the background in addition to the + item's contents. +*/ + + +/*! + \fn float BListItem::Height() const + \brief Return the height of the list item. + + \return The height of the list item as a float. +*/ + + +/*! + \fn float BListItem::Width() const + \brief Return the width of the list item. + + \return The width of the list item as a float. +*/ + + +/*! + \fn bool BListItem::IsSelected() const + \brief Return whether or not the list item is currently selected. + + \return \c true if the list item is selected, \c false otherwise. +*/ + + +/*! + \fn void BListItem::Select() + \brief Select the list item. +*/ + + +/*! + \fn void BListItem::Deselect() + \brief Unselect the list item. +*/ + + +/*! + \fn void BListItem::SetEnabled(bool on) + \brief Enable or disable the list item. + + \param on Set \c true to enable, \c false to disable the list item. +*/ + + +/*! + \fn bool BListItem::IsEnabled() const + \brief Returns whether or not the list item is currently enabled. + + \return \c true if the list item is enabled, \c false if it is disabled. +*/ + + +/*! + \fn void BListItem::SetHeight(float height) + \brief Set the height of the list item to \a height. + + \param height The height to set the list item to. +*/ + + +/*! + \fn void BListItem::SetWidth(float width) + \brief Set the width of the list item to \a width. + + \param width The width to set the list item to. +*/ + + +/*! + \fn void BListItem::Update(BView* owner, const BFont* font) + \brief Hook method that's called with the list item's \a owner changes. + + This method gets called when the list item is added to the list view. + + The default implementation sets the width of the list item to the width of + \a owner and sets the height to fit \a font. + + \param owner The list item's new \a owner. + \param font The font set to the list item's current \a owner. +*/ + + +/*! + \fn status_t BListItem::Perform(perform_code d, void* arg) + \brief Performs an action give a perform_code and arg. (Internal Method) + + \param d The perform code. + \param arg A pointer to some data to perform on. + + \return A status code. +*/ + + +/*! + \fn void BListItem::SetExpanded(bool expanded) + \brief Set the expanded state of the list item. This only makes sense if the + list item is part of a BOutlineListView. + + \param expanded \c true to expand the list item, \c false to un-expand the + list item. +*/ + + +/*! + \fn bool BListItem::IsExpanded() const + \brief Returns whether or not the list item is currently expanded. + + \return \c true if the list item is expanded, \c false if it is not expanded. +*/ + + +/*! + \fn uint32 BListItem::OutlineLevel() const + \brief Returns the current outline level of the list item. This only makes + sense if the list item is part of a BOutlineListView. + + \return The current outline level of the list item. +*/ + + +/*! + \fn void BListItem::SetOutlineLevel(uint32 level) + \brief Set the outline level of the list item. + + \param level The outline level to set the list item to. +*/ diff --git a/docs/user/interface/ListView.dox b/docs/user/interface/ListView.dox new file mode 100644 index 0000000000..69475e312f --- /dev/null +++ b/docs/user/interface/ListView.dox @@ -0,0 +1,943 @@ +/* + * Copyright 2013 Haiku Inc. All rights reserved. + * Distributed under the terms of the MIT License. + * + * Authors: + * John Scipione, jscipione@gmail.com + * + * Corresponds to: + * headers/os/interface/ListView.h hrev45555 + * src/kits/interface/ListView.cpp hrev45555 + */ + + +/*! + \file ListView.h + \ingroup interface + \ingroup libbe + \brief ListView class definition. +*/ + + +/*! + \class BListView + \ingroup interface + \ingroup libbe + \brief Displays a list of items that the user can select and invoke. + + BListView's can be one of two types set by the type parameter of the constructor: + - \c B_SINGLE_SELECTION_LIST Can select only one item in the list at a time. + This is the default. + - \c B_MULTIPLE_SELECTION_LIST Can select any number of items by holding down + Option for a discontinuous selection, or Shift for a contiguous selection. + + An example of a BListView looks like this: + \image html BListView_example.png + + Click on an item to select it and double-click an item to invoke it. The + BListView doesn't define what it means to "invoke" an item. See + BListView::SetSelectionMessage() and BListView::SetInvocationMessage() to set + a message to be set when these actions occur. You can also select and invoke + items with keyboard keys such as the up and down arrow keys, Page Up and Page + Down and the Enter key or Space key to invoke the item. + + This class is based on the BList class from the Support Kit and many of the + methods it uses behave similarly. + + Although a BListView is scrollable, it doesn't provide scroll bars by itself. + You should add the BListView as a child of a BScrollView to make it scrollable. + + The code to add a BListView to a BScrollView looks something like this: + +\code + BListView* list = new BListView(frame, "List", B_SINGLE_SELECTION_LIST); + list->AddItem(new BStringItem("Item 1")); + list->AddItem(new BStringItem("Item 2")); + ... + view->AddChild(new BScrollView("scroll_view", list, + B_FOLLOW_LEFT | B_FOLLOW_TOP, 0, false, true)); +\endcode + + \see BScrollView for more information on scrolling views. + \see BList in the Support Kit. + \see BOutlineListView + \see BListItem +*/ + + +/*! + \fn BListView::BListView(BRect frame, const char* name, list_view_type type, + uint32 resizingMode, uint32 flags) + \brief Creates a new list view. This is the non-layout constructor. + + \param frame The frame rectangle of the view. + \param name The name of the view. + \param type Whether the list view supports a single selection or multiple + selections. + \param resizingMode The resizing mode flags. + \param flags The view flags. +*/ + + +/*! + \fn BListView::BListView(const char* name, list_view_type type, uint32 flags) + \brief Creates a new list view suitable as part of a layout with the specified + \a name, \a type, and \a flags. + + \param name The name of the view. + \param type Whether the list view supports a single selection or multiple + selections. + \param flags The view flags. +*/ + + +/*! + \fn BListView::BListView(list_view_type type) + \brief Creates a new list view suitable as part of a layout. + + \param type Whether the list view supports a single selection or multiple + selections. +*/ + + +/*! + \fn BListView::BListView(BMessage* archive) + \brief Creates a list view from an \a archive message. + + \param archive The message to create the list view from. +*/ + + +/*! + \fn BListView::~BListView() + \brief Delete the list view and free the memory used. + + This method does not free the list items. +*/ + + +/*! + \name Archiving +*/ + + +//! @{ + + +/*! + \fn BArchivable* BListView::Instantiate(BMessage* archive) + \brief Create a new list view from the message \a archive. + + \param archive The message to create the list view from. +*/ + + +/*! + \fn status_t BListView::Archive(BMessage* archive, bool deep) const + \brief Archive the list view to a message. + + \param archive The message to archive the list view to. + \param deep \c true to archive child views. +*/ + + +//! @} + + +/*! + \name Hook methods +*/ + + +//! @{ + + +/*! + \fn void BListView::Draw(BRect updateRect) + \brief Hook method called to draw the contents of the text view. + + You should not have to call this method directly, use Invalidate() instead. + + \param updateRect The rectangular area to draw. + + \see BView::Draw() +*/ + + +/*! + \fn void BListView::AttachedToWindow() + \brief Hook method called when the list view is added to the view hierarchy. + + \see BView::AttachedToWindow() +*/ + + +/*! + \fn void BListView::DetachedFromWindow() + \brief Hook method that is called when the list view is removed from the + view hierarchy. + + \see BView::DetachedFromWindow() +*/ + + +/*! + \fn void BListView::AllAttached() + \brief Hook method called once all views are attached to the view. + + \see BView::AllAttached() +*/ + + +/*! + \fn void BListView::AllDetached() + \brief Hook method called once all views are detached from the view. + + \see BView::AllDetached() +*/ + + +/*! + \fn void BListView::FrameResized(float width, float height) + \brief Hook method called when the list view is resized. + + \param width The new \a width of the list view. + \param height The new \a height of the list view. + + \see BView::FrameResized() +*/ + + +/*! + \fn void BListView::FrameMoved(BPoint new_position) + \brief Hook method called when the list view is moved. + + \param new_position The list view's new position. +*/ + + +/*! + \fn void BListView::TargetedByScrollView(BScrollView *view) + \brief Hook method called when the list view is attached to a BScrollView. + + \param view The BScrollView the list view is attached to. +*/ + + +/*! + \fn void BListView::WindowActivated(bool state) + \brief Hook method that is called when the window becomes the active window + or gives up that status. + + \param state If \c true, window has just been activated. If \c false the + window has just been deactivated. + + \see BView::WindowActivated() +*/ + + +/*! + \fn void BListView::MessageReceived(BMessage* message) + \brief Hook method called with a message is received by the list view. + + \param message The message received by the list view. + + \see BView::MessageReceived() +*/ + + +/*! + \fn void BListView::KeyDown(const char* bytes, int32 numBytes) + \brief Hook method that is called when a key is pressed while the view is + the focus view of the active window. + + The following keys are used by the list view by default: + - Up Arrow Selects the previous item. + - Down Arrow Selects the next item. + - Page Up Selects the item one view height above the current item. + - Page Down Selects the item one view height below the current item. + - Home Selects the first item in the list. + - End Select the last item in the list. + - Enter and Spacebar Invokes the currently selected item. + + \param bytes The \a bytes representing the keys pushed down. + \param numBytes The size of \a bytes. + + \see BView::KeyDown() +*/ + + +/*! + \fn void BListView::KeyUp(const char* bytes, int32 numBytes) + \brief Hook method that is called when a keyboard key is released. + + \param bytes The \a bytes representing the keys released. + \param numBytes The size of \a bytes. + + \see BView::KeyUp() +*/ + + +/*! + \fn void BListView::MouseDown(BPoint point) + \brief Hook method that is called when a mouse button is pushed down while + the cursor is contained in the view. + + By default this method selects items on a single click, and invokes them on a + double click. This method calls InitiateDrag() to allow derived classes the + opportunity to drag and drop items from the list. + + \param point The \a point where the mouse button was pushed down. + + \see BView::MouseDown() +*/ + + +/*! + \fn void BListView::MouseUp(BPoint where) + \brief Hook method that is called when a mouse button is released while + the cursor is contained in the view. + + \param where The location that the mouse button was released. + + \see BView::MouseUp() +*/ + + +/*! + \fn void BListView::MouseMoved(BPoint where, uint32 code, + const BMessage* dragMessage) + \brief Hook method that is called whenever the mouse cursor enters, exits + or moves inside the list view. + + \param where The point where the mouse cursor has moved to. + \param code A code which indicating if the mouse entered or exited the view. + \param dragMessage A message containing drag and drop information. + + \see BView::MouseMoved() +*/ + + +/*! + \fn bool BListView::InitiateDrag(BPoint point, int32 index, bool wasSelected) + \brief Hook method called when a drag and drop operation is initiated. + + This method is used by derived classes to implement drag and drop. This method + is called by the MouseDown() method. If the derived class initiates the drag & + drop operation you should return \c true, otherwise return \c false. By default + this method returns \c false. + + \param point Where the drag & drop operation started. + \param index + \param wasSelected Indicates whether or not the item was selected. + + \returns \c true if a drag & drop operation was initiated, \c false if not. +*/ + + +/*! + \fn void BListView::SelectionChanged() + \brief Hook method that is called when the selection changes. + + This method should be implemented by derived classes, the default + implementation does nothing. +*/ + + +//! @} + + +/*! + \name Resize methods +*/ + + +//! @{ + + +/*! + \fn void BListView::ResizeToPreferred() + \brief Resize the view to it's preferred size. + + \see BView::ResizeToPreferred() +*/ + + +/*! + \fn void BListView::GetPreferredSize(float *_width, float *_height) + \brief Fill out the \a _width and \a _height parameters with the preferred + width and height of the list view. + + \param _width The list view's preferred width is written to \a _width. + \param _height The list view's preferred height is written to \a _height. + + \see BView::GetPreferredSize() +*/ + + +/*! + \fn BSize BListView::MinSize() + \brief Returns the minimum size of the list view. + + \return The minimum size of the list view as a BSize. + + \see BView::MinSize() +*/ + + +/*! + \fn BSize BListView::MaxSize() + \brief Returns the maximum size of the list view. + + \return The maximum size of the list view as a BSize. + + \see BView::MaxSize() +*/ + + +/*! + \fn BSize BListView::PreferredSize() + \brief Returns the preferred size of the list view. + + \return The preferred size of the list view as a BSize. + + \see BView::PreferredSize() +*/ + + +//! @} + + +/*! + \fn void BListView::MakeFocus(bool focused) + \brief Highlight or unhighlight the selection when the list view acquires + or loses its focus state. + + \param focused \c true to receive focus or \c false to lose it. + + \see BView::MakeFocus() +*/ + + +/*! + \fn void BListView::SetFont(const BFont* font, uint32 mask) + \brief Sets the font of the list view to \a font with the font parameters set + by \a mask. + + \param font The \a font to set the list view to. + \param mask A \a mask indicating which properties of \a font to set. + + \see BView::SetFont() +*/ + + +/*! + \fn void BListView::ScrollTo(BPoint point) + \brief Scroll the view to the specified \a point. + + \param point The location to scroll the list view to. + + \see BView::ScrollTo() +*/ + + +/*! + \name Add and remove item methods +*/ + + +//! @{ + + +/*! + \fn bool BListView::AddItem(BListItem *item, int32 index) + \brief Add an \a item to the list view at the specified \a index. + + \param item The list item to add. + \param index The \a index of where to add the list item, if not specified the + item is added to the end. + + \return \c true if the list item was added, \c false otherwise. +*/ + + +/*! + \fn bool BListView::AddList(BList* list, int32 index) + \brief Add a \a list of list items to the list view at the specified \a index. + + \param list The \a list of list items to add. + \param index The \a index of where to add the list, if not specified the + \a list is added to the end. + + \return \c true if the \a list was added, \c false otherwise. +*/ + + +/*! + \fn bool BListView::AddList(BList* list) + \fn Add a \a list of list items to the end of the list view. + + \param list The \a list of list items to add. + + \return \c true if the \a list was added, \c false otherwise. +*/ + + +/*! + \fn BListItem* BListView::RemoveItem(int32 index) + \brief Remove the item at \a index from the list. + + \param index The \a index of the item to remove. + + \return \c true if the item was removed, \c false otherwise. +*/ + + +/*! + \fn bool BListView::RemoveItem(BListItem* item) + \brief Remove the specified list item. + + \param item The list item to remove. + + \return \c true if the \a item was removed, \c false otherwise. +*/ + + +/*! + \fn bool BListView::RemoveItems(int32 index, int32 count) + \brief Removes the items from \a index and the next \a count items. + + \param index The location to start removing items from. + \param count The number of items past \a index to remove. + + return \c true if the \a items were removed, \c false otherwise. +*/ + + +//! @} + + +/*! + \name Selection and Invocation message methods +*/ + + +//! @{ + + +/*! + \fn void BListView::SetSelectionMessage(BMessage* message) + \brief Sets the \a message that the list view sends when a new item is selected. + + \param message The selection \a message to set. +*/ + + +/*! + \fn void BListView::SetInvocationMessage(BMessage* message) + Sets the \a message that the list view sends when an item is invoked. + + \param message The invocation \a message to set. + + \see BInvoker::SetMessage() +*/ + + +/*! + \fn BMessage* BListView::InvocationMessage() const + \brief Returns the message that is send when an item is invoked. + + \return The current invocation method as a BMessage. + + \see BInvoker::Message() +*/ + + +/*! + \fn uint32 BListView::InvocationCommand() const + \brief Returns the what parameter of the current invocation method. + + \returns The what parameter of the currently set invocation method. + + \see BInvoker::Command() +*/ + + +/*! + \fn BMessage* BListView::SelectionMessage() const + \brief Returns the message that is send when an item is selected. + + \return The current selection message as a BMessage. +*/ + + +/*! + \fn uint32 BListView::SelectionCommand() const + \brief Returns the what parameter of the message that is send when an item is + selected. + + \return The what parameter of the current selection message. +*/ + + +//! @} + + +/*! + \name List type methods +*/ + + +//! @{ + + +/*! + \fn void BListView::SetListType(list_view_type type) + \brief Sets the list view \a type. + + \param type The list view \a type to set. +*/ + + +/*! + \fn list_view_type BListView::ListType() const + \brief Returns the current list view type. + + \return The list view type. +*/ + + +//! @} + + +/*! + \name List methods +*/ + + +//! @{ + + +/*! + \fn BListItem* BListView::ItemAt(int32 index) const + \brief Returns the list item at the specified \a index. + + \param index + + \return The list item at the specified \a index. +*/ + + +/*! + \fn int32 BListView::IndexOf(BListItem* item) const + \brief Returns the index of the specified \a item. + + \param item The list item to get the index of. + + \return The index of the specified \a item. +*/ + + +/*! + \fn int32 BListView::IndexOf(BPoint point) const + \brief Returns the index of the item at the specified \a point. + + \param point The location of the list item to get the index of. + + \return The index of the list item at the specified \a point. +*/ + + +/*! + \fn BListItem* BListView::FirstItem() const + \brief Returns the first list item. + + \return The first item in the list. +*/ + + +/*! + \fn BListItem* BListView::LastItem() const + \brief Returns the last list item. + + \return The last item in the list. +*/ + + +/*! + \fn bool BListView::HasItem(BListItem *item) const + \brief Returns whether or not the list contains the specified \a item. + + \param item The list item to check. + + \return \c true if the list item is contained in the list view, \c false + otherwise. +*/ + + +/*! + \fn int32 BListView::CountItems() const + \brief Returns the number of list items contained in the list view. + + \return The number of list items. +*/ + + +/*! + \fn void BListView::MakeEmpty() + \brief Empties the list view of all list items. +*/ + + +/*! + \fn bool BListView::IsEmpty() const + \brief Returns whether or not the list view is empty or not. + + \return \c true if the list view was empty, \c false otherwize. +*/ + + +/*! + \fn void BListView::DoForEach(bool (*func)(BListItem*)) + \brief Calls the specified function on each item in the list. + + The \a func is called on the items in order starting with the item at index 0 + and ending at the last item in the list. This method stops calling the \a func + once it returns \a true or the end of the list is reached. + + The first argument of \a func is a pointer to the list item. + + \param func The function to call on each item. +*/ + + +/*! + \fn void BListView::DoForEach(bool (*func)(BListItem*, void*), void* arg) + \brief Calls the specified function on each item in the list. + + The \a func is called on the items in order starting with the item at index 0 + and ending at the last item in the list. This method stops calling the \a func + once it returns \a true or the end of the list is reached. + + The first argument of \a func is a pointer to the list item, \a arg is passed in + as the second argument. + + \param func The function to call on each item. +*/ + + +/*! + \fn const BListItem** BListView::Items() const + \brief Returns a pointer to the list of list items. + + \returns a pointer to the list of list items. +*/ + + +//! @} + + +/*! + \fn void BListView::InvalidateItem(int32 index) + \brief Draws the list item at the specified \a index. + + \param index The \a index of the list item to draw. +*/ + + +/*! + \name Selection methods +*/ + + +//! @{ + + +/*! + \fn void BListView::ScrollToSelection() + \brief Scrolls to selected list item. +*/ + + +/*! + \fn void BListView::Select(int32 index, bool extend) + \brief Selects the list item at the specified \a index. + + \param index The \a index of the item to select. + \param extend Whether or not to also select child items. +*/ + + +/*! + \fn void BListView::Select(int32 start, int32 finish, bool extend) + \brief Select items from \a start to \a finish. + + \param start The index of the item to start the selection. + \param finish The index of the item to end the selection. + \param extend Whether or not to also select child items. +*/ + + +/*! + \fn bool BListView::IsItemSelected(int32 index) const + \brief Returns whether or not the item at \a index is selected. + + \return \c true if the item was selected, \c false otherwise. +*/ + + +/*! + \fn int32 BListView::CurrentSelection(int32 index) const + \brief Returns the index of a currently selected item relative to the passed + in \a index. + + If the index of the selected item is lower than \a index the value returned + is negative, if the index of the selected item is greater than \a index the + value returned is positive. If the index of the selected item is equal to + \a index then 0 is returned. + + \brief index The \a index of the item to get relative to the selected item's + index. +*/ + + +//! @} + + +/*! + \fn status_t BListView::Invoke(BMessage* message) + \brief Invoke the list view, either with the current invocation message or + \a message if it is specified. + + \param message The message to send or \c NULL to send the current invocation + message. + + \see BControl::Invoke() +*/ + + +/*! + \name Deselection methods +*/ + + +//! @{ + + +/*! + \fn void BListView::DeselectAll() + \brief Deselect all items. +*/ + + +/*! + \fn void BListView::DeselectExcept(int32 exceptFrom, int32 exceptTo) + \brief Deselect all items except the items with index in the range of + \a exceptFrom to \a exceptTo. + + \param exceptFrom The index of the start of the exception list. + \param exceptTo The index of the end of the exception list. +*/ + + +/*! + \fn void BListView::Deselect(int32 index) + \brief Deselect the item at \a index. + + \param index The \a index of the item to deselect. +*/ + + +//! @} + + +/*! + \fn void BListView::SortItems(int (*cmp)(const void *, const void *)) + \brief sort the items according the the passed in \a cmp function. + + \param cmp The compare function to use to sort the items. +*/ + + +/*! + \fn bool BListView::SwapItems(int32 a, int32 b) + \brief Swap item \a a with item \a b. + + \param a The index of the first item to swap. + \param b The index of the second item to swap. + + \return \c true if the items were swapped, \c false otherwise. +*/ + + +/*! + \fn bool BListView::MoveItem(int32 from, int32 to) + \brief Move the item at index \a from to the position in the list at index \a to. + + \param from The index of the item to move. + \param to The index to move the item to. + + \return \c true if the item was moved, \c false otherwise. +*/ + + +/*! + \fn bool BListView::ReplaceItem(int32 index, BListItem* item) + \brief Replace the item at index \a index with \a item. + + \param index The \a index of the item to replace. + \param item The \a item to replace the item at \a index with. + + \return \c true if the item was replaced, \c false otherwise. +*/ + + +/*! + \fn BRect BListView::ItemFrame(int32 index) + \brief Return the frame of the item at the specified \a index. + + \param index The \a index of the item to get the frame of. + + \returns The frame of the item at \a index. +*/ + + +/*! + \fn BHandler* BListView::ResolveSpecifier(BMessage* message, int32 index, + BMessage* specifier, int32 form, const char* property); + \brief Returns the proper handler for the passed in scripting \a message. + + \param message The scripting message to determine the handler. + \param index The index of the specifier. + \param specifier The message which contains the specifier. + \param form The 'what' field of the specifier message. + \param property The name of the target property. + + \return The proper BHandler for the passed in scripting \a message. + + \see BView::ResolveSpecifier() +*/ + + +/*! + \fn status_t BListView::GetSupportedSuites(BMessage* data) + \brief Reports the suites of messages and specifiers that derived classes + understand. + + \param data The message to report the suite of messages and specifiers. + + \see BView::GetSupportedSuites() +*/ + + +/*! + \fn status_t BListView::Perform(perform_code code, void* _data) + \brief Performs an action give a perform_code and data. (Internal Method) + + \param code The perform code + \param _data A pointer to some data to perform on + + \return A status code. + + \see BView::Perform() +*/ diff --git a/docs/user/interface/images/BListView_example.png b/docs/user/interface/images/BListView_example.png new file mode 100644 index 0000000000000000000000000000000000000000..59ae635cb6b33fe92eb3e042af2e0b2172bd0b87 GIT binary patch literal 19024 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