#include <itemcontainer.h>

Inheritance diagram for ItemContainer:

Public Member Functions
	ItemContainer (const Widget2 const widget, Inventory const inventory, const int maxColumns, const ShowEmptyRows showEmptyRows, const ForceQuantity forceQuantity)

	~ItemContainer ()

void	logic ()

void	draw (Graphics *const graphics)

void	safeDraw (Graphics *const graphics)

void	keyPressed (KeyEvent &event)

void	keyReleased (KeyEvent &event)

void	mousePressed (MouseEvent &event)

void	mouseDragged (MouseEvent &event)

void	mouseReleased (MouseEvent &event)

void	mouseMoved (MouseEvent &event)

void	mouseExited (MouseEvent &event)

void	widgetResized (const Event &event)

void	widgetMoved (const Event &event)

Item *	getSelectedItem () const

void	selectNone ()

void	addSelectionListener (SelectionListener *listener)

void	removeSelectionListener (SelectionListener *listener)

void	setFilter (const int tag)

void	setSortType (const int sortType)

void	setName (const std::string &str)

int	updateMatrix ()

bool	getClickCount () const

void	unsetInventory ()

void	setInventory (Inventory *const inventory)

void	setCellBackgroundImage (const std::string &xmlName)

void	setMaxColumns (const int maxColumns)

Public Member Functions inherited from Widget
	Widget (const Widget2 *const widget)

	~Widget ()

virtual void	drawFrame (Graphics *graphics)

virtual void	safeDrawFrame (Graphics *graphics)

void	setFrameSize (const unsigned int frameSize)

unsigned int	getFrameSize () const

Widget *	getParent () const

void	setWidth (const int width)

int	getWidth () const

void	setHeight (const int height)

int	getHeight () const

void	setSize (const int width, const int height)

void	setX (const int x)

int	getX () const

void	setY (const int y)

int	getY () const

void	setPosition (const int x, const int y)

void	setDimension (const Rect &dimension)

const Rect &	getDimension () const

void	setFocusable (const bool focusable)

bool	isFocusable () const

virtual bool	isFocused () const

void	setEnabled (const bool enabled)

bool	isEnabled () const

void	setVisible (Visible visible)

bool	isVisible () const

void	setBaseColor (const Color &color)

const Color &	getBaseColor () const

void	setForegroundColor (const Color &color)

const Color &	getForegroundColor () const

void	setBackgroundColor (const Color &color)

const Color &	getBackgroundColor () const

virtual void	requestFocus ()

virtual void	requestMoveToTop ()

virtual void	requestMoveToBottom ()

virtual void	setFocusHandler (FocusHandler *const focusHandler)

FocusHandler *	getFocusHandler ()

void	addActionListener (ActionListener *const actionListener)

void	removeActionListener (ActionListener *const actionListener)

void	addDeathListener (WidgetDeathListener *const deathListener)

void	removeDeathListener (WidgetDeathListener *const deathListener)

void	addMouseListener (MouseListener *const mouseListener)

void	removeMouseListener (MouseListener *const mouseListener)

void	addKeyListener (KeyListener *const keyListener)

void	removeKeyListener (KeyListener *const keyListener)

void	addFocusListener (FocusListener *const focusListener)

void	removeFocusListener (FocusListener *const focusListener)

void	addWidgetListener (WidgetListener *const widgetListener)

void	removeWidgetListener (WidgetListener *const widgetListener)

void	setActionEventId (const std::string &actionEventId)

const std::string &	getActionEventId () const

virtual void	getAbsolutePosition (int &x, int &y) const

virtual void	setParent (Widget *parent)

Font *	getFont () const

void	setFont (Font *const font)

virtual void	fontChanged ()

bool	isTabInEnabled () const

void	setTabInEnabled (const bool enabled)

bool	isTabOutEnabled () const

void	setTabOutEnabled (const bool enabled)

void	requestModalFocus ()

virtual void	requestModalMouseInputFocus ()

virtual void	releaseModalFocus ()

virtual void	releaseModalMouseInputFocus ()

virtual bool	isModalFocused () const

virtual bool	isModalMouseInputFocused () const

virtual Widget *	getWidgetAt (int x, int y)

const std::list< MouseListener * > &	getMouseListeners () const A_CONST

const std::list< KeyListener * > &	getKeyListeners () const A_CONST

const std::list< FocusListener * > &	getFocusListeners () const A_CONST

virtual Rect	getChildrenArea ()

virtual FocusHandler *	getInternalFocusHandler ()

void	setInternalFocusHandler (FocusHandler *const internalFocusHandler)

virtual void	moveToTop (Widget *widget)

virtual void	moveToBottom (Widget *widget)

virtual void	focusNext ()

virtual void	focusPrevious ()

virtual void	showWidgetPart (Widget *const widget, const Rect &area)

void	setId (const std::string &id)

const std::string &	getId () const

virtual void	showPart (const Rect &rectangle)

bool	isAllowLogic () const

void	setMouseConsume (const bool b)

bool	isMouseConsume () const

void	setRedraw (const bool b)

virtual bool	isSelectable () const

void	setSelectable (const bool selectable)

void	windowResized ()

virtual void	postInit ()

Public Member Functions inherited from Widget2
virtual	~Widget2 ()

const Color &	getThemeColor (const ThemeColorIdT type, const unsigned int alpha) const A_INLINE

const Color &	getThemeCharColor (const signed char c, bool &valid) const A_INLINE

virtual void	setWidget2 (const Widget2 *const widget)

void	setPalette (int palette)

void	checkPalette ()

void	setForegroundColor2 (const Color &color)

Widget *	getWindow () const

virtual void	setWindow (Widget *const window)

Public Member Functions inherited from KeyListener
virtual	~KeyListener ()

Public Member Functions inherited from MouseListener
virtual	~MouseListener ()

virtual void	mouseEntered (MouseEvent &event)

virtual void	mouseClicked (MouseEvent &event)

virtual void	mouseWheelMovedUp (MouseEvent &event)

virtual void	mouseWheelMovedDown (MouseEvent &event)

Public Member Functions inherited from WidgetListener
virtual	~WidgetListener ()

virtual void	widgetHidden (const Event &event)

virtual void	widgetShown (const Event &event)

Private Types
enum	Direction { Left = 0 , Right , Up , Down }

enum	SelectionState { SEL_NONE = 0 , SEL_SELECTED , SEL_SELECTING , SEL_DESELECTING , SEL_DRAGGING }

typedef std::list< SelectionListener * >	SelectionListenerList

typedef SelectionListenerList::iterator	SelectionListenerIterator

Private Member Functions
void	setSelectedIndex (const int index)

void	adjustHeight ()

void	distributeValueChangedEvent ()

void	updateSize ()

int	getSlotIndex (int x, int y) const

int	getSlotByXY (int x, int y) const

Private Attributes
Inventory *	mInventory

Image *	mSelImg

Image *	mProtectedImg

Image *	mCellBackgroundImg

std::string	mName

int *	mShowMatrix

Skin *	mSkin

ImageCollection *	mVertexes

Color	mEquipedColor

Color	mEquipedColor2

Color	mUnEquipedColor

Color	mUnEquipedColor2

SelectionListenerList	mSelectionListeners

int	mGridColumns

int	mGridRows

int	mDrawRows

int	mSelectedIndex

int	mLastUsedSlot

int	mTag

int	mSortType

int	mClicks

int	mBoxWidth

int	mBoxHeight

int	mEquippedTextPadding

int	mPaddingItemX

int	mPaddingItemY

int	mMaxColumns

SelectionState	mSelectionStatus

ForceQuantity	mForceQuantity

ShowEmptyRows	mShowEmptyRows

bool	mDescItems

Additional Inherited Members
Static Public Member Functions inherited from Widget
static void	setGlobalFont (Font *const font)

static Font *	getGloablFont ()

static void	cleanGlobalFont ()

static bool	widgetExists (const Widget *const widget)

static void	distributeWindowResizeEvent ()

static Widget *	callPostInit (Widget *const widget)

Data Fields inherited from Widget
Visible	mVisible

Protected Types inherited from Widget
typedef std::list< MouseListener * >	MouseListenerList

typedef MouseListenerList::iterator	MouseListenerIterator

typedef std::list< KeyListener * >	KeyListenerList

typedef KeyListenerList::iterator	KeyListenerIterator

typedef std::list< ActionListener * >	ActionListenerList

typedef ActionListenerList::iterator	ActionListenerIterator

typedef std::list< WidgetDeathListener * >	WidgetDeathListenerList

typedef WidgetDeathListenerList::iterator	WidgetDeathListenerIterator

typedef std::list< FocusListener * >	FocusListenerList

typedef FocusListenerList::iterator	FocusListenerIterator

typedef std::list< WidgetListener * >	WidgetListenerList

typedef WidgetListenerList::iterator	WidgetListenerIterator

Protected Member Functions inherited from Widget
void	distributeActionEvent ()

void	distributeResizedEvent ()

void	distributeMovedEvent ()

void	distributeHiddenEvent ()

void	distributeShownEvent ()

Protected Member Functions inherited from Widget2
	Widget2 (const Widget2 *const widget)

Protected Member Functions inherited from KeyListener
	KeyListener ()

Protected Member Functions inherited from MouseListener
	MouseListener ()

Protected Member Functions inherited from WidgetListener
	WidgetListener ()

Protected Attributes inherited from Widget
MouseListenerList	mMouseListeners

KeyListenerList	mKeyListeners

ActionListenerList	mActionListeners

WidgetDeathListenerList	mDeathListeners

FocusListenerList	mFocusListeners

WidgetListenerList	mWidgetListeners

Color	mForegroundColor

Color	mBackgroundColor

Color	mBaseColor

Rect	mDimension

std::string	mActionEventId

std::string	mId

FocusHandler *	mFocusHandler

FocusHandler *	mInternalFocusHandler

Widget *	mParent

Font *	mCurrentFont

unsigned int	mFrameSize

bool	mFocusable

bool	mTabIn

bool	mTabOut

bool	mEnabled

bool	mAllowLogic

bool	mMouseConsume

bool	mRedraw

bool	mSelectable

Protected Attributes inherited from Widget2
int	mPaletteOffset

Widget *	mWindow

Color	mForegroundColor2

Static Protected Attributes inherited from Widget
static Font *	mGlobalFont = 0

Detailed Description

An item container. Used to show items in inventory and trade dialog.

Definition at line 49 of file itemcontainer.h.

Member Typedef Documentation

◆ SelectionListenerIterator

typedef SelectionListenerList::iterator ItemContainer::SelectionListenerIterator

private

Definition at line 202 of file itemcontainer.h.

◆ SelectionListenerList

typedef std::list<SelectionListener*> ItemContainer::SelectionListenerList

private

Definition at line 201 of file itemcontainer.h.

Member Enumeration Documentation

◆ Direction

enum ItemContainer::Direction

private

Enumerator
Left
Right
Up
Down

Definition at line 143 of file itemcontainer.h.

         {
             Left = 0,
             Right,
             Up,
             Down
         };

◆ SelectionState

enum ItemContainer::SelectionState

private

Enumerator
SEL_NONE
SEL_SELECTED
SEL_SELECTING
SEL_DESELECTING
SEL_DRAGGING

Definition at line 151 of file itemcontainer.h.

         {
             SEL_NONE = 0,
             SEL_SELECTED,
             SEL_SELECTING,
             SEL_DESELECTING,
             SEL_DRAGGING
         };

Constructor & Destructor Documentation

◆ ItemContainer()

ItemContainer::ItemContainer	(	const Widget2 *const	widget,
		Inventory *const	inventory,
		const int	maxColumns,
		const ShowEmptyRows	showEmptyRows,
		const ForceQuantity	forceQuantity
	)

Definition at line 225 of file itemcontainer.cpp.

                                                                 :
     Widget(widget),
     KeyListener(),
     MouseListener(),
     WidgetListener(),
     mInventory(inventory),
     mSelImg(Theme::getImageFromThemeXml("item_selection.xml", "")),
     mProtectedImg(Theme::getImageFromTheme("lock.png")),
     mCellBackgroundImg(Theme::getImageFromThemeXml("inventory_cell.xml", "")),
     mName(),
     mShowMatrix(nullptr),
     mSkin(theme != nullptr ? theme->load("itemcontainer.xml", "",
         true, Theme::getThemePath()) : nullptr),
     mVertexes(new ImageCollection),
     mEquipedColor(getThemeColor(ThemeColorId::ITEM_EQUIPPED, 255U)),
     mEquipedColor2(getThemeColor(ThemeColorId::ITEM_EQUIPPED_OUTLINE, 255U)),
     mUnEquipedColor(getThemeColor(ThemeColorId::ITEM_NOT_EQUIPPED, 255U)),
     mUnEquipedColor2(getThemeColor(ThemeColorId::ITEM_NOT_EQUIPPED_OUTLINE,
         255U)),
     mSelectionListeners(),
     mGridColumns(1),
     mGridRows(1),
     mDrawRows(1),
     mSelectedIndex(-1),
     mLastUsedSlot(-1),
     mTag(0),
     mSortType(0),
     mClicks(1),
     mBoxWidth(mSkin != nullptr ? mSkin->getOption("boxWidth", 35) : 35),
     mBoxHeight(mSkin != nullptr ? mSkin->getOption("boxHeight", 43) : 43),
     mEquippedTextPadding(mSkin != nullptr ? mSkin->getOption(
                          "equippedTextPadding", 29) : 29),
     mPaddingItemX(mSkin != nullptr ? mSkin->getOption("paddingItemX", 0) : 0),
     mPaddingItemY(mSkin != nullptr ? mSkin->getOption("paddingItemY", 0) : 0),
     mMaxColumns(maxColumns),
     mSelectionStatus(SEL_NONE),
     mForceQuantity(forceQuantity),
     mShowEmptyRows(showEmptyRows),
     mDescItems(false)
 {
     setFocusable(true);
     addKeyListener(this);
     addMouseListener(this);
     addWidgetListener(this);
     mAllowLogic = false;
 }

References Widget::addKeyListener(), Widget::addMouseListener(), Widget::addWidgetListener(), Widget::mAllowLogic, and Widget::setFocusable().

◆ ~ItemContainer()

ItemContainer::~ItemContainer ( )

Destructor.

Definition at line 276 of file itemcontainer.cpp.

 {
     if (gui != nullptr)
         gui->removeDragged(this);
  
     if (mSelImg != nullptr)
     {
         mSelImg->decRef();
         mSelImg = nullptr;
     }
     if (mProtectedImg != nullptr)
     {
         mProtectedImg->decRef();
         mProtectedImg = nullptr;
     }
     if (mCellBackgroundImg != nullptr)
     {
         mCellBackgroundImg->decRef();
         mCellBackgroundImg = nullptr;
     }
  
     if (theme != nullptr)
         theme->unload(mSkin);
  
     delete []mShowMatrix;
     delete2(mVertexes)
 }

References delete2, gui, mCellBackgroundImg, mProtectedImg, mSelImg, mShowMatrix, mSkin, mVertexes, Gui::removeDragged(), theme, and Theme::unload().

Member Function Documentation

◆ addSelectionListener()

void ItemContainer::addSelectionListener ( SelectionListener * listener )

inline

Adds a listener to the list that's notified each time a change to the selection occurs.

Definition at line 110 of file itemcontainer.h.

111 { mSelectionListeners.push_back(listener); }

anonymous_namespace{itemlinkhandler.cpp}::listener

OpenUrlListener listener

Definition: itemlinkhandler.cpp:56

References anonymous_namespace{itemlinkhandler.cpp}::listener, and mSelectionListeners.

Referenced by InventoryWindow::InventoryWindow(), and TradeWindow::TradeWindow().

◆ adjustHeight()

void ItemContainer::adjustHeight ( )

private

Determine and set the height of the container.

Definition at line 1132 of file itemcontainer.cpp.

 {
     if (mGridColumns == 0)
         return;
  
     mGridRows = (mLastUsedSlot + 1) / mGridColumns;
     if (mGridRows == 0 || (mLastUsedSlot + 1) % mGridColumns > 0)
         ++mGridRows;
  
     const int invSize = mInventory->getSize();
     int maxRows = mShowEmptyRows == ShowEmptyRows_true ?
         std::max(invSize / mGridColumns, mGridRows) : mGridRows;
  
     if (mShowEmptyRows == ShowEmptyRows_true)
     {
         if (mGridColumns * maxRows < invSize)
             maxRows ++;
         mGridRows = maxRows;
     }
  
     if (mShowEmptyRows == ShowEmptyRows_false)
     {
         const int num = updateMatrix();
         mDrawRows = num / mGridColumns;
         if (mDrawRows == 0 || num % mGridColumns > 0)
             ++mDrawRows;
  
         maxRows = mDrawRows;
     }
     else
     {
         mDrawRows = mGridRows;
     }
     setHeight(maxRows * mBoxHeight);
 }

References Inventory::getSize(), mBoxHeight, mDrawRows, mGridColumns, mGridRows, mInventory, mLastUsedSlot, mShowEmptyRows, Widget::setHeight(), ShowEmptyRows_false, ShowEmptyRows_true, and updateMatrix().

Referenced by logic(), setFilter(), and updateSize().

◆ distributeValueChangedEvent()

void ItemContainer::distributeValueChangedEvent ( )

private

Sends out selection events to the list of selection listeners.

Definition at line 608 of file itemcontainer.cpp.

 {
     FOR_EACH (SelectionListenerIterator, i, mSelectionListeners)
     {
         if (*i != nullptr)
         {
             SelectionEvent event(this);
             (*i)->valueChanged(event);
         }
     }
 }

References FOR_EACH, and mSelectionListeners.

Referenced by setSelectedIndex().

◆ draw()

void ItemContainer::draw ( Graphics *const graphics )

virtual

Draws the items.

Implements Widget.

Definition at line 325 of file itemcontainer.cpp.

 {
     if ((mInventory == nullptr) || (mShowMatrix == nullptr))
         return;
  
     BLOCK_START("ItemContainer::draw")
     Font *const font = getFont();
  
     if (mCellBackgroundImg != nullptr)
     {
         if (mRedraw || graphics->getRedraw())
         {
             mRedraw = false;
             mVertexes->clear();
  
             const int invSize = mInventory->getSize();
             const int maxRows = mShowEmptyRows == ShowEmptyRows_true ?
                 std::max(invSize / mGridColumns, mGridRows) : mGridRows;
             const int maxColumns = mGridColumns > invSize ?
                 invSize : mGridColumns;
             for (int j = 0; j < maxRows; j++)
             {
                 const int intY0 = j * mBoxHeight;
                 for (int i = 0; i < maxColumns; i++)
                 {
                     int itemX = i * mBoxWidth;
                     int itemY = intY0;
                     graphics->calcTileCollection(mVertexes,
                         mCellBackgroundImg,
                         itemX + mPaddingItemX,
                         itemY + mPaddingItemY);
                 }
             }
             graphics->finalize(mVertexes);
         }
         graphics->drawTileCollection(mVertexes);
     }
  
     for (int j = 0; j < mDrawRows; j++)
     {
         const int intY0 = j * mBoxHeight;
         int itemIndex = j * mGridColumns - 1;
         for (int i = 0; i < mGridColumns; i++)
         {
             itemIndex ++;
             if (mShowMatrix[itemIndex] < 0)
                 continue;
  
             const Item *const item = mInventory->getItem(
                 mShowMatrix[itemIndex]);
  
             if ((item == nullptr) || item->getId() == 0)
                 continue;
  
             Image *const image = item->getImage();
             if (image != nullptr)
             {
                 int itemX = i * mBoxWidth;
                 int itemY = intY0;
                 if (mShowMatrix[itemIndex] == mSelectedIndex)
                 {
                     if (mSelImg != nullptr)
                         graphics->drawImage(mSelImg, itemX, itemY);
                 }
                 image->setAlpha(1.0F);  // ensure the image if fully drawn...
                 graphics->drawImage(image,
                     itemX + mPaddingItemX,
                     itemY + mPaddingItemY);
                 if ((mProtectedImg != nullptr) && PlayerInfo::isItemProtected(
                     item->getId()))
                 {
                     graphics->drawImage(mProtectedImg,
                         itemX + mPaddingItemX,
                         itemY + mPaddingItemY);
                 }
             }
         }
     }
  
     for (int j = 0; j < mDrawRows; j++)
     {
         const int intY0 = j * mBoxHeight;
         int itemIndex = j * mGridColumns - 1;
         for (int i = 0; i < mGridColumns; i++)
         {
             int itemX = i * mBoxWidth;
             int itemY = intY0;
             itemIndex ++;
             if (mShowMatrix[itemIndex] < 0)
                 continue;
  
             const Item *const item = mInventory->getItem(
                 mShowMatrix[itemIndex]);
  
             if ((item == nullptr) || item->getId() == 0)
                 continue;
  
             // Draw item caption
             std::string caption;
             if (item->getQuantity() > 1 ||
                 mForceQuantity == ForceQuantity_true)
             {
                 caption = toString(item->getQuantity());
             }
             else if (item->isEquipped() == Equipped_true)
             {
                 // TRANSLATORS: Text under equipped items (should be small)
                 caption = _("Eq.");
             }
  
             if (item->isEquipped() == Equipped_true)
             {
                 font->drawString(graphics,
                     mEquipedColor, mEquipedColor2,
                     caption,
                     itemX + (mBoxWidth - font->getWidth(caption)) / 2,
                     itemY + mEquippedTextPadding);
             }
             else
             {
                 font->drawString(graphics,
                     mUnEquipedColor, mUnEquipedColor2,
                     caption,
                     itemX + (mBoxWidth - font->getWidth(caption)) / 2,
                     itemY + mEquippedTextPadding);
             }
         }
     }
     BLOCK_END("ItemContainer::draw")
 }

References _, BLOCK_END, BLOCK_START, Graphics::calcTileCollection(), ImageCollection::clear(), Graphics::drawImage(), Font::drawString(), Graphics::drawTileCollection(), Equipped_true, Graphics::finalize(), ForceQuantity_true, Widget::getFont(), Item::getId(), Item::getImage(), Inventory::getItem(), Item::getQuantity(), Graphics::getRedraw(), Inventory::getSize(), Font::getWidth(), Item::isEquipped(), PlayerInfo::isItemProtected(), mBoxHeight, mBoxWidth, mCellBackgroundImg, mDrawRows, mEquipedColor, mEquipedColor2, mEquippedTextPadding, mForceQuantity, mGridColumns, mGridRows, mInventory, mPaddingItemX, mPaddingItemY, mProtectedImg, Widget::mRedraw, mSelectedIndex, mSelImg, mShowEmptyRows, mShowMatrix, mUnEquipedColor, mUnEquipedColor2, mVertexes, ShowEmptyRows_true, and Catch::toString().

◆ getClickCount()

bool ItemContainer::getClickCount ( ) const

inline

Definition at line 129 of file itemcontainer.h.

130 { return mClicks != 0; }

References mClicks.

◆ getSelectedItem()

Item * ItemContainer::getSelectedItem ( ) const

Returns the selected item.

Definition at line 601 of file itemcontainer.cpp.

 {
     if (mInventory != nullptr)
         return mInventory->getItem(mSelectedIndex);
     return nullptr;
 }

References Inventory::getItem(), mInventory, and mSelectedIndex.

Referenced by InventoryWindow::action(), InventoryWindow::getSelectedItem(), InventoryWindow::mouseClicked(), InventoryWindow::moveItemToCraft(), InventoryWindow::updateButtons(), InventoryWindow::updateDropButton(), InventoryWindow::valueChanged(), and TradeWindow::valueChanged().

◆ getSlotByXY()

int ItemContainer::getSlotByXY	(	int	x,
		int	y
	)		const

private

Definition at line 1286 of file itemcontainer.cpp.

 {
     if (mShowMatrix == nullptr)
         return Inventory::NO_SLOT_INDEX;
  
     if (x < mDimension.width && y < mDimension.height && x >= 0 && y >= 0)
     {
         if (x > mBoxWidth * mGridColumns)
             return Inventory::NO_SLOT_INDEX;
         const int idx = (y / mBoxHeight) * mGridColumns + (x / mBoxWidth);
         if (idx >= 0 && idx < mGridRows * mGridColumns)
             return idx;
     }
  
     return Inventory::NO_SLOT_INDEX;
 }

References mBoxHeight, mBoxWidth, Widget::mDimension, mGridColumns, mGridRows, mShowMatrix, Inventory::NO_SLOT_INDEX, Rect::width, x, and y.

Referenced by mouseReleased().

◆ getSlotIndex()

int ItemContainer::getSlotIndex	(	int	x,
		int	y
	)		const

private

Gets the inventory slot index based on the cursor position.

Parameters

x	The X coordinate position.
y	The Y coordinate position.

Returns: The slot index on success, -1 on failure.

Definition at line 1266 of file itemcontainer.cpp.

 {
     if (mShowMatrix == nullptr)
         return Inventory::NO_SLOT_INDEX;
  
     if (x < mDimension.width && y < mDimension.height && x >= 0 && y >= 0)
     {
         if (x > mBoxWidth * mGridColumns)
             return Inventory::NO_SLOT_INDEX;
         const int idx = (y / mBoxHeight) * mGridColumns + (x / mBoxWidth);
         if (idx >= 0 && idx < mGridRows * mGridColumns
             && mShowMatrix[idx] >= 0)
         {
             return mShowMatrix[idx];
         }
     }
  
     return Inventory::NO_SLOT_INDEX;
 }

References mBoxHeight, mBoxWidth, Widget::mDimension, mGridColumns, mGridRows, mShowMatrix, Inventory::NO_SLOT_INDEX, Rect::width, x, and y.

Referenced by mouseMoved(), mousePressed(), and mouseReleased().

◆ keyPressed()

void ItemContainer::keyPressed ( KeyEvent & event )

virtual

Called if a key is pressed when the widget has keyboard focus. If a key is held down the widget will generate multiple key presses.

Parameters

event Discribes the event.

Reimplemented from KeyListener.

Definition at line 620 of file itemcontainer.cpp.

621 {

622 }

◆ keyReleased()

void ItemContainer::keyReleased ( KeyEvent & event )

virtual

Called if a key is released when the widget has keyboard focus.

Parameters

event Discribes the event.

Reimplemented from KeyListener.

Definition at line 624 of file itemcontainer.cpp.

625 {

626 }

◆ logic()

void ItemContainer::logic ( )

virtual

Necessary for checking how full the inventory is.

Reimplemented from Widget.

Definition at line 304 of file itemcontainer.cpp.

 {
     BLOCK_START("ItemContainer::logic")
     Widget::logic();
  
     if (mInventory == nullptr)
     {
         BLOCK_END("ItemContainer::logic")
         return;
     }
  
     const int lastUsedSlot = mInventory->getLastUsedSlot();
  
     if (lastUsedSlot != mLastUsedSlot)
     {
         mLastUsedSlot = lastUsedSlot;
         adjustHeight();
     }
     BLOCK_END("ItemContainer::logic")
 }

References adjustHeight(), BLOCK_END, BLOCK_START, Inventory::getLastUsedSlot(), Widget::logic(), mInventory, and mLastUsedSlot.

◆ mouseDragged()

void ItemContainer::mouseDragged ( MouseEvent & event )

virtual

Called when the mouse has moved and the mouse has previously been pressed on the widget.

Parameters

event Describes the event.

Reimplemented from MouseListener.

Definition at line 719 of file itemcontainer.cpp.

 {
     if (mSelectionStatus != SEL_NONE)
         mSelectionStatus = SEL_DRAGGING;
 }

References mSelectionStatus, SEL_DRAGGING, and SEL_NONE.

◆ mouseExited()

void ItemContainer::mouseExited ( MouseEvent & event )

virtual

Called when the mouse has exited the widget area.

Parameters

event Describes the event.

Reimplemented from MouseListener.

Definition at line 1107 of file itemcontainer.cpp.

 {
     itemPopup->setVisible(Visible_false);
 }

References itemPopup, Widget::setVisible(), and Visible_false.

◆ mouseMoved()

void ItemContainer::mouseMoved ( MouseEvent & event )

virtual

Called when the mouse has moved in the widget area and no mouse button has been pressed (i.e no widget is being dragged).

Parameters

event Describes the event.

Reimplemented from MouseListener.

Definition at line 1088 of file itemcontainer.cpp.

 {
     if (mInventory == nullptr)
         return;
  
     const Item *const item = mInventory->getItem(
         getSlotIndex(event.getX(), event.getY()));
  
     if ((item != nullptr) && (viewport != nullptr))
     {
         itemPopup->setItem(item, false);
         itemPopup->position(viewport->mMouseX, viewport->mMouseY);
     }
     else
     {
         itemPopup->setVisible(Visible_false);
     }
 }

References Inventory::getItem(), getSlotIndex(), MouseEvent::getX(), MouseEvent::getY(), itemPopup, mInventory, Viewport::mMouseX, Viewport::mMouseY, Popup::position(), ItemPopup::setItem(), Widget::setVisible(), viewport, and Visible_false.

◆ mousePressed()

void ItemContainer::mousePressed ( MouseEvent & event )

virtual

Called when a mouse button has been pressed on the widget area.

NOTE: A mouse press is NOT equal to a mouse click. Use mouseClickMessage to check for mouse clicks.

Parameters

event Describes the event.

Reimplemented from MouseListener.

Definition at line 628 of file itemcontainer.cpp.

 {
     if (mInventory == nullptr)
         return;
  
     const MouseButtonT button = event.getButton();
     mClicks = event.getClickCount();
  
     if (button == MouseButton::LEFT || button == MouseButton::RIGHT)
     {
         event.consume();
         const int index = getSlotIndex(event.getX(), event.getY());
         if (index == Inventory::NO_SLOT_INDEX)
             return;
  
         Item *const item = mInventory->getItem(index);
  
         // put item name into chat window
         if ((item != nullptr) && mDescItems && (chatWindow != nullptr))
             chatWindow->addItemText(item->getInfo().getName());
  
         DragDropSourceT src = DragDropSource::Empty;
         switch (mInventory->getType())
         {
             case InventoryType::Inventory:
                 src = DragDropSource::Inventory;
                 break;
             case InventoryType::Storage:
                 src = DragDropSource::Storage;
                 break;
             case InventoryType::Trade:
                 src = DragDropSource::Trade;
                 break;
             case InventoryType::Npc:
                 src = DragDropSource::Npc;
                 break;
             case InventoryType::Cart:
                 src = DragDropSource::Cart;
                 break;
             case InventoryType::MailEdit:
                 src = DragDropSource::MailEdit;
                 break;
             case InventoryType::MailView:
                 src = DragDropSource::MailView;
                 break;
             case InventoryType::Craft:
                 src = DragDropSource::Craft;
                 break;
             default:
             case InventoryType::Vending:
             case InventoryType::TypeEnd:
                 break;
         }
         if (src == DragDropSource::MailView)
             return;
         if (mSelectedIndex == index && mClicks != 2)
         {
             dragDrop.dragItem(item, src, index);
             dragDrop.select(item);
             mSelectionStatus = SEL_DESELECTING;
         }
         else if ((item != nullptr) && (item->getId() != 0))
         {
             if (index >= 0)
             {
                 dragDrop.dragItem(item, src, index);
                 dragDrop.select(item);
                 setSelectedIndex(index);
                 mSelectionStatus = SEL_SELECTING;
  
                 if (itemShortcutWindow != nullptr)
                 {
                     const int num = itemShortcutWindow->getTabIndex();
                     if (num >= 0 && num < CAST_S32(SHORTCUT_TABS))
                     {
                         if (itemShortcut[num] != nullptr)
                             itemShortcut[num]->setItemSelected(item);
                     }
                 }
                 if (shopWindow != nullptr)
                     shopWindow->setItemSelected(item->getId());
             }
         }
         else
         {
             dragDrop.deselect();
             selectNone();
         }
     }
 }

References ChatWindow::addItemText(), DragDropSource::Cart, InventoryType::Cart, CAST_S32, chatWindow, DragDropSource::Craft, InventoryType::Craft, DragDrop::deselect(), dragDrop, DragDrop::dragItem(), DragDropSource::Empty, Item::getId(), Item::getInfo(), Inventory::getItem(), ItemInfo::getName(), getSlotIndex(), ShortcutWindow::getTabIndex(), Inventory::getType(), MouseEvent::getX(), MouseEvent::getY(), DragDropSource::Inventory, InventoryType::Inventory, itemShortcut, itemShortcutWindow, MouseButton::LEFT, DragDropSource::MailEdit, InventoryType::MailEdit, DragDropSource::MailView, InventoryType::MailView, mClicks, mDescItems, mInventory, mSelectedIndex, mSelectionStatus, Inventory::NO_SLOT_INDEX, DragDropSource::Npc, InventoryType::Npc, MouseButton::RIGHT, SEL_DESELECTING, SEL_SELECTING, DragDrop::select(), selectNone(), ShopWindow::setItemSelected(), ItemShortcut::setItemSelected(), setSelectedIndex(), shopWindow, SHORTCUT_TABS, DragDropSource::Storage, InventoryType::Storage, DragDropSource::Trade, InventoryType::Trade, InventoryType::TypeEnd, and InventoryType::Vending.

◆ mouseReleased()

void ItemContainer::mouseReleased ( MouseEvent & event )

virtual

Called when a mouse button has been released on the widget area.

Parameters

event Describes the event.

Reimplemented from MouseListener.

Definition at line 725 of file itemcontainer.cpp.

 {
     if (mClicks == 2 ||
         inventoryHandler == nullptr ||
         tradeHandler == nullptr)
     {
         return;
     }
  
     switch (mSelectionStatus)
     {
         case SEL_SELECTING:
             mSelectionStatus = SEL_SELECTED;
             break;
         case SEL_DESELECTING:
             selectNone();
             break;
         case SEL_DRAGGING:
             mSelectionStatus = SEL_SELECTED;
             break;
         case SEL_NONE:
         case SEL_SELECTED:
         default:
             break;
     }
  
     if (dragDrop.isEmpty())
     {
         const int index = getSlotIndex(event.getX(), event.getY());
         if (index == Inventory::NO_SLOT_INDEX)
             return;
         if (index == mSelectedIndex || mSelectedIndex == -1)
             return;
         inventoryHandler->moveItem(mSelectedIndex, index);
         selectNone();
     }
     else if (mInventory != nullptr)
     {
         const DragDropSourceT src = dragDrop.getSource();
         DragDropSourceT dst = DragDropSource::Empty;
         switch (mInventory->getType())
         {
             case InventoryType::Inventory:
                 dst = DragDropSource::Inventory;
                 break;
             case InventoryType::Storage:
                 dst = DragDropSource::Storage;
                 break;
             case InventoryType::Trade:
                 dst = DragDropSource::Trade;
                 break;
             case InventoryType::Npc:
                 dst = DragDropSource::Npc;
                 break;
             case InventoryType::MailEdit:
                 dst = DragDropSource::MailEdit;
                 break;
             case InventoryType::MailView:
                 dst = DragDropSource::MailView;
                 break;
             case InventoryType::Cart:
                 dst = DragDropSource::Cart;
                 break;
             case InventoryType::Craft:
                 dst = DragDropSource::Craft;
                 break;
             default:
             case InventoryType::Vending:
             case InventoryType::TypeEnd:
                 break;
         }
         InventoryTypeT srcContainer = InventoryType::TypeEnd;
         InventoryTypeT dstContainer = InventoryType::TypeEnd;
         bool checkProtection(false);
         Inventory *inventory = nullptr;
         if (src == DragDropSource::Inventory
             && dst == DragDropSource::Storage)
         {
             srcContainer = InventoryType::Inventory;
             dstContainer = InventoryType::Storage;
             inventory = PlayerInfo::getInventory();
         }
         else if (src == DragDropSource::Storage
                  && dst == DragDropSource::Inventory)
         {
             srcContainer = InventoryType::Storage;
             dstContainer = InventoryType::Inventory;
             inventory = PlayerInfo::getStorageInventory();
         }
         if (src == DragDropSource::Inventory
             && dst == DragDropSource::Cart)
         {
             srcContainer = InventoryType::Inventory;
             dstContainer = InventoryType::Cart;
             inventory = PlayerInfo::getInventory();
         }
         if (src == DragDropSource::Inventory
             && dst == DragDropSource::Inventory)
         {
             if (Net::getNetworkType() == ServerType::TMWATHENA)
                 return;
             const int index = getSlotIndex(event.getX(), event.getY());
             if (index == Inventory::NO_SLOT_INDEX)
                 return;
             if (index == mSelectedIndex || mSelectedIndex == -1)
                 return;
             if (inventoryWindow != nullptr)
                 inventoryWindow->combineItems(index, mSelectedIndex);
             return;
         }
         else if (src == DragDropSource::Cart
                  && dst == DragDropSource::Inventory)
         {
             srcContainer = InventoryType::Cart;
             dstContainer = InventoryType::Inventory;
             inventory = PlayerInfo::getCartInventory();
         }
         else if (src == DragDropSource::Cart
                  && dst == DragDropSource::Storage)
         {
             srcContainer = InventoryType::Cart;
             dstContainer = InventoryType::Storage;
             inventory = PlayerInfo::getCartInventory();
         }
         else if (src == DragDropSource::Storage
                  && dst == DragDropSource::Cart)
         {
             srcContainer = InventoryType::Storage;
             dstContainer = InventoryType::Cart;
             inventory = PlayerInfo::getStorageInventory();
         }
         if (src == DragDropSource::Inventory
             && dst == DragDropSource::Trade)
         {
             checkProtection = true;
             inventory = PlayerInfo::getInventory();
         }
         else if (src == DragDropSource::Inventory &&
                  dst == DragDropSource::Npc)
         {
             inventory = PlayerInfo::getInventory();
             if (inventory != nullptr)
             {
                 Item *const item = inventory->getItem(dragDrop.getTag());
                 if (mInventory->addVirtualItem(
                     item,
                     getSlotByXY(event.getX(), event.getY()),
                     1))
                 {
                     inventory->virtualRemove(item, 1);
                 }
             }
             return;
         }
         else if (src == DragDropSource::Inventory &&
                  dst == DragDropSource::MailEdit)
         {
             inventory = PlayerInfo::getInventory();
             if (inventory == nullptr)
                 return;
             Item *const item = inventory->getItem(dragDrop.getTag());
             if (item == nullptr)
                 return;
             if (settings.enableNewMailSystem)
             {
                 if (item->getQuantity() > 1
                     && !inputManager.isActionActive(InputAction::STOP_ATTACK))
                 {
                     ItemAmountWindow::showWindow(
                         ItemAmountWindowUsage::MailAdd,
                         mailEditWindow,
                         item,
                         0,
                         0);
                 }
                 else
                 {
                     mail2Handler->addItem(item, 1);
                 }
             }
             else
             {
                 if (mInventory->addVirtualItem(
                     item,
                     getSlotByXY(event.getX(), event.getY()),
                     1))
                 {
                     inventory->virtualRemove(item, 1);
                 }
             }
             return;
         }
         else if (src == DragDropSource::Npc)
         {
             inventory = PlayerInfo::getInventory();
             if (dst == DragDropSource::Npc)
             {
                 const Item *const item = mInventory->getItem(
                     dragDrop.getTag());
                 const int index = getSlotByXY(event.getX(), event.getY());
                 if (index == Inventory::NO_SLOT_INDEX)
                 {
                     if (inventory != nullptr)
                         inventory->virtualRestore(item, 1);
                     mInventory->removeItemAt(dragDrop.getTag());
                     return;
                 }
                 mInventory->removeItemAt(index);
                 mInventory->setItem(index,
                     item->getId(),
                     item->getType(),
                     1,
                     1,
                     item->getColor(),
                     item->getIdentified(),
                     item->getDamaged(),
                     item->getFavorite(),
                     Equipm_false,
                     Equipped_false);
                 Item *const item2 = mInventory->getItem(index);
                 if (item2 != nullptr)
                     item2->setTag(item->getTag());
                 mInventory->removeItemAt(dragDrop.getTag());
             }
             else
             {
                 if (inventory != nullptr)
                 {
                     const Item *const item = inventory->getItem(
                         dragDrop.getTag());
                     if (item != nullptr)
                     {
                         inventory->virtualRestore(item, 1);
                         mInventory->removeItemAt(dragDrop.getTag());
                     }
                 }
                 return;
             }
         }
         else if (src == DragDropSource::Inventory &&
                  dst == DragDropSource::Craft)
         {
             inventory = PlayerInfo::getInventory();
             if (inventory != nullptr)
             {
                 Item *const item = inventory->getItem(dragDrop.getTag());
                 if ((item == nullptr) || item->isEquipped() == Equipped_true)
                     return;
                 const int slot = getSlotByXY(event.getX(), event.getY());
                 if (item->getQuantity() > 1
                     && !inputManager.isActionActive(InputAction::STOP_ATTACK))
                 {
                     ItemAmountWindow::showWindow(
                         ItemAmountWindowUsage::CraftAdd,
                         npcHandler->getCurrentNpcDialog(),
                         item,
                         0,
                         slot);
                 }
                 else
                 {
                     if (mInventory->addVirtualItem(
                         item,
                         slot,
                         1))
                     {
                         inventory->virtualRemove(item, 1);
                     }
                 }
             }
             return;
         }
         else if (src == DragDropSource::Craft)
         {
             inventory = PlayerInfo::getInventory();
             if (dst == DragDropSource::Craft)
             {
                 const Item *const item = mInventory->getItem(
                     dragDrop.getTag());
                 const int index = getSlotByXY(event.getX(), event.getY());
                 if (index == Inventory::NO_SLOT_INDEX)
                 {
                     if (inventory != nullptr)
                     {
                         inventory->virtualRestore(item,
                             item->getQuantity());
                         mInventory->removeItemAt(dragDrop.getTag());
                     }
                     return;
                 }
                 mInventory->moveItem(index, dragDrop.getTag());
             }
             else
             {
                 if (inventory != nullptr)
                 {
                     const Item *const item = inventory->getItem(
                         dragDrop.getTag());
                     if (item != nullptr)
                     {
                         inventory->virtualRestore(item,
                             item->getQuantity());
                         mInventory->removeItemAt(dragDrop.getTag());
                     }
                 }
                 return;
             }
         }
         else if (src == DragDropSource::MailEdit)
         {
             if (event.getType() == MouseEventType::RELEASED2)
                 return;
             if (settings.enableNewMailSystem)
             {
                 if (mailEditWindow == nullptr)
                     return;
                 inventory = mailEditWindow->getInventory();
                 if (inventory == nullptr)
                     return;
                 const Item *const item = inventory->getItem(dragDrop.getTag());
                 if (item == nullptr)
                     return;
                 mail2Handler->removeItem(item->getTag(),
                     item->getQuantity());
             }
             else
             {
                 inventory = PlayerInfo::getInventory();
                 if (inventory == nullptr)
                     return;
                 const Item *const item = inventory->getItem(dragDrop.getTag());
                 if (item == nullptr)
                     return;
                 mInventory->removeItemAt(dragDrop.getTag());
             }
             return;
         }
  
         if (inventory != nullptr)
         {
             const Item *const item = inventory->getItem(dragDrop.getTag());
             if (item != nullptr)
             {
                 if (srcContainer != InventoryType::TypeEnd)
                 {   // inventory <--> storage, cart
                     inventoryHandler->moveItem2(srcContainer,
                         item->getInvIndex(),
                         item->getQuantity(),
                         dstContainer);
                 }
                 else
                 {   // inventory --> trade
                     if (!checkProtection || !PlayerInfo::isItemProtected(
                         item->getId()))
                     {
                         tradeHandler->addItem(item, item->getQuantity());
                     }
                 }
             }
         }
     }
 }

References Net::TradeHandler::addItem(), Net::Mail2Handler::addItem(), Inventory::addVirtualItem(), DragDropSource::Cart, InventoryType::Cart, InventoryWindow::combineItems(), DragDropSource::Craft, InventoryType::Craft, ItemAmountWindowUsage::CraftAdd, dragDrop, DragDropSource::Empty, Settings::enableNewMailSystem, Equipm_false, Equipped_false, Equipped_true, PlayerInfo::getCartInventory(), Item::getColor(), Net::NpcHandler::getCurrentNpcDialog(), Item::getDamaged(), Item::getFavorite(), Item::getId(), Item::getIdentified(), PlayerInfo::getInventory(), MailEditWindow::getInventory(), Item::getInvIndex(), Inventory::getItem(), Net::getNetworkType(), Item::getQuantity(), getSlotByXY(), getSlotIndex(), DragDrop::getSource(), PlayerInfo::getStorageInventory(), DragDrop::getTag(), Item::getTag(), MouseEvent::getType(), Inventory::getType(), Item::getType(), MouseEvent::getX(), MouseEvent::getY(), inputManager, DragDropSource::Inventory, InventoryType::Inventory, inventoryHandler, inventoryWindow, InputManager::isActionActive(), DragDrop::isEmpty(), Item::isEquipped(), PlayerInfo::isItemProtected(), mail2Handler, ItemAmountWindowUsage::MailAdd, DragDropSource::MailEdit, InventoryType::MailEdit, mailEditWindow, DragDropSource::MailView, InventoryType::MailView, mClicks, mInventory, Inventory::moveItem(), Net::InventoryHandler::moveItem(), Net::InventoryHandler::moveItem2(), mSelectedIndex, mSelectionStatus, Inventory::NO_SLOT_INDEX, DragDropSource::Npc, InventoryType::Npc, npcHandler, MouseEventType::RELEASED2, Net::Mail2Handler::removeItem(), Inventory::removeItemAt(), SEL_DESELECTING, SEL_DRAGGING, SEL_NONE, SEL_SELECTED, SEL_SELECTING, selectNone(), Inventory::setItem(), Item::setTag(), settings, ItemAmountWindow::showWindow(), InputAction::STOP_ATTACK, DragDropSource::Storage, InventoryType::Storage, ServerType::TMWATHENA, DragDropSource::Trade, InventoryType::Trade, tradeHandler, InventoryType::TypeEnd, InventoryType::Vending, Inventory::virtualRemove(), and Inventory::virtualRestore().

◆ removeSelectionListener()

void ItemContainer::removeSelectionListener ( SelectionListener * listener )

inline

Removes a listener from the list that's notified each time a change to the selection occurs.

Definition at line 117 of file itemcontainer.h.

118 { mSelectionListeners.remove(listener); }

References anonymous_namespace{itemlinkhandler.cpp}::listener, and mSelectionListeners.

◆ safeDraw()

void ItemContainer::safeDraw ( Graphics *const graphics )

virtual

Implements Widget.

Definition at line 456 of file itemcontainer.cpp.

 {
     if ((mInventory == nullptr) || (mShowMatrix == nullptr))
         return;
  
     BLOCK_START("ItemContainer::draw")
     Font *const font = getFont();
  
     if (mCellBackgroundImg != nullptr)
     {
         const int invSize = mInventory->getSize();
         const int maxRows = mShowEmptyRows == ShowEmptyRows_true ?
             std::max(invSize / mGridColumns, mGridRows) : mGridRows;
         const int maxColumns = mGridColumns > invSize ?
             invSize : mGridColumns;
         for (int j = 0; j < maxRows; j++)
         {
             const int intY0 = j * mBoxHeight;
             for (int i = 0; i < maxColumns; i++)
             {
                 int itemX = i * mBoxWidth;
                 int itemY = intY0;
                 graphics->drawImage(mCellBackgroundImg,
                     itemX + mPaddingItemX,
                     itemY + mPaddingItemY);
             }
         }
     }
  
     for (int j = 0; j < mDrawRows; j++)
     {
         const int intY0 = j * mBoxHeight;
         int itemIndex = j * mGridColumns - 1;
         for (int i = 0; i < mGridColumns; i++)
         {
             itemIndex ++;
             if (mShowMatrix[itemIndex] < 0)
                 continue;
  
             const Item *const item = mInventory->getItem(
                 mShowMatrix[itemIndex]);
  
             if ((item == nullptr) || item->getId() == 0)
                 continue;
  
             Image *const image = item->getImage();
             if (image != nullptr)
             {
                 int itemX = i * mBoxWidth;
                 int itemY = intY0;
                 if (mShowMatrix[itemIndex] == mSelectedIndex)
                 {
                     if (mSelImg != nullptr)
                         graphics->drawImage(mSelImg, itemX, itemY);
                 }
                 image->setAlpha(1.0F);  // ensure the image if fully drawn...
                 graphics->drawImage(image,
                     itemX + mPaddingItemX,
                     itemY + mPaddingItemY);
                 if ((mProtectedImg != nullptr) && PlayerInfo::isItemProtected(
                     item->getId()))
                 {
                     graphics->drawImage(mProtectedImg,
                         itemX + mPaddingItemX,
                         itemY + mPaddingItemY);
                 }
             }
         }
     }
  
     for (int j = 0; j < mDrawRows; j++)
     {
         const int intY0 = j * mBoxHeight;
         int itemIndex = j * mGridColumns - 1;
         for (int i = 0; i < mGridColumns; i++)
         {
             int itemX = i * mBoxWidth;
             int itemY = intY0;
             itemIndex ++;
             if (mShowMatrix[itemIndex] < 0)
                 continue;
  
             const Item *const item = mInventory->getItem(
                 mShowMatrix[itemIndex]);
  
             if ((item == nullptr) || item->getId() == 0)
                 continue;
  
             // Draw item caption
             std::string caption;
             if (item->getQuantity() > 1 ||
                 mForceQuantity == ForceQuantity_true)
             {
                 caption = toString(item->getQuantity());
             }
             else if (item->isEquipped() == Equipped_true)
             {
                 // TRANSLATORS: Text under equipped items (should be small)
                 caption = _("Eq.");
             }
  
             if (item->isEquipped() == Equipped_true)
             {
                 font->drawString(graphics,
                     mEquipedColor, mEquipedColor2,
                     caption,
                     itemX + (mBoxWidth - font->getWidth(caption)) / 2,
                     itemY + mEquippedTextPadding);
             }
             else
             {
                 font->drawString(graphics,
                     mUnEquipedColor, mUnEquipedColor2,
                     caption,
                     itemX + (mBoxWidth - font->getWidth(caption)) / 2,
                     itemY + mEquippedTextPadding);
             }
         }
     }
     BLOCK_END("ItemContainer::draw")
 }

References _, BLOCK_END, BLOCK_START, Graphics::drawImage(), Font::drawString(), Equipped_true, ForceQuantity_true, Widget::getFont(), Item::getId(), Item::getImage(), Inventory::getItem(), Item::getQuantity(), Inventory::getSize(), Font::getWidth(), Item::isEquipped(), PlayerInfo::isItemProtected(), mBoxHeight, mBoxWidth, mCellBackgroundImg, mDrawRows, mEquipedColor, mEquipedColor2, mEquippedTextPadding, mForceQuantity, mGridColumns, mGridRows, mInventory, mPaddingItemX, mPaddingItemY, mProtectedImg, mSelectedIndex, mSelImg, mShowEmptyRows, mShowMatrix, mUnEquipedColor, mUnEquipedColor2, ShowEmptyRows_true, and Catch::toString().

◆ selectNone()

void ItemContainer::selectNone ( )

Sets selected item to NULL.

Definition at line 578 of file itemcontainer.cpp.

 {
     dragDrop.clear();
  
     setSelectedIndex(-1);
     mSelectionStatus = SEL_NONE;
 /*
     if (outfitWindow)
         outfitWindow->setItemSelected(-1);
     if (shopWindow)
         shopWindow->setItemSelected(-1);
 */
 }

References DragDrop::clear(), dragDrop, mSelectionStatus, SEL_NONE, and setSelectedIndex().

Referenced by mousePressed(), mouseReleased(), InventoryWindow::unselectItem(), and TradeWindow::valueChanged().

◆ setCellBackgroundImage()

void ItemContainer::setCellBackgroundImage ( const std::string & xmlName )

Definition at line 1315 of file itemcontainer.cpp.

 {
     if (mCellBackgroundImg != nullptr)
         mCellBackgroundImg->decRef();
     mCellBackgroundImg = Theme::getImageFromThemeXml(xmlName, "");
     mRedraw = true;
 }

References Theme::getImageFromThemeXml(), mCellBackgroundImg, and Widget::mRedraw.

Referenced by NpcDialog::placeItemInputControls().

◆ setFilter()

void ItemContainer::setFilter ( const int tag )

Definition at line 1303 of file itemcontainer.cpp.

 {
     mTag = tag;
     adjustHeight();
 }

References adjustHeight(), and mTag.

Referenced by InventoryWindow::action().

◆ setInventory()

void ItemContainer::setInventory ( Inventory *const inventory )

inline

Definition at line 135 of file itemcontainer.h.

136 { mInventory = inventory; }

References mInventory.

Referenced by NpcDialog::placeItemInputControls().

◆ setMaxColumns()

void ItemContainer::setMaxColumns ( const int maxColumns )

Definition at line 1323 of file itemcontainer.cpp.

 {
     mMaxColumns = maxColumns;
     updateSize();
 }

References mMaxColumns, and updateSize().

Referenced by NpcDialog::placeItemInputControls().

◆ setName()

void ItemContainer::setName ( const std::string & str )

inline

Definition at line 124 of file itemcontainer.h.

125 { mName = str; }

References mName.

Referenced by InventoryWindow::action().

◆ setSelectedIndex()

void ItemContainer::setSelectedIndex ( const int index )

private

Sets the currently selected item.

Definition at line 592 of file itemcontainer.cpp.

 {
     if (mSelectedIndex != newIndex)
     {
         mSelectedIndex = newIndex;
         distributeValueChangedEvent();
     }
 }

References distributeValueChangedEvent(), and mSelectedIndex.

Referenced by mousePressed(), and selectNone().

◆ setSortType()

void ItemContainer::setSortType ( const int sortType )

Definition at line 1309 of file itemcontainer.cpp.

 {
     mSortType = sortType;
     updateMatrix();
 }

References mSortType, and updateMatrix().

Referenced by InventoryWindow::action(), and InventoryWindow::postInit().

◆ unsetInventory()

void ItemContainer::unsetInventory ( )

inline

Definition at line 132 of file itemcontainer.h.

133 { mInventory = nullptr; }

References mInventory.

Referenced by InventoryWindow::unsetInventory().

◆ updateMatrix()

int ItemContainer::updateMatrix ( )

Definition at line 1168 of file itemcontainer.cpp.

 {
     if (mInventory == nullptr)
         return 0;
  
     mRedraw = true;
     delete []mShowMatrix;
     mShowMatrix = new int[CAST_SIZE(mGridRows * mGridColumns)];
  
     STD_VECTOR<ItemIdPair*> sortedItems;
     int i = 0;
     int j = 0;
  
     std::string temp = mName;
     toLower(temp);
  
     const unsigned int invSize = mInventory->getSize();
     for (unsigned int idx = 0; idx < invSize; idx ++)
     {
         Item *const item = mInventory->getItem(idx);
  
         if (item == nullptr ||
             item->getId() == 0 ||
             !item->isHaveTag(mTag) ||
             item->getQuantity() == 0)
         {
             if (mShowEmptyRows == ShowEmptyRows_true)
                 sortedItems.push_back(new ItemIdPair(idx, nullptr));
             continue;
         }
  
         if (!item->isHaveTag(mTag))
             continue;
  
         if (mName.empty())
         {
             sortedItems.push_back(new ItemIdPair(idx, item));
             continue;
         }
         std::string name = item->getInfo().getName();
         toLower(name);
         if (name.find(temp) != std::string::npos)
             sortedItems.push_back(new ItemIdPair(idx, item));
     }
  
     switch (mSortType)
     {
         case 0:
         default:
             break;
         case 1:
             std::sort(sortedItems.begin(), sortedItems.end(),
                 itemAlphaInvSorter);
             break;
         case 2:
             std::sort(sortedItems.begin(), sortedItems.end(), itemIdInvSorter);
             break;
         case 3:
             std::sort(sortedItems.begin(), sortedItems.end(),
                 itemWeightInvSorter);
             break;
         case 4:
             std::sort(sortedItems.begin(), sortedItems.end(),
                 itemAmountInvSorter);
             break;
         case 5:
             std::sort(sortedItems.begin(), sortedItems.end(),
                 itemTypeInvSorter);
             break;
     }
  
     int jMult = j * mGridColumns;
     const int maxSize = mGridRows * mGridColumns;
     FOR_EACH (STD_VECTOR<ItemIdPair*>::const_iterator, iter, sortedItems)
     {
         if (jMult >= maxSize)
             break;
  
         mShowMatrix[jMult + i] = (*iter)->mId;
  
         i ++;
         if (i >= mGridColumns)
         {
             i = 0;
             j ++;
             jMult += mGridColumns;
         }
     }
  
     for (int idx = j * mGridColumns + i; idx < maxSize; idx ++)
         mShowMatrix[idx] = -1;
  
     const int num = CAST_S32(sortedItems.size());
     for (size_t idx = 0, sz = num; idx < sz; idx ++)
         delete sortedItems[idx];
     return num;
 }

References CAST_S32, CAST_SIZE, FOR_EACH, Item::getId(), Item::getInfo(), Inventory::getItem(), ItemInfo::getName(), Item::getQuantity(), Inventory::getSize(), Item::isHaveTag(), anonymous_namespace{itemcontainer.cpp}::itemAlphaInvSorter, anonymous_namespace{itemcontainer.cpp}::itemAmountInvSorter, anonymous_namespace{itemcontainer.cpp}::itemIdInvSorter, anonymous_namespace{itemcontainer.cpp}::itemTypeInvSorter, anonymous_namespace{itemcontainer.cpp}::itemWeightInvSorter, mGridColumns, mGridRows, mInventory, mName, Widget::mRedraw, mShowEmptyRows, mShowMatrix, mSortType, mTag, ShowEmptyRows_true, and Catch::toLower().

Referenced by InventoryWindow::action(), adjustHeight(), setSortType(), InventoryWindow::slotsChanged(), MailEditWindow::updateItems(), and MailViewWindow::updateItems().

◆ updateSize()

void ItemContainer::updateSize ( )

private

Definition at line 1117 of file itemcontainer.cpp.

 {
     mGridColumns = std::min(mMaxColumns,
         std::max(1, mDimension.width / mBoxWidth));
     if (mGridColumns > mMaxColumns)
         mGridColumns = mMaxColumns;
     adjustHeight();
     mRedraw = true;
 }

References adjustHeight(), mBoxWidth, Widget::mDimension, mGridColumns, mMaxColumns, Widget::mRedraw, and Rect::width.

Referenced by setMaxColumns(), and widgetResized().

◆ widgetMoved()

void ItemContainer::widgetMoved ( const Event & event )

virtual

Invoked when a widget is moved.

Parameters

event Describes the event.

Reimplemented from WidgetListener.

Definition at line 1127 of file itemcontainer.cpp.

 {
     mRedraw = true;
 }

References Widget::mRedraw.

◆ widgetResized()

void ItemContainer::widgetResized ( const Event & event )

virtual

Invoked when a widget changes its size.

Parameters

event Describes the event.

Reimplemented from WidgetListener.

Definition at line 1112 of file itemcontainer.cpp.

 {
     updateSize();
 }

References updateSize().

Field Documentation

◆ mBoxHeight

int ItemContainer::mBoxHeight

private

Definition at line 213 of file itemcontainer.h.

Referenced by adjustHeight(), draw(), getSlotByXY(), getSlotIndex(), and safeDraw().

◆ mBoxWidth

int ItemContainer::mBoxWidth

private

Definition at line 212 of file itemcontainer.h.

Referenced by draw(), getSlotByXY(), getSlotIndex(), safeDraw(), and updateSize().

◆ mCellBackgroundImg

Image* ItemContainer::mCellBackgroundImg

private

Definition at line 191 of file itemcontainer.h.

Referenced by draw(), safeDraw(), setCellBackgroundImage(), and ~ItemContainer().

◆ mClicks

int ItemContainer::mClicks

private

Definition at line 211 of file itemcontainer.h.

Referenced by getClickCount(), mousePressed(), and mouseReleased().

◆ mDescItems

bool ItemContainer::mDescItems

private

Definition at line 221 of file itemcontainer.h.

Referenced by mousePressed().

◆ mDrawRows

int ItemContainer::mDrawRows

private

Definition at line 206 of file itemcontainer.h.

Referenced by adjustHeight(), draw(), and safeDraw().

◆ mEquipedColor

Color ItemContainer::mEquipedColor

private

Definition at line 197 of file itemcontainer.h.

Referenced by draw(), and safeDraw().

◆ mEquipedColor2

Color ItemContainer::mEquipedColor2

private

Definition at line 198 of file itemcontainer.h.

Referenced by draw(), and safeDraw().

◆ mEquippedTextPadding

int ItemContainer::mEquippedTextPadding

private

Definition at line 214 of file itemcontainer.h.

Referenced by draw(), and safeDraw().

◆ mForceQuantity

ForceQuantity ItemContainer::mForceQuantity

private

Definition at line 219 of file itemcontainer.h.

Referenced by draw(), and safeDraw().

◆ mGridColumns

int ItemContainer::mGridColumns

private

Definition at line 204 of file itemcontainer.h.

Referenced by adjustHeight(), draw(), getSlotByXY(), getSlotIndex(), safeDraw(), updateMatrix(), and updateSize().

◆ mGridRows

int ItemContainer::mGridRows

private

Definition at line 205 of file itemcontainer.h.

Referenced by adjustHeight(), draw(), getSlotByXY(), getSlotIndex(), safeDraw(), and updateMatrix().

◆ mInventory

Inventory* ItemContainer::mInventory

private

Definition at line 188 of file itemcontainer.h.

Referenced by adjustHeight(), draw(), getSelectedItem(), logic(), mouseMoved(), mousePressed(), mouseReleased(), safeDraw(), setInventory(), unsetInventory(), and updateMatrix().

◆ mLastUsedSlot

int ItemContainer::mLastUsedSlot

private

Definition at line 208 of file itemcontainer.h.

Referenced by adjustHeight(), and logic().

◆ mMaxColumns

int ItemContainer::mMaxColumns

private

Definition at line 217 of file itemcontainer.h.

Referenced by setMaxColumns(), and updateSize().

◆ mName

std::string ItemContainer::mName

private

Definition at line 192 of file itemcontainer.h.

Referenced by setName(), and updateMatrix().

◆ mPaddingItemX

int ItemContainer::mPaddingItemX

private

Definition at line 215 of file itemcontainer.h.

Referenced by draw(), and safeDraw().

◆ mPaddingItemY

int ItemContainer::mPaddingItemY

private

Definition at line 216 of file itemcontainer.h.

Referenced by draw(), and safeDraw().

◆ mProtectedImg

Image* ItemContainer::mProtectedImg

private

Definition at line 190 of file itemcontainer.h.

Referenced by draw(), safeDraw(), and ~ItemContainer().

◆ mSelectedIndex

int ItemContainer::mSelectedIndex

private

Definition at line 207 of file itemcontainer.h.

Referenced by draw(), getSelectedItem(), mousePressed(), mouseReleased(), safeDraw(), and setSelectedIndex().

◆ mSelectionListeners

SelectionListenerList ItemContainer::mSelectionListeners

private

Definition at line 203 of file itemcontainer.h.

Referenced by addSelectionListener(), distributeValueChangedEvent(), and removeSelectionListener().

◆ mSelectionStatus

SelectionState ItemContainer::mSelectionStatus

private

Definition at line 218 of file itemcontainer.h.

Referenced by mouseDragged(), mousePressed(), mouseReleased(), and selectNone().

◆ mSelImg

Image* ItemContainer::mSelImg

private

Definition at line 189 of file itemcontainer.h.

Referenced by draw(), safeDraw(), and ~ItemContainer().

◆ mShowEmptyRows

ShowEmptyRows ItemContainer::mShowEmptyRows

private

Definition at line 220 of file itemcontainer.h.

Referenced by adjustHeight(), draw(), safeDraw(), and updateMatrix().

◆ mShowMatrix

int* ItemContainer::mShowMatrix

private

Definition at line 194 of file itemcontainer.h.

Referenced by draw(), getSlotByXY(), getSlotIndex(), safeDraw(), updateMatrix(), and ~ItemContainer().

◆ mSkin

Skin* ItemContainer::mSkin

private

Definition at line 195 of file itemcontainer.h.

Referenced by ~ItemContainer().

◆ mSortType

int ItemContainer::mSortType

private

Definition at line 210 of file itemcontainer.h.

Referenced by setSortType(), and updateMatrix().

◆ mTag

int ItemContainer::mTag

private

Definition at line 209 of file itemcontainer.h.

Referenced by setFilter(), and updateMatrix().

◆ mUnEquipedColor

Color ItemContainer::mUnEquipedColor

private

Definition at line 199 of file itemcontainer.h.

Referenced by draw(), and safeDraw().

◆ mUnEquipedColor2

Color ItemContainer::mUnEquipedColor2

private

Definition at line 200 of file itemcontainer.h.

Referenced by draw(), and safeDraw().

◆ mVertexes

ImageCollection* ItemContainer::mVertexes

private

Definition at line 196 of file itemcontainer.h.

Referenced by draw(), and ~ItemContainer().

The documentation for this class was generated from the following files:

src/gui/widgets/itemcontainer.h (986a3bf)
src/gui/widgets/itemcontainer.cpp (986a3bf)

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ SelectionListenerIterator

◆ SelectionListenerList

Member Enumeration Documentation

◆ Direction

◆ SelectionState

Constructor & Destructor Documentation

◆ ItemContainer()

◆ ~ItemContainer()

Member Function Documentation

◆ addSelectionListener()

◆ adjustHeight()

◆ distributeValueChangedEvent()

◆ draw()

◆ getClickCount()

◆ getSelectedItem()

◆ getSlotByXY()

◆ getSlotIndex()

◆ keyPressed()

◆ keyReleased()

◆ logic()

◆ mouseDragged()

◆ mouseExited()

◆ mouseMoved()

◆ mousePressed()

◆ mouseReleased()

◆ removeSelectionListener()

◆ safeDraw()

◆ selectNone()

◆ setCellBackgroundImage()

◆ setFilter()

◆ setInventory()

◆ setMaxColumns()

◆ setName()

◆ setSelectedIndex()

◆ setSortType()

◆ unsetInventory()

◆ updateMatrix()

◆ updateSize()

◆ widgetMoved()

◆ widgetResized()

Field Documentation

◆ mBoxHeight

◆ mBoxWidth

◆ mCellBackgroundImg

◆ mClicks

◆ mDescItems

◆ mDrawRows

◆ mEquipedColor

◆ mEquipedColor2

◆ mEquippedTextPadding

◆ mForceQuantity

◆ mGridColumns

◆ mGridRows

◆ mInventory

◆ mLastUsedSlot

◆ mMaxColumns

◆ mName

◆ mPaddingItemX

◆ mPaddingItemY

◆ mProtectedImg

◆ mSelectedIndex

◆ mSelectionListeners

◆ mSelectionStatus

◆ mSelImg

◆ mShowEmptyRows

◆ mShowMatrix

◆ mSkin

◆ mSortType

◆ mTag

◆ mUnEquipedColor

◆ mUnEquipedColor2

◆ mVertexes