UNLOZE/sourcemod
10
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
07901946d0
sourcemod/public/IMenuManager.h

933 lines
28 KiB
C++
Raw Blame History

/**
* vim: set ts=4 :
* =============================================================================
* SourceMod
* Copyright (C) 2004-2008 AlliedModders LLC. All rights reserved.
* =============================================================================
*
* This program is free software; you can redistribute it and/or modify it under
* the terms of the GNU General Public License, version 3.0, as published by the
* Free Software Foundation.
*
* This program 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 General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License along with
* this program. If not, see <http://www.gnu.org/licenses/>.
*
* As a special exception, AlliedModders LLC gives you permission to link the
* code of this program (as well as its derivative works) to "Half-Life 2," the
* "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
* by the Valve Corporation. You must obey the GNU General Public License in
* all respects for all other code used. Additionally, AlliedModders LLC grants
* this exception to all derivative works. AlliedModders LLC defines further
* exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
* or <http://www.sourcemod.net/license.php>.
*
* Version: $Id$
*/
#ifndef _INCLUDE_SOURCEMOD_MENU_SYSTEM_H_
#define _INCLUDE_SOURCEMOD_MENU_SYSTEM_H_
#include <IShareSys.h>
#include <IHandleSys.h>
#define SMINTERFACE_MENUMANAGER_NAME "IMenuManager"
#define SMINTERFACE_MENUMANAGER_VERSION 16
/**
* @file IMenuManager.h
* @brief Abstracts on-screen menus for clients.
*/
namespace SourceMod
{
/**
* @brief Used to determine how an item selection is interpreted.
*/
enum ItemSelection
{
ItemSel_None, /**< Invalid selection */
ItemSel_Back, /**< Go back one page (really "Previous") */
ItemSel_Next, /**< Go forward one page */
ItemSel_Exit, /**< Menu was exited */
ItemSel_Item, /**< Valid item selection */
ItemSel_ExitBack, /**< Sends MenuEnd_ExitBack */
};
/**
* @brief Used to determine which order to search for items in.
*/
enum ItemOrder
{
ItemOrder_Ascending, /**< Items should be drawn ascendingly */
ItemOrder_Descending, /**< Items should be drawn descendingly */
};
/**
* @brief Pairs an item type with an item menu position.
*/
struct menu_slots_t
{
ItemSelection type; /**< Item selection type */
unsigned int item; /**< Item position, if applicable */
};
class IBaseMenu;
class IMenuPanel;
class IMenuHandler;
/**
* @brief Describes menu display information.
*/
struct menu_states_t
{
unsigned int apiVers; /**< Must be filled with the API version */
IBaseMenu *menu; /**< Menu pointer, or NULL if there is only a display */
IMenuHandler *mh; /**< Menu callbacks handler */
unsigned int firstItem; /**< MENU ONLY: First item displayed on the last page */
unsigned int lastItem; /**< MENU ONLY: Last item displayed on the last page */
unsigned int item_on_page; /**< MENU ONLY: First item on page */
menu_slots_t slots[11]; /**< MENU ONLY: Item selection table (first index is 1) */
};
#define ITEMDRAW_DEFAULT (0) /**< Item should be drawn normally */
#define ITEMDRAW_DISABLED (1<<0) /**< Item is drawn but not selectable */
#define ITEMDRAW_RAWLINE (1<<1) /**< Item should be a raw line, without a slot */
#define ITEMDRAW_NOTEXT (1<<2) /**< No text should be drawn */
#define ITEMDRAW_SPACER (1<<3) /**< Item should be drawn as a spacer, if possible */
#define ITEMDRAW_IGNORE ((1<<1)|(1<<2)) /**< Item should be completely ignored (rawline + notext) */
#define ITEMDRAW_CONTROL (1<<4) /**< Item is control text (back/next/exit) */
/**
* @brief Information about item drawing.
*/
struct ItemDrawInfo
{
ItemDrawInfo(const char *DISPLAY=NULL, unsigned int STYLE=ITEMDRAW_DEFAULT,
unsigned int FLAGS=0, const char *HELPTEXT=NULL)
: display(DISPLAY), style(STYLE)
{
}
const char *display; /**< Display text (NULL for none) */
unsigned int style; /**< ITEMDRAW style flags */
};
/**
* @brief Contains information about a vote result.
*/
struct menu_vote_result_t
{
unsigned int num_clients; /**< Number of clients the menu was displayed to */
unsigned int num_votes; /**< Number of votes received */
struct menu_client_vote_t
{
int client; /**< Client index */
int item; /**< Item # (or -1 for none) */
} *client_list; /**< Array of size num_clients */
unsigned int num_items; /**< Number of items voted for */
struct menu_item_vote_t
{
unsigned int item; /**< Item index */
unsigned int count; /**< Number of votes */
} *item_list; /**< Array of size num_items, sorted by count,
descending */
};
/**
* @brief Reasons for a menu dying.
*/
enum MenuCancelReason
{
MenuCancel_Disconnected = -1, /**< Client dropped from the server */
MenuCancel_Interrupted = -2, /**< Client was interrupted with another menu */
MenuCancel_Exit = -3, /**< Client selected "exit" on a paginated menu */
MenuCancel_NoDisplay = -4, /**< Menu could not be displayed to the client */
MenuCancel_Timeout = -5, /**< Menu timed out */
MenuCancel_ExitBack = -6, /**< Client selected "exit back" on a paginated menu */
};
/**
* @brief Reasons a menu ended.
*/
enum MenuEndReason
{
MenuEnd_Selected = 0, /**< Menu item was selected */
MenuEnd_VotingDone = -1, /**< Voting finished */
MenuEnd_VotingCancelled = -2, /**< Voting was cancelled */
MenuEnd_Cancelled = -3, /**< Menu was uncleanly cancelled */
MenuEnd_Exit = -4, /**< Menu was cleanly exited via "exit" */
MenuEnd_ExitBack = -5, /**< Menu was cleanly exited via "back" */
};
/**
* @brief Reasons a vote can be cancelled.
*/
enum VoteCancelReason
{
VoteCancel_Generic = -1, /**< Vote was generically cancelled. */
VoteCancel_NoVotes = -2, /**< Vote did not receive any votes. */
};
#define MENU_NO_PAGINATION 0 /**< Menu should not be paginated (10 items max) */
#define MENU_TIME_FOREVER 0 /**< Menu should be displayed as long as possible */
#define MENUFLAG_BUTTON_EXIT (1<<0) /**< Menu has an "exit" button */
#define MENUFLAG_BUTTON_EXITBACK (1<<1) /**< Menu has an "exit back" button */
#define MENUFLAG_NO_SOUND (1<<2) /**< Menu will not have any select sounds */
#define VOTEFLAG_NO_REVOTES (1<<0) /**< Players cannot change their votes */
/**
* @brief Extended menu options.
*/
enum MenuOption
{
MenuOption_IntroMessage, /**< CONST CHAR *: Valve menus only; defaults to:
"You have a menu, hit ESC"
*/
MenuOption_IntroColor, /**< INT[4]: Valve menus only; specifies the intro message colour
using R,G,B,A (defaults to 255,0,0,255)
*/
MenuOption_Priority, /**< INT *: Valve menus only; priority (less is higher) */
};
/**
* @brief Describes the menu a player is viewing.
*/
enum MenuSource
{
MenuSource_None = 0, /**< No menu is being displayed */
MenuSource_External = 1, /**< External menu, no pointer */
MenuSource_BaseMenu = 2, /**< An IBaseMenu pointer. */
MenuSource_Display = 3, /**< IMenuPanel source, no pointer */
};
class IMenuStyle;
/**
* @brief Sets how a raw menu should be drawn.
*/
class IMenuPanel
{
public:
/**
* @brief Returns the parent IMenuStyle pointer.
*
* @return IMenuStyle pointer which created
* this object.
*/
virtual IMenuStyle *GetParentStyle() =0;
/**
* @brief Resets/clears the cached display text.
*/
virtual void Reset() =0;
/**
* @brief Sets how the title should be drawn.
*
* @param text Text string to display for the title.
* @param onlyIfEmpty Only sets the title if one does not already
* exist.
*/
virtual void DrawTitle(const char *text, bool onlyIfEmpty=false) =0;
/**
* @brief Adds an item to the menu and returns the position (1-10).
*
* Note: Item will fail to draw if there are too many items,
* or the item is not drawable (for example, invisible).
*
* @return Item draw position, or 0 on failure.
*/
virtual unsigned int DrawItem(const ItemDrawInfo &item) =0;
/**
* @brief Draws a raw line of text, if supported. The line does not
* need to be newline terminated.
*
* @return True on success, false if not supported.
*/
virtual bool DrawRawLine(const char *rawline) =0;
/**
* @brief Sets an extended menu option.
*
* @param option Option type.
* @param valuePtr Pointer of the type expected by the option.
* @return True on success, false if option or value is not supported.
*/
virtual bool SetExtOption(MenuOption option, const void *valuePtr) =0;
/**
* @brief Returns whether the display is capable of rendering an item
* with the given flags.
*
* @param drawFlags ITEMDRAW flags.
* @return True if renderable, false otherwise.
*/
virtual bool CanDrawItem(unsigned int drawFlags) =0;
/**
* @brief Sends the menu display to a client.
*
* @param client Client index to display to.
* @param handler Menu handler to use.
* @param time Time to hold menu for.
* @return True on success, false otherwise.
*/
virtual bool SendDisplay(int client, IMenuHandler *handler, unsigned int time) =0;
/**
* @brief Destroys the display object.
*/
virtual void DeleteThis() =0;
/**
* @brief Sets the selectable key map. Returns false if the function
* is not supported.
*
* @param keymap A bit string where each bit N-1 specifies
* that key N is selectable (key 0 is bit 9).
* If the selectable key map is 0, it will be
* automatically set to allow 0.
* @return True on success, false if not supported.
*/
virtual bool SetSelectableKeys(unsigned int keymap) =0;
/**
* @brief Returns the current key position.
*
* @return Current key position starting at 1.
*/
virtual unsigned int GetCurrentKey() =0;
/**
* @brief Sets the next key position. This cannot be used
* to traverse backwards.
*
* @param key Key that is greater or equal to
* GetCurrentKey().
* @return True on success, false otherwise.
*/
virtual bool SetCurrentKey(unsigned int key) =0;
/**
* @brief Returns the number of characters that can be added to the
* menu. The internal buffer is truncated if overflowed; this is for
* manual truncation/wrapping purposes.
*
* @return Number of bytes available. If the result is
* -1, then the panel has no text limit.
*/
virtual int GetAmountRemaining() =0;
/**
* @brief For the Handle system, returns approximate memory usage.
*
* @return Approximate number of bytes being used.
*/
virtual unsigned int GetApproxMemUsage() =0;
};
/**
* @brief Describes a "MenuStyle" system which manages
* menu drawing and construction.
*/
class IMenuStyle
{
public:
/**
* @brief Returns the style API version.
*
* @return API version.
*/
virtual unsigned int GetStyleAPIVersion()
{
return SMINTERFACE_MENUMANAGER_VERSION;
}
/**
* @brief Returns the name of the menu style.
*
* @return String containing the style name.
*/
virtual const char *GetStyleName() =0;
/**
* @brief Creates an IMenuPanel object.
*
* Note: the object should be freed using ::DeleteThis.
*
* @return IMenuPanel object.
*/
virtual IMenuPanel *CreatePanel() =0;
/**
* @brief Creates an IBaseMenu object of this style.
*
* Note: the object should be freed using IBaseMenu::Destroy.
*
* @param handler IMenuHandler pointer.
* @param pOwner Optional IdentityToken_t owner for handle
* creation.
* @return An IBaseMenu pointer.
*/
virtual IBaseMenu *CreateMenu(IMenuHandler *handler, IdentityToken_t *pOwner=NULL) =0;
/**
* @brief Returns the maximum number of items per page.
*
* Menu implementations must return >= 2. Styles with only 1 or 0
* items per page are not valid.
*
* @return Number of items per page.
*/
virtual unsigned int GetMaxPageItems() =0;
/**
* @brief Returns whether or not a client is viewing a menu.
*
* @param client Client index.
* @param object Optional pointer to retrieve menu object,
* if any.
* @return MenuSource value.
*/
virtual MenuSource GetClientMenu(int client, void **object) =0;
/**
* @brief Cancels a client's menu.
*
* @param client Client index.
* @param autoIgnore If true, no menus can be created during
* the cancellation process.
* @return True if a menu was cancelled, false otherwise.
*/
virtual bool CancelClientMenu(int client, bool autoIgnore=false) =0;
/**
* @brief Returns a Handle the IMenuStyle object.
*
* @return Handle_t pointing to this object.
*/
virtual Handle_t GetHandle() =0;
/**
* @brief For the Handle system, returns approximate memory usage.
*
* @return Approximate number of bytes being used.
*/
virtual unsigned int GetApproxMemUsage() =0;
};
/**
* @brief High-level interface for building menus.
*/
class IBaseMenu
{
public:
/**
* @brief Appends an item to the end of a menu.
*
* @param info Item information string.
* @param draw Default drawing information.
* @return True on success, false on item limit reached.
*/
virtual bool AppendItem(const char *info, const ItemDrawInfo &draw) =0;
/**
* @brief Inserts an item into the menu before a certain position;
* the new item will be at the given position and all next items
* pushed forward.
*
* @param position Position, starting from 0.
* @param info Item information string.
* @param draw Default item draw info.
* @return True on success, false on invalid menu position
*/
virtual bool InsertItem(unsigned int position, const char *info, const ItemDrawInfo &draw) =0;
/**
* @brief Removes an item from the menu.
*
* @param position Position, starting from 0.
* @return True on success, false on invalid menu position.
*/
virtual bool RemoveItem(unsigned int position) =0;
/**
* @brief Removes all items from the menu.
*/
virtual void RemoveAllItems() =0;
/**
* @brief Returns an item's info.
*
* @param position Position, starting from 0.
* @param draw Optional pointer to store a draw information.
* @return Info string pointer, or NULL if position was invalid.
*/
virtual const char *GetItemInfo(unsigned int position, ItemDrawInfo *draw) =0;
/**
* @brief Returns the number of items.
*
* @return Number of items in the menu.
*/
virtual unsigned int GetItemCount() =0;
/**
* @brief Sets the menu's pagination,.
*
* If pagination is set to MENU_NO_PAGINATION, and the previous
* pagination was not MENU_NO_PAGINATION, then the MENUFLAG_BUTTON_EXIT
* is unset. It can be re-applied if desired.
*
* @param itemsPerPage Number of items per page, or MENU_NO_PAGINATION.
* @return True on success, false if itemsPerPage is too
* large.
*/
virtual bool SetPagination(unsigned int itemsPerPage) =0;
/**
* @brief Returns an item's pagination.
*
* @return Pagination setting.
*/
virtual unsigned int GetPagination() =0;
/**
* @brief Returns the menu style.
*
* @return Menu style.
*/
virtual IMenuStyle *GetDrawStyle() =0;
/**
* @brief Sets the menu's display title/message.
*
* @param message Message (format options allowed).
*/
virtual void SetDefaultTitle(const char *message) =0;
/**
* @brief Returns the menu's display/title message.
*
* @return Message string.
*/
virtual const char *GetDefaultTitle() =0;
/**
* @brief Sets an extended menu option.
*
* @param option Option type.
* @param valuePtr Pointer of the type expected by the option.
* @return True on success, false if option or value is not supported.
*/
virtual bool SetExtOption(MenuOption option, const void *valuePtr) =0;
/**
* @brief Creates a new IMenuPanel object using extended options specific
* to the IMenuStyle parent. Titles, items, etc, are not copied.
*
* Note: The object should be freed with IMenuPanel::DeleteThis.
*
* @return IMenuPanel pointer.
*/
virtual IMenuPanel *CreatePanel() =0;
/**
* @brief Sends the menu to a client.
*
* @param client Client index to display to.
* @param time Time to hold menu for.
* @param alt_handler Alternate IMenuHandler.
* @return True on success, false otherwise.
*/
virtual bool Display(int client, unsigned int time, IMenuHandler *alt_handler=NULL) =0;
/**
* @brief Destroys the menu and frees all associated resources.
*
* @param releaseHandle If true, the Handle will be released
* in the destructor. This should be set
* to true except for IHandleTypeDispatch
* destructors.
*/
virtual void Destroy(bool releaseHandle=true) =0;
/**
* @brief Cancels the menu on all client's displays. While the menu is
* being cancelled, the menu may not be re-displayed to any clients.
* If a vote menu is currently active, it will be cancelled as well.
*
* @return Number of menus cancelled.
*/
virtual void Cancel() =0;
/**
* @brief Returns the menu's Handle. The Handle is automatically
* removed when the menu is destroyed.
*
* @return Handle_t handle value.
*/
virtual Handle_t GetHandle() =0;
/**
* @brief Returns menu option flags.
*
* @return Menu option flags.
*/
virtual unsigned int GetMenuOptionFlags() =0;
/**
* @brief Sets menu option flags.
*
* @param flags Menu option flags.
*/
virtual void SetMenuOptionFlags(unsigned int flags) =0;
/**
* @brief Returns the menu's handler.
*
* @return IMenuHandler of the menu.
*/
virtual IMenuHandler *GetHandler() =0;
/**
* @brief Sends the menu to a client, starting from the given item number.
*
* Note: this API call was added in v13.
*
* @param client Client index to display to.
* @param time Time to hold menu for.
* @param start_item Starting item to draw.
* @param alt_handler Alternate IMenuHandler.
* @return True on success, false otherwise.
*/
virtual bool DisplayAtItem(int client,
unsigned int time,
unsigned int start_item,
IMenuHandler *alt_handler=NULL) =0;
/**
* @brief For the Handle system, returns approximate memory usage.
*
* @return Approximate number of bytes being used.
*/
virtual unsigned int GetApproxMemUsage() =0;
};
/**
* @brief Contains callbacks for menu actions.
*/
class IMenuHandler
{
public:
/**
* @brief Returns the menu api verison.
*
* @return Menu API version.
*/
virtual unsigned int GetMenuAPIVersion2()
{
return SMINTERFACE_MENUMANAGER_VERSION;
}
/**
* @brief A display/selection cycle has started.
*
* @param menu Menu pointer.
*/
virtual void OnMenuStart(IBaseMenu *menu)
{
}
/**
* @brief Called before a menu is being displayed. This is where
* you can set an alternate title on the menu.
*
* @param menu Menu pointer.
* @param client Client index.
* @param display IMenuPanel pointer.
*/
virtual void OnMenuDisplay(IBaseMenu *menu, int client, IMenuPanel *display)
{
}
/**
* @brief Called when an item is selected.
*
* @param menu Menu pointer.
* @param client Client that selected the item.
* @param item Item number.
*/
virtual void OnMenuSelect(IBaseMenu *menu, int client, unsigned int item)
{
}
/**
* @brief An active menu display was dropped from a client.
*
* @param menu Menu pointer.
* @param client Client that had the menu.
* @param reason Menu cancellation reason.
*/
virtual void OnMenuCancel(IBaseMenu *menu, int client, MenuCancelReason reason)
{
}
/**
* @brief A display/selection cycle has ended.
*
* @param menu Menu pointer.
* @param reason MenuEndReason reason.
*/
virtual void OnMenuEnd(IBaseMenu *menu, MenuEndReason reason)
{
}
/**
* @brief Called when the menu object is destroyed.
*
* @param menu Menu pointer.
*/
virtual void OnMenuDestroy(IBaseMenu *menu)
{
}
/**
* @brief Called when requesting how to render an item.
*
* @param menu Menu pointer.
* @param client Client index receiving the menu.
* @param item Item number in the menu.
* @param style ITEMSTYLE flags, by reference for modification.
*/
virtual void OnMenuDrawItem(IBaseMenu *menu, int client, unsigned int item, unsigned int &style)
{
}
/**
* @brief Called when drawing item text.
*
* @param menu Menu pointer.
* @param client Client index receiving the menu.
* @param panel Panel being used to draw the menu.
* @param item Item number in the menu.
* @param dr Item draw information.
* @return 0 to let the render algorithm decide how to draw, otherwise,
* the return value from panel->DrawItem should be returned.
*/
virtual unsigned int OnMenuDisplayItem(IBaseMenu *menu,
int client,
IMenuPanel *panel,
unsigned int item,
const ItemDrawInfo &dr)
{
return 0;
}
/**
* @brief Called when a vote has been started and displayed to
* clients. This is called after OnMenuStart() and OnMenuDisplay(),
* but before OnMenuSelect().
*
* @param menu Menu pointer.
*/
virtual void OnMenuVoteStart(IBaseMenu *menu)
{
}
/**
* @brief Called when a vote ends. This is automatically called by the
* wrapper, and never needs to called from a style implementation.
*
* This function does not replace OnMenuEnd(), nor does it have the
* same meaning as OnMenuEnd(), meaning you should not destroy a menu
* while it is in this function.
*
* @param menu Menu pointer.
* @param results Menu vote results.
*/
virtual void OnMenuVoteResults(IBaseMenu *menu, const menu_vote_result_t *results)
{
}
/**
* @brief Called when a vote is cancelled. If this is called, then
* OnMenuVoteResults() will not be called. In both cases, OnMenuEnd will
* always be called.
*
* @param menu Menu pointer.
* @param reason VoteCancelReason reason.
*/
virtual void OnMenuVoteCancel(IBaseMenu *menu, VoteCancelReason reason)
{
}
/**
* @brief Call to set private handler stuff.
*
* @param option Option name.
* @param data Private data.
* @return True if set, false if invalid or unrecognized.
*/
virtual bool OnSetHandlerOption(const char *option, const void *data)
{
return false;
}
/**
* @brief Called when an item is selected.
*
* Note: This callback was added in v13. It is called after OnMenuSelect().
*
* @param menu Menu pointer.
* @param client Client that selected the item.
* @param item Item number.
* @param item_on_page The first item on the page the player was last
* viewing.
*/
virtual void OnMenuSelect2(IBaseMenu *menu,
int client,
unsigned int item,
unsigned int item_on_page)
{
}
};
/**
* @brief Manages menu creation and displaying.
*/
class IMenuManager : public SMInterface
{
public:
virtual const char *GetInterfaceName()
{
return SMINTERFACE_MENUMANAGER_NAME;
}
virtual unsigned int GetInterfaceVersion()
{
return SMINTERFACE_MENUMANAGER_VERSION;
}
virtual bool IsVersionCompatible(unsigned int version)
{
if (version < 11 || version > GetInterfaceVersion())
{
return false;
}
return true;
}
public:
/**
* @brief Finds a style by name.
*
* @param name Name of the style (case insensitive).
* @return IMenuStyle pointer, or NULL if not found.
*/
virtual IMenuStyle *FindStyleByName(const char *name) =0;
/**
* @brief Returns the default draw style Core is using.
*
* @return Menu style pointer.
*/
virtual IMenuStyle *GetDefaultStyle() =0;
/**
* @brief Given a set of menu states, converts it to an IMenuPanel object.
*
* The state parameter is both INPUT and OUTPUT.
* INPUT: menu, mh, firstItem, lastItem
* OUTPUT: display, firstItem, lastItem, slots
*
* @param client Client index.
* @param states Menu states.
* @param order Order to search for items.
* @return IMenuPanel pointer, or NULL if no items could be
* found in the IBaseMenu pointer, or NULL if any
* other error occurred. Any valid pointer must
* be freed using IMenuPanel::DeleteThis.
*/
virtual IMenuPanel *RenderMenu(int client, menu_states_t &states, ItemOrder order) =0;
/**
* @brief Cancels a menu. Calls IBaseMenu::Cancel() after doing some preparatory
* work. This should always be used instead of directly calling Cancel().
*
* @param menu IBaseMenu pointer.
*/
virtual void CancelMenu(IBaseMenu *menu) =0;
/**
* @brief Displays a menu as a vote.
*
* @param menu IBaseMenu pointer.
* @param num_clients Number of clients to display to.
* @param clients Client index array.
* @param max_time Maximum time to hold menu for.
* @param flags Vote flags.
* @return True on success, false if a vote is in progress.
*/
virtual bool StartVote(IBaseMenu *menu,
unsigned int num_clients,
int clients[],
unsigned int max_time,
unsigned int flags=0) =0;
/**
* @brief Returns whether or not a vote is in progress.
*
* @return True if a vote is in progress, false otherwise.
*/
virtual bool IsVoteInProgress() =0;
/**
* @brief Cancels the vote in progress. This calls IBaseMenu::Cancel().
*/
virtual void CancelVoting() =0;
/**
* @brief Returns the remaining vote delay from the last menu. This delay is
* a suggestion for all public votes, and is not enforced.
*
* @return Number of seconds to wait.
*/
virtual unsigned int GetRemainingVoteDelay() =0;
/**
* @brief Returns whether a client is in the "allowed to vote" pool determined
* by the initial call to StartVote().
*
* @param client Client index.
* @return True if client is allowed to vote, false on failure.
*/
virtual bool IsClientInVotePool(int client) =0;
/**
* @brief Redraws the current vote menu to a client in the voting pool.
*
* @param client Client index.
* @return True on success, false if client is not allowed to vote.
*/
virtual bool RedrawClientVoteMenu(int client) =0;
/**
* @brief Redraws the current vote menu to a client in the voting pool.
*
* @param client Client index.
* @param revotes True to allow revotes, false otherwise.
* @return True on success, false if client is not allowed to vote.
*/
virtual bool RedrawClientVoteMenu2(int client, bool revotes) =0;
};
}
#endif //_INCLUDE_SOURCEMOD_MENU_SYSTEM_H_
Reference in New Issue View Git Blame Copy Permalink