finalcut/include/final/flistbox.h

536 lines
17 KiB
C
Raw Normal View History

2017-11-04 07:03:53 +01:00
/***********************************************************************
* flistbox.h - Widget FListBox and FListBoxItem *
* *
* This file is part of the Final Cut widget toolkit *
* *
* Copyright 2014-2018 Markus Gans *
2017-11-04 07:03:53 +01:00
* *
* The Final Cut is free software; you can redistribute it and/or *
* modify it under the terms of the GNU Lesser General Public License *
* as published by the Free Software Foundation; either version 3 of *
* the License, or (at your option) any later version. *
* *
* The Final Cut is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU Lesser General Public *
* License along with this program. If not, see *
* <http://www.gnu.org/licenses/>. *
***********************************************************************/
/* Inheritance diagram
*
*
*
* FTerm
*
*
*
*
* FVTerm FObject
*
*
*
*
*
*
* FWidget
*
*
*
* 1 *
* FListBox - - - - FListBoxItem
*
*
*/
2015-05-23 13:35:12 +02:00
#ifndef FLISTBOX_H
#define FLISTBOX_H
2015-05-23 13:35:12 +02:00
#if !defined (USE_FINAL_H) && !defined (COMPILE_FINAL_CUT)
#error "Only <final/final.h> can be included directly."
#endif
2017-09-11 03:06:02 +02:00
#include <vector>
#include "final/fscrollbar.h"
#include "final/fstring.h"
#include "final/fwidget.h"
2015-05-23 13:35:12 +02:00
//----------------------------------------------------------------------
// class FListBoxItem
//----------------------------------------------------------------------
#pragma pack(push)
#pragma pack(1)
class FListBoxItem
{
2017-09-11 03:06:02 +02:00
public:
// Constructors
FListBoxItem ();
FListBoxItem (const FListBoxItem&); // copy constructor
explicit FListBoxItem (const FString&, FWidget::data_ptr = 0);
// Destructor
virtual ~FListBoxItem();
// Assignment operator (=)
FListBoxItem& operator = (const FListBoxItem&);
// Accessors
virtual FString& getText();
virtual FWidget::data_ptr getData() const;
// Mutators
void setText (const FString&);
void setData (FWidget::data_ptr);
// Methods
void clear();
2017-09-11 03:06:02 +02:00
private:
// Friend classes
friend class FListBox;
// Data Members
FString text;
FWidget::data_ptr data_pointer;
fc::brackets_type brackets;
bool selected;
2015-05-23 13:35:12 +02:00
};
#pragma pack(pop)
2015-05-23 13:35:12 +02:00
// FListBoxItem inline functions
//----------------------------------------------------------------------
inline FString& FListBoxItem::getText()
2015-09-22 04:18:20 +02:00
{ return text; }
2015-05-23 13:35:12 +02:00
//----------------------------------------------------------------------
inline FWidget::data_ptr FListBoxItem::getData() const
{ return data_pointer; }
2015-05-23 13:35:12 +02:00
//----------------------------------------------------------------------
2017-03-17 22:59:06 +01:00
inline void FListBoxItem::setText (const FString& txt)
2015-09-22 04:18:20 +02:00
{ text = txt; }
2015-05-23 13:35:12 +02:00
//----------------------------------------------------------------------
inline void FListBoxItem::setData (FWidget::data_ptr data)
{ data_pointer = data; }
//----------------------------------------------------------------------
inline void FListBoxItem::clear()
{ text.clear(); }
2015-05-23 13:35:12 +02:00
//----------------------------------------------------------------------
// class FListBox
//----------------------------------------------------------------------
#pragma pack(push)
#pragma pack(1)
class FListBox : public FWidget
{
2017-09-11 03:06:02 +02:00
public:
// Typedef
typedef std::vector<FListBoxItem> listBoxItems;
// Using-declaration
using FWidget::setGeometry;
// Constructor
explicit FListBox (FWidget* = 0);
template <class Iterator, class InsertConverter>
FListBox (Iterator, Iterator, InsertConverter, FWidget* = 0);
template <class Container, class LazyConverter>
FListBox (Container, LazyConverter, FWidget* = 0);
// Destructor
~FListBox();
// Accessors
const char* getClassName() const;
uInt getCount() const;
FListBoxItem getItem (int);
FListBoxItem getItem (listBoxItems::iterator) const;
int currentItem() const;
FString& getText();
// Mutators
void setCurrentItem (int);
void setCurrentItem (listBoxItems::iterator);
void selectItem (int);
void selectItem (listBoxItems::iterator);
void unselectItem (int);
void unselectItem (listBoxItems::iterator);
void showInsideBrackets (int, fc::brackets_type);
void showNoBrackets (int);
void showNoBrackets (listBoxItems::iterator);
void setGeometry (int, int, int, int, bool = true);
void setMultiSelection (bool);
void setMultiSelection ();
void unsetMultiSelection ();
bool setDisable();
bool setFocus (bool);
bool setFocus();
bool unsetFocus();
void setText (const FString&);
// Inquiries
bool isSelected (int);
bool isSelected (listBoxItems::iterator) const;
bool isMultiSelection() const;
bool hasBrackets (int);
bool hasBrackets (listBoxItems::iterator) const;
// Methods
void hide();
template <class Iterator, class InsertConverter>
void insert (Iterator, Iterator, InsertConverter);
template <class Container, class LazyConverter>
void insert (Container, LazyConverter);
void insert (FListBoxItem);
void insert ( const FString&
, fc::brackets_type = fc::NoBrackets
, bool = false
, data_ptr = 0 );
void insert ( long
, fc::brackets_type = fc::NoBrackets
, bool = false
, data_ptr = 0 );
void remove (int);
void clear();
// Event handlers
void onKeyPress (FKeyEvent*);
void onMouseDown (FMouseEvent*);
void onMouseUp (FMouseEvent*);
void onMouseMove (FMouseEvent*);
void onMouseDoubleClick (FMouseEvent*);
void onWheel (FWheelEvent*);
void onTimer (FTimerEvent*);
void onFocusIn (FFocusEvent*);
void onFocusOut (FFocusEvent*);
protected:
// Methods
void adjustYOffset();
void adjustSize();
private:
// Enumeration
enum convert_type
{
no_convert = 0,
direct_convert = 1,
lazy_convert = 2
};
// Disable copy constructor
FListBox (const FListBox&);
// Disable assignment operator (=)
FListBox& operator = (const FListBox&);
// Accessors
static FString& getString (listBoxItems::iterator);
// Methods
void init();
void draw();
void drawLabel();
void drawList();
void drawListLine (int, listBoxItems::iterator, bool);
void printLeftBracket (fc::brackets_type);
void printRightBracket (fc::brackets_type);
void drawListBracketsLine (int, listBoxItems::iterator, bool);
void setLineAttributes (int, bool, bool, bool&);
void unsetAttributes();
void updateDrawing (bool, bool);
2017-09-11 03:06:02 +02:00
void recalculateHorizontalBar (int, bool);
void recalculateVerticalBar (int);
void getWidgetFocus();
void multiSelection (int);
void multiSelectionUpTo (int);
void wheelUp (int);
void wheelDown (int);
bool dragScrollUp();
bool dragScrollDown();
void dragUp (int);
void dragDown (int);
void stopDragScroll();
void prevListItem (int);
void nextListItem (int);
void scrollToX (int);
void scrollToY (int);
void scrollLeft (int);
void scrollRight (int);
void keyUp();
void keyDown();
void keyLeft();
void keyRight();
void keyPgUp();
void keyPgDn();
void keyHome();
void keyEnd();
bool keyEsc();
void keyEnter();
bool keySpace();
bool keyInsert();
bool keyBackspace();
bool keyIncSearchInput (int);
2017-09-11 03:06:02 +02:00
void processClick();
void processSelect();
void processChanged();
void lazyConvert (listBoxItems::iterator, int);
2017-09-11 03:06:02 +02:00
listBoxItems::iterator index2iterator (int);
// Callback methods
void cb_VBarChange (FWidget*, data_ptr);
void cb_HBarChange (FWidget*, data_ptr);
// Function Pointer
void (*convertToItem) ( FListBoxItem&
, FWidget::data_ptr
, int index );
// Data Members
2017-09-15 01:31:02 +02:00
listBoxItems itemlist;
2017-09-11 03:06:02 +02:00
FWidget::data_ptr source_container;
convert_type conv_type;
FScrollbar* vbar;
FScrollbar* hbar;
FString text;
FString inc_search;
bool multi_select;
bool mouse_select;
fc::dragScroll drag_scroll;
bool scroll_timer;
int scroll_repeat;
int scroll_distance;
int current;
int last_current;
int secect_from_item;
int xoffset;
int yoffset;
int last_yoffset;
int nf_offset;
int max_line_width;
2015-05-23 13:35:12 +02:00
};
#pragma pack(pop)
// FListBox inline functions
//----------------------------------------------------------------------
template <class Iterator, class InsertConverter>
inline FListBox::FListBox ( Iterator first
, Iterator last
, InsertConverter convert
, FWidget* parent )
: FWidget(parent)
, convertToItem(0)
2017-09-15 01:31:02 +02:00
, itemlist()
, source_container(0)
, conv_type(FListBox::no_convert)
, vbar(0)
, hbar(0)
, text()
, inc_search()
, multi_select(false)
, mouse_select(false)
, drag_scroll(fc::noScroll)
, scroll_timer(false)
, scroll_repeat(100)
, scroll_distance(1)
, current(0)
, last_current(-1)
, secect_from_item(-1)
, xoffset(0)
, yoffset(0)
, last_yoffset(-1)
, nf_offset(0)
, max_line_width(0)
{
init();
while ( first != last )
{
insert(convert(first), fc::NoBrackets, false, &(*first));
++first;
}
}
//----------------------------------------------------------------------
template <class Container, class LazyConverter>
inline FListBox::FListBox ( Container container
, LazyConverter convert
, FWidget* parent )
: FWidget(parent)
, convertToItem(0)
2017-09-15 01:31:02 +02:00
, itemlist()
, source_container(0)
, conv_type(FListBox::no_convert)
, vbar(0)
, hbar(0)
, text()
, inc_search()
, multi_select(false)
, mouse_select(false)
, drag_scroll(fc::noScroll)
, scroll_timer(false)
, scroll_repeat(100)
, scroll_distance(1)
, current(0)
, last_current(-1)
, secect_from_item(-1)
, xoffset(0)
, yoffset(0)
, last_yoffset(-1)
, nf_offset(0)
, max_line_width(0)
{
init();
insert (container, convert);
}
2015-05-23 13:35:12 +02:00
//----------------------------------------------------------------------
inline const char* FListBox::getClassName() const
{ return "FListBox"; }
//----------------------------------------------------------------------
inline uInt FListBox::getCount() const
2017-09-15 01:31:02 +02:00
{ return uInt(itemlist.size()); }
2015-05-23 13:35:12 +02:00
//----------------------------------------------------------------------
inline FListBoxItem FListBox::getItem (int index)
{
listBoxItems::iterator iter = index2iterator(index - 1);
return *iter;
}
//----------------------------------------------------------------------
inline FListBoxItem FListBox::getItem (listBoxItems::iterator iter) const
{ return *iter; }
2015-05-23 13:35:12 +02:00
//----------------------------------------------------------------------
inline int FListBox::currentItem() const
{ return current; }
//----------------------------------------------------------------------
inline FString& FListBox::getText()
{ return text; }
2015-05-23 13:35:12 +02:00
//----------------------------------------------------------------------
inline void FListBox::selectItem (int index)
{ index2iterator(index - 1)->selected = true; }
//----------------------------------------------------------------------
inline void FListBox::selectItem (listBoxItems::iterator iter)
{ iter->selected = true; }
2015-05-23 13:35:12 +02:00
//----------------------------------------------------------------------
inline void FListBox::unselectItem (int index)
{ index2iterator(index - 1)->selected = false; }
//----------------------------------------------------------------------
inline void FListBox::unselectItem (listBoxItems::iterator iter)
{ iter->selected = false; }
//----------------------------------------------------------------------
inline void FListBox::showNoBrackets (int index)
{ index2iterator(index - 1)->brackets = fc::NoBrackets; }
2015-05-23 13:35:12 +02:00
//----------------------------------------------------------------------
inline void FListBox::showNoBrackets (listBoxItems::iterator iter)
{ iter->brackets = fc::NoBrackets; }
2015-05-23 13:35:12 +02:00
//----------------------------------------------------------------------
inline void FListBox::setMultiSelection (bool on)
{ multi_select = on; }
2015-05-23 13:35:12 +02:00
//----------------------------------------------------------------------
inline void FListBox::setMultiSelection()
{ setMultiSelection(true); }
//----------------------------------------------------------------------
inline void FListBox::unsetMultiSelection()
{ setMultiSelection(false); }
//----------------------------------------------------------------------
inline bool FListBox::setDisable()
{ return setEnable(false); }
//----------------------------------------------------------------------
inline bool FListBox::setFocus()
{ return setFocus(true); }
//----------------------------------------------------------------------
inline bool FListBox::unsetFocus()
{ return setFocus(false); }
//----------------------------------------------------------------------
inline bool FListBox::isSelected (int index)
{ return index2iterator(index - 1)->selected; }
//----------------------------------------------------------------------
inline bool FListBox::isSelected (listBoxItems::iterator iter) const
{ return iter->selected; }
//----------------------------------------------------------------------
inline bool FListBox::isMultiSelection() const
{ return multi_select; }
//----------------------------------------------------------------------
inline bool FListBox::hasBrackets(int index)
{ return bool(index2iterator(index - 1)->brackets > 0); }
//----------------------------------------------------------------------
inline bool FListBox::hasBrackets(listBoxItems::iterator iter) const
{ return bool(iter->brackets > 0); }
//----------------------------------------------------------------------
template <class Iterator, class InsertConverter>
inline void FListBox::insert ( Iterator first
, Iterator last
, InsertConverter convert )
{
conv_type = direct_convert;
while ( first != last )
{
insert (convert(first), fc::NoBrackets, false, &(*first));
++first;
}
}
//----------------------------------------------------------------------
template <class Container, class LazyConverter>
void FListBox::insert (Container container, LazyConverter convert)
{
conv_type = lazy_convert;
source_container = container;
convertToItem = convert;
2018-01-05 00:49:00 +01:00
std::size_t size = container->size();
if ( size > 0 )
2017-09-15 01:31:02 +02:00
itemlist.resize(size);
recalculateVerticalBar(int(size));
}
//----------------------------------------------------------------------
inline FListBox::listBoxItems::iterator FListBox::index2iterator (int index)
{
2017-09-15 01:31:02 +02:00
listBoxItems::iterator iter = itemlist.begin();
std::advance (iter, index);
return iter;
}
2015-05-23 13:35:12 +02:00
#endif // FLISTBOX_H