UNLOZE/sourcemod
10
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
bab1110bc0
sourcemod/plugins/include/menus.inc
David Anderson 722a23c818 Redo menu methodmaps.
2014-12-13 12:53:30 -08:00

1109 lines
40 KiB
SourcePawn
Raw Blame History

/**
* vim: set ts=4 sw=4 tw=99 noet :
* =============================================================================
* SourceMod (C)2004-2014 AlliedModders LLC. All rights reserved.
* =============================================================================
*
* This file is part of the SourceMod/SourcePawn SDK.
*
* 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$
*/
#if defined _menus_included
#endinput
#endif
#define _menus_included
/**
* Low-level drawing style of the menu.
*/
enum MenuStyle
{
MenuStyle_Default = 0, /**< The "default" menu style for the mod */
MenuStyle_Valve = 1, /**< The Valve provided menu style (Used on HL2DM) */
MenuStyle_Radio = 2, /**< The simpler menu style commonly used on CS:S */
};
/**
* Different actions for the menu "pump" callback
*/
enum MenuAction
{
MenuAction_Start = (1<<0), /**< A menu has been started (nothing passed) */
MenuAction_Display = (1<<1), /**< A menu is about to be displayed (param1=client, param2=MenuPanel Handle) */
MenuAction_Select = (1<<2), /**< An item was selected (param1=client, param2=item) */
MenuAction_Cancel = (1<<3), /**< The menu was cancelled (param1=client, param2=reason) */
MenuAction_End = (1<<4), /**< A menu display has fully ended.
param1 is the MenuEnd reason, and if it's MenuEnd_Cancelled, then
param2 is the MenuCancel reason from MenuAction_Cancel.
*/
MenuAction_VoteEnd = (1<<5), /**< (VOTE ONLY): A vote sequence has succeeded (param1=chosen item)
This is not called if SetVoteResultCallback has been used on the menu. */
MenuAction_VoteStart = (1<<6), /**< (VOTE ONLY): A vote sequence has started (nothing passed) */
MenuAction_VoteCancel = (1<<7), /**< (VOTE ONLY): A vote sequence has been cancelled (param1=reason) */
MenuAction_DrawItem = (1<<8), /**< An item is being drawn; return the new style (param1=client, param2=item) */
MenuAction_DisplayItem = (1<<9),/**< Item text is being drawn to the display (param1=client, param2=item)
To change the text, use RedrawMenuItem().
If you do so, return its return value. Otherwise, return 0.
*/
};
/** Default menu actions */
#define MENU_ACTIONS_DEFAULT MenuAction_Select|MenuAction_Cancel|MenuAction_End
/** All menu actions */
#define MENU_ACTIONS_ALL MenuAction:0xFFFFFFFF
#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 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) */
#define MENUFLAG_BUTTON_EXIT (1<<0) /**< Menu has an "exit" button (default if paginated) */
#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 MENUFLAG_BUTTON_NOVOTE (1<<3) /**< Menu has a "No Vote" button at slot 1 */
#define VOTEINFO_CLIENT_INDEX 0 /**< Client index */
#define VOTEINFO_CLIENT_ITEM 1 /**< Item the client selected, or -1 for none */
#define VOTEINFO_ITEM_INDEX 0 /**< Item index */
#define VOTEINFO_ITEM_VOTES 1 /**< Number of votes for the item */
#define VOTEFLAG_NO_REVOTES (1<<0) /**< Players cannot change their votes */
/**
* Reasons a menu can be cancelled (MenuAction_Cancel).
*/
enum
{
MenuCancel_Disconnected = -1, /**< Client dropped from the server */
MenuCancel_Interrupted = -2, /**< Client was interrupted with another menu */
MenuCancel_Exit = -3, /**< Client exited via "exit" */
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 */
};
/**
* Reasons a vote can be cancelled (MenuAction_VoteCancel).
*/
enum
{
VoteCancel_Generic = -1, /**< Vote was generically cancelled. */
VoteCancel_NoVotes = -2, /**< Vote did not receive any votes. */
};
/**
* Reasons a menu ended (MenuAction_End).
*/
enum
{
MenuEnd_Selected = 0, /**< Menu item was selected */
MenuEnd_VotingDone = -1, /**< Voting finished */
MenuEnd_VotingCancelled = -2, /**< Voting was cancelled */
MenuEnd_Cancelled = -3, /**< Menu was cancelled (reason in param2) */
MenuEnd_Exit = -4, /**< Menu was cleanly exited via "exit" */
MenuEnd_ExitBack = -5, /**< Menu was cleanly exited via "back" */
};
/**
* Describes a menu's source
*/
enum MenuSource
{
MenuSource_None = 0, /**< No menu is being displayed */
MenuSource_External = 1, /**< External menu */
MenuSource_Normal = 2, /**< A basic menu is being displayed */
MenuSource_RawPanel = 3, /**< A display is active, but it is not tied to a menu */
};
/**
* Called when a menu action is completed.
*
* @param menu The menu being acted upon.
* @param action The action of the menu.
* @param param1 First action parameter (usually the client).
* @param param2 Second action parameter (usually the item).
*/
typedef MenuHandler = function int (Menu menu, MenuAction action, int param1, int param2);
// Panels are used for drawing raw menus without any extra helper functions.
// Handles must be closed via delete or CloseHandle().
methodmap Panel < Handle
{
// Constructor for a new Panel.
//
// @param hStyle MenuStyle Handle, or null to use the default style.
public native Panel(Handle hStyle = null);
// Sets the panel's title.
//
// @param text Text to set as the title.
// @param onlyIfEmpty If true, the title will only be set if no title is set.
public native void SetTitle(const char[] text, bool onlyIfEmpty=false);
// Draws an item on a panel. If the item takes up a slot, the position
// is returned.
//
// @param text Display text to use. If not a raw line,
// the style may automatically add color markup.
// No numbering or newlines are needed.
// @param style ITEMDRAW style flags.
// @return A slot position, or 0 if item was a rawline or could not be drawn.
public native void DrawItem(const char[] text, style=ITEMDRAW_DEFAULT);
// Draws a raw line of text on a panel, without any markup other than a
// newline.
//
// @param text Display text to use.
// @return True on success, false if raw lines are not supported.
public native bool DrawText(const char[] text);
// Returns whether or not the given drawing flags are supported by
// the menu style.
//
// @param style ITEMDRAW style flags.
// @return True if item is drawable, false otherwise.
public native bool CanDrawFlags(int style);
// Sets the selectable key map of a panel. This is not supported by
// all styles (only by Radio, as of this writing).
//
// @param keys An integer where each bit N allows key
// N+1 to be selected. If no keys are selectable,
// then key 0 (bit 9) is automatically set.
// @return True if supported, false otherwise.
public native bool SetKeys(int keys);
// Sends a panel to a client. Unlike full menus, the handler
// function will only receive the following actions, both of
// which will have null for a menu, and the client as param1.
//
// MenuAction_Select (param2 will be the key pressed)
// MenuAction_Cancel (param2 will be the reason)
//
// Also, if the menu fails to display, no callbacks will be called.
//
// @param client A client to draw to.
// @param handler The MenuHandler function to catch actions with.
// @param time Time to hold the menu for.
// @return True on success, false on failure.
public native bool Send(int client, MenuHandler handler, int time);
// Returns the amount of text the menu can still hold. If this is
// limit is reached or overflowed, the text is silently truncated.
//
// Radio menus: Currently 511 characters (512 bytes).
// Valve menus: Currently -1 (no meaning).
property int TextRemaining {
public native get();
}
// Returns or sets the current key position, starting at 1. This cannot be
// used to traverse backwards.
property int CurrentKey {
public native get();
public native set(int key);
}
// Returns the panel's style. Style handles are global and cannot be closed.
property Handle Style {
public native get();
}
};
// A menu is a helper object for managing in-game menus.
methodmap Menu < Handle
{
// Creates a new, empty menu using the default style.
//
// @param handler Function which will receive menu actions.
// @param actions Optionally set which actions to receive. Select,
// Cancel, and End will always be received regardless
// of whether they are set or not. They are also
// the only default actions.
public native Menu(MenuHandler handler, MenuAction actions=MENU_ACTIONS_DEFAULT);
// Displays a menu to a client.
//
// @param client Client index.
// @param time Maximum time to leave menu on the screen.
// @return True on success, false on failure.
// @error Client not in game.
public native bool Display(int client, int time);
// Displays a menu to a client, starting from the given item.
//
// @param client Client index.
// @param first_item First item to begin drawing from.
// @param time Maximum time to leave menu on the screen.
// @return True on success, false on failure.
// @error Client not in game.
///
public native bool DisplayAt(int client, int first_item, int time);
// Appends a new item to the end of a menu.
//
// @param info Item information string.
// @param display Default item display string.
// @param style Drawing style flags. Anything other than DEFAULT or
// DISABLED will be completely ignored when paginating.
// @return True on success, false on failure.
// @error Item limit reached.
public native bool AddItem(const char[] info, const char[] display, int style=ITEMDRAW_DEFAULT);
// 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 display Default item display string.
// @param style Drawing style flags. Anything other than DEFAULT or
// DISABLED will be completely ignored when paginating.
// @return True on success, false on failure.
// @error Invalid menu position.
public native bool InsertItem(int position, const char[] info,
const char[] display, int style=ITEMDRAW_DEFAULT);
// Removes an item from the menu.
//
// @param position Position, starting from 0.
// @return True on success, false on failure.
// @error Invalid menu position.
public native bool RemoveItem(int position);
// Removes all items from a menu.
public native void RemoveAllItems();
// Retrieves information about a menu item.
//
// @param position Position, starting from 0.
// @param infoBuf Info buffer.
// @param infoBufLen Maximum length of the info buffer.
// @param style By-reference variable to store drawing flags.
// @param dispBuf Display buffer.
// @param dispBufLen Maximum length of the display buffer.
// @return True on success, false if position is invalid.
public native bool GetItem(int position, char[] infoBuf, int infoBufLen,
int &style=0, char[] dispBuf="", int dispBufLen=0);
// Sets the menu's default title/instruction message.
//
// @param fmt Message string format
// @param ... Message string arguments.
public native void SetTitle(const char[] fmt, any ...);
// Returns the text of a menu's title.
//
// @param menu Menu Handle.
// @param buffer Buffer to store title.
// @param maxlength Maximum length of the buffer.
// @return Number of bytes written.
public native void GetTitle(char[] buffer, int maxlength);
// Creates a raw MenuPanel based off the menu's style.
// The Handle must be freed with CloseHandle().
//
// @param menu Menu Handle.
// @return A new MenuPanel Handle.
public native Panel ToPanel();
// Cancels a menu from displaying on all clients. While the
// cancellation is in progress, this menu cannot be re-displayed
// to any clients.
//
// The menu may still exist on the client's screen after this command.
// This simply verifies that the menu is not being used anywhere.
//
// If any vote is in progress on a menu, it will be cancelled.
public native void Cancel();
// Broadcasts a menu to a list of clients. The most selected item will be
// returned through MenuAction_End. On a tie, a random item will be returned
// from a list of the tied items.
//
// Note that MenuAction_VoteEnd and MenuAction_VoteStart are both
// default callbacks and do not need to be enabled.
//
// @param clients Array of clients to broadcast to.
// @param numClients Number of clients in the array.
// @param time Maximum time to leave menu on the screen.
// @param flags Optional voting flags.
// @return True on success, false if this menu already has a
// vote session in progress.
// @error A vote is already in progress.
public native bool DisplayVote(int[] clients, int numClients, int time, int flags=0);
// Sends a vote menu to all clients. See VoteMenu() for more information.
//
// @param time Maximum time to leave menu on the screen.
// @param flags Optional voting flags.
// @return True on success, false if this menu already has a
// vote session in progress.
public bool DisplayVoteToAll(int time, int flags=0) {
int total = 0;
int[] players = new int[MaxClients];
for (int i = 1; i <= MaxClients; i++) {
if (!IsClientInGame(i) || IsFakeClient(i))
continue
players[total++] = i;
}
return this.DisplayVote(players, total, time, flags);
}
// Get or set the menu's pagination.
//
// If pgination is MENU_NO_PAGINATION, and the exit button flag is set,
// then the exit button flag is removed. It can be re-applied if desired.
property int Pagination {
public native get();
public native set(int value);
}
// Get or set the menu's option flags.
//
// If a certain bit is not supported, it will be stripped before being set.
property int OptionFlags {
public native get();
public native set(int value);
}
// Returns whether or not the menu has an exit button. By default, menus
// have an exit button.
property bool ExitButton {
public native get();
public native set(bool value);
}
// Controls whether or not the menu has an "exit back" button. By default,
// menus do not have an exit back button.
//
// Exit Back buttons appear as "Back" on page 1 of paginated menus and have
// functionality defined by the user in MenuEnd_ExitBack.
property bool ExitBackButton {
public native get();
public native set(bool value);
}
// Sets whether or not the menu has a "no vote" button in slot 1.
// By default, menus do not have a no vote button.
property bool NoVoteButton {
public native set(bool value);
}
// Sets an advanced vote handling callback. If this callback is set,
// MenuAction_VoteEnd will not be called.
property VoteHandler VoteResultCallback {
public native set(VoteHandler handler);
}
// Returns the number of items in a menu.
property int ItemCount {
public native get();
}
// Returns the menu style. The Handle is global and cannot be closed.
property Handle Style {
public native get();
}
// Returns the first item on the page of a currently selected menu.
//
// This is only valid inside a MenuAction_Select callback.
property int Selection {
public native get();
}
}
/**
* Creates a new, empty menu using the default style.
*
* @param handler Function which will receive menu actions.
* @param actions Optionally set which actions to receive. Select,
* Cancel, and End will always be received regardless
* of whether they are set or not. They are also
* the only default actions.
* @return A new menu Handle.
*/
native Menu CreateMenu(MenuHandler handler, MenuAction actions=MENU_ACTIONS_DEFAULT);
/**
* Displays a menu to a client.
*
* @param menu Menu Handle.
* @param client Client index.
* @param time Maximum time to leave menu on the screen.
* @return True on success, false on failure.
* @error Invalid Handle or client not in game.
*/
native bool DisplayMenu(Handle menu, int client, int time);
/**
* Displays a menu to a client, starting from the given item.
*
* @param menu Menu Handle.
* @param client Client index.
* @param first_item First item to begin drawing from.
* @param time Maximum time to leave menu on the screen.
* @return True on success, false on failure.
* @error Invalid Handle or client not in game.
*/
native bool DisplayMenuAtItem(Handle menu, int client, int first_item, int time);
/**
* Appends a new item to the end of a menu.
*
* @param menu Menu Handle.
* @param info Item information string.
* @param display Default item display string.
* @param style Drawing style flags. Anything other than DEFAULT or
* DISABLED will be completely ignored when paginating.
* @return True on success, false on failure.
* @error Invalid Handle or item limit reached.
*/
native bool AddMenuItem(Handle menu,
const char[] info,
const char[] display,
int style=ITEMDRAW_DEFAULT);
/**
* 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 menu Menu Handle.
* @param position Position, starting from 0.
* @param info Item information string.
* @param display Default item display string.
* @param style Drawing style flags. Anything other than DEFAULT or
* DISABLED will be completely ignored when paginating.
* @return True on success, false on failure.
* @error Invalid Handle or menu position.
*/
native bool InsertMenuItem(Handle menu,
position,
const char[] info,
const char[] display,
int style=ITEMDRAW_DEFAULT);
/**
* Removes an item from the menu.
*
* @param menu Menu Handle.
* @param position Position, starting from 0.
* @return True on success, false on failure.
* @error Invalid Handle or menu position.
*/
native bool RemoveMenuItem(Handle menu, int position);
/**
* Removes all items from a menu.
*
* @param menu Menu Handle.
* @error Invalid Handle or menu position.
*/
native void RemoveAllMenuItems(Handle menu);
/**
* Retrieves information about a menu item.
*
* @param menu Menu Handle.
* @param position Position, starting from 0.
* @param infoBuf Info buffer.
* @param infoBufLen Maximum length of the info buffer.
* @param style By-reference variable to store drawing flags.
* @param dispBuf Display buffer.
* @param dispBufLen Maximum length of the display buffer.
* @return True on success, false if position is invalid.
* @error Invalid Handle.
*/
native bool GetMenuItem(Handle menu,
int position,
char[] infoBuf,
int infoBufLen,
int &style=0,
char[] dispBuf="",
int dispBufLen=0);
/**
* Returns the first item on the page of a currently selected menu.
*
* This is only valid inside a MenuAction_Select callback.
*
* @return First item number on the page the client was viewing
* before selecting the item in the callback. This can
* be used to re-display the menu from the original
* position.
* @error Not called from inside a MenuAction_Select callback.
*/
native int GetMenuSelectionPosition();
/**
* Returns the number of items in a menu.
*
* @param menu Menu Handle.
* @return Number of items in the menu.
* @error Invalid Handle.
*/
native int GetMenuItemCount(Handle menu);
/**
* Sets whether the menu should be paginated or not.
*
* If itemsPerPage is MENU_NO_PAGINATION, and the exit button flag is set,
* then the exit button flag is removed. It can be re-applied if desired.
*
* @param menu Handle to the menu.
* @param itemsPerPage Number of items per page, or MENU_NO_PAGINATION.
* @return True on success, false if pagination is too high or
* low.
* @error Invalid Handle.
*/
native bool SetMenuPagination(Handle menu, int itemsPerPage);
/**
* Returns a menu's pagination setting.
*
* @param menu Handle to the menu.
* @return Pagination setting.
* @error Invalid Handle.
*/
native int GetMenuPagination(Handle menu);
/**
* Returns a menu's MenuStyle Handle. The Handle
* is global and cannot be freed.
*
* @param menu Handle to the menu.
* @return Handle to the menu's draw style.
* @error Invalid Handle.
*/
native Handle GetMenuStyle(Handle menu);
/**
* Sets the menu's default title/instruction message.
*
* @param menu Menu Handle.
* @param fmt Message string format
* @param ... Message string arguments.
* @error Invalid Handle.
*/
native void SetMenuTitle(Handle menu, const char[] fmt, any ...);
/**
* Returns the text of a menu's title.
*
* @param menu Menu Handle.
* @param buffer Buffer to store title.
* @param maxlength Maximum length of the buffer.
* @return Number of bytes written.
* @error Invalid Handle/
*/
native int GetMenuTitle(Handle menu, char[] buffer, int maxlength);
/**
* Creates a raw MenuPanel based off the menu's style.
* The Handle must be freed with CloseHandle().
*
* @param menu Menu Handle.
* @return A new MenuPanel Handle.
* @error Invalid Handle.
*/
native Panel CreatePanelFromMenu(Handle menu);
/**
* Returns whether or not the menu has an exit button.
* By default, menus have an exit button.
*
* @param menu Menu Handle.
* @return True if the menu has an exit button; false otherwise.
* @error Invalid Handle.
*/
native bool GetMenuExitButton(Handle menu);
/**
* Sets whether or not the menu has an exit button. By default, paginated menus
* have an exit button.
*
* If a menu's pagination is changed to MENU_NO_PAGINATION, and the pagination
* was previously a different value, then the Exit button status is changed to
* false. It must be explicitly re-enabled afterwards.
*
* If a non-paginated menu has an exit button, then at most 9 items will be
* displayed.
*
* @param menu Menu Handle.
* @param button True to enable the button, false to remove it.
* @return True if allowed; false on failure.
* @error Invalid Handle.
*/
native bool SetMenuExitButton(Handle menu, bool button);
/**
* Returns whether or not the menu has an "exit back" button. By default,
* menus do not have an exit back button.
*
* Exit Back buttons appear as "Back" on page 1 of paginated menus and have
* functionality defined by the user in MenuEnd_ExitBack.
*
* @param menu Menu Handle.
* @return True if the menu has an exit back button; false otherwise.
* @error Invalid Handle.
*/
native bool GetMenuExitBackButton(Handle menu);
/**
* Sets whether or not the menu has an "exit back" button. By default, menus
* do not have an exit back button.
*
* Exit Back buttons appear as "Back" on page 1 of paginated menus and have
* functionality defined by the user in MenuEnd_ExitBack.
*
* @param menu Menu Handle.
* @param button True to enable the button, false to remove it.
* @error Invalid Handle.
*/
native void SetMenuExitBackButton(Handle menu, bool button);
/**
* Sets whether or not the menu has a "no vote" button in slot 1.
* By default, menus do not have a no vote button.
*
* @param menu Menu Handle.
* @param button True to enable the button, false to remove it.
* @return True if allowed; false on failure.
* @error Invalid Handle.
*/
native bool SetMenuNoVoteButton(Handle menu, bool button);
/**
* Cancels a menu from displaying on all clients. While the
* cancellation is in progress, this menu cannot be re-displayed
* to any clients.
*
* The menu may still exist on the client's screen after this command.
* This simply verifies that the menu is not being used anywhere.
*
* If any vote is in progress on a menu, it will be cancelled.
*
* @param menu Menu Handle.
* @error Invalid Handle.
*/
native void CancelMenu(Handle menu);
/**
* Retrieves a menu's option flags.
*
* @param menu Menu Handle.
* @return A bitstring of MENUFLAG bits.
* @error Invalid Handle.
*/
native int GetMenuOptionFlags(Handle menu);
/**
* Sets a menu's option flags.
*
* If a certain bit is not supported, it will be stripped before being set.
* See SetMenuExitButton() for information on Exit buttons.
* See SetMenuExitBackButton() for information on Exit Back buttons.
*
* @param menu Menu Handle.
* @param flags A new bitstring of MENUFLAG bits.
* @error Invalid Handle.
*/
native void SetMenuOptionFlags(Handle menu, int flags);
/**
* Returns whether a vote is in progress.
*
* @param menu Deprecated; no longer used.
* @return True if a vote is in progress, false otherwise.
*/
native bool IsVoteInProgress(Handle menu=INVALID_HANDLE);
/**
* Cancels the vote in progress.
*
* @error If no vote is in progress.
*/
native void CancelVote();
/**
* Broadcasts a menu to a list of clients. The most selected item will be
* returned through MenuAction_End. On a tie, a random item will be returned
* from a list of the tied items.
*
* Note that MenuAction_VoteEnd and MenuAction_VoteStart are both
* default callbacks and do not need to be enabled.
*
* @param menu Menu Handle.
* @param clients Array of clients to broadcast to.
* @param numClients Number of clients in the array.
* @param time Maximum time to leave menu on the screen.
* @param flags Optional voting flags.
* @return True on success, false if this menu already has a vote session
* in progress.
* @error Invalid Handle, or a vote is already in progress.
*/
native bool VoteMenu(Handle menu, int[] clients, int numClients, int time, int flags=0);
/**
* Sends a vote menu to all clients. See VoteMenu() for more information.
*
* @param menu Menu Handle.
* @param time Maximum time to leave menu on the screen.
* @param flags Optional voting flags.
* @return True on success, false if this menu already has a vote session
* in progress.
* @error Invalid Handle.
*/
stock bool VoteMenuToAll(Handle menu, int time, int flags=0)
{
new total;
decl players[MaxClients];
for (new i=1; i<=MaxClients; i++)
{
if (!IsClientInGame(i) || IsFakeClient(i))
{
continue;
}
players[total++] = i;
}
return VoteMenu(menu, players, total, time, flags);
}
/**
* Callback for when a vote has ended and results are available.
*
* @param menu The menu being voted on.
* @param num_votes Number of votes tallied in total.
* @param num_clients Number of clients who could vote.
* @param client_info Array of clients. Use VOTEINFO_CLIENT_ defines.
* @param num_items Number of unique items that were selected.
* @param item_info Array of items, sorted by count. Use VOTEINFO_ITEM
* defines.
*/
typedef VoteHandler = function void (
Menu menu,
int num_votes,
int num_clients,
const int client_info[][2],
int num_items,
const int item_info[][2]
);
/**
* Sets an advanced vote handling callback. If this callback is set,
* MenuAction_VoteEnd will not be called.
*
* @param menu Menu Handle.
* @param callback Callback function.
* @error Invalid Handle or callback.
*/
native void SetVoteResultCallback(Handle menu, VoteHandler callback);
/**
* Returns the number of seconds you should "wait" before displaying
* a publicly invocable menu. This number is the time remaining until
* (last_vote + sm_vote_delay).
*
* @return Number of seconds to wait, or 0 for none.
*/
native int CheckVoteDelay();
/**
* Returns whether a client is in the pool of clients allowed
* to participate in the current vote. This is determined by
* the client list passed to VoteMenu().
*
* @param client Client index.
* @return True if client is allowed to vote, false otherwise.
* @error If no vote is in progress or client index is invalid.
*/
native bool IsClientInVotePool(int client);
/**
* 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 the client is in the vote pool
* but cannot vote again.
* @error No vote in progress, int client is not in the voting pool,
* or client index is invalid.
*/
native bool RedrawClientVoteMenu(int client, bool revotes=true);
/**
* Returns a style's global Handle.
*
* @param style Menu Style.
* @return A Handle, or INVALID_HANDLE if not found or unusable.
*/
native Handle GetMenuStyleHandle(MenuStyle style);
/**
* Creates a MenuPanel from a MenuStyle. Panels are used for drawing raw
* menus without any extra helper functions. The Handle must be closed
* with CloseHandle().
*
* @param hStyle MenuStyle Handle, or INVALID_HANDLE to use the default style.
* @return A new MenuPanel Handle.
* @error Invalid Handle other than INVALID_HANDLE.
*/
native Panel CreatePanel(Handle hStyle=INVALID_HANDLE);
/**
* Creates a Menu from a MenuStyle. The Handle must be closed with
* CloseHandle().
*
* @param hStyle MenuStyle Handle, or INVALID_HANDLE to use the default style.
* @param handler Function which will receive menu actions.
* @param actions Optionally set which actions to receive. Select,
* Cancel, and End will always be received regardless
* of whether they are set or not. They are also
* the only default actions.
* @return A new menu Handle.
* @error Invalid Handle other than INVALID_HANDLE.
*/
native Menu CreateMenuEx(Handle hStyle=INVALID_HANDLE, MenuHandler handler, MenuAction actions=MENU_ACTIONS_DEFAULT);
/**
* Returns whether a client is viewing a menu.
*
* @param client Client index.
* @param hStyle MenuStyle Handle, or INVALID_HANDLE to use the default style.
* @return A MenuSource value.
* @error Invalid Handle other than null.
*/
native MenuSource GetClientMenu(int client, Handle hStyle=null);
/**
* Cancels a menu on a client. This will only affect non-external menus.
*
* @param hStyle MenuStyle Handle, or INVALID_HANDLE to use the default style.
* @param client Client index.
* @param autoIgnore If true, no menus can be re-drawn on the client during
* the cancellation process.
* @return True if a menu was cancelled, false otherwise.
*/
native bool CancelClientMenu(int client, bool autoIgnore=false, Handle hStyle=INVALID_HANDLE);
/**
* Returns a style's maximum items per page.
*
* @param hStyle MenuStyle Handle, or INVALID_HANDLE to use the default style.
* @return Maximum items per page.
* @error Invalid Handle other than INVALID_HANDLE.
*/
native int GetMaxPageItems(Handle hStyle=INVALID_HANDLE);
/**
* Returns a MenuPanel's parent style.
*
* @param panel A MenuPanel Handle.
* @return The MenuStyle Handle that created the panel.
* @error Invalid Handle.
*/
native Handle GetPanelStyle(Handle panel);
/**
* Sets the panel's title.
*
* @param panel A MenuPanel Handle.
* @param text Text to set as the title.
* @param onlyIfEmpty If true, the title will only be set if no title is set.
* @error Invalid Handle.
*/
native void SetPanelTitle(Handle panel, const char[] text, bool onlyIfEmpty=false);
/**
* Draws an item on a panel. If the item takes up a slot, the position
* is returned.
*
* @param panel A MenuPanel Handle.
* @param text Display text to use. If not a raw line,
* the style may automatically add color markup.
* No numbering or newlines are needed.
* @param style ITEMDRAW style flags.
* @return A slot position, or 0 if item was a rawline or could not be drawn.
* @error Invalid Handle.
*/
native int DrawPanelItem(Handle panel, const char[] text, style=ITEMDRAW_DEFAULT);
/**
* Draws a raw line of text on a panel, without any markup other than a newline.
*
* @param panel A MenuPanel Handle, or INVALID_HANDLE if inside a
* MenuAction_DisplayItem callback.
* @param text Display text to use.
* @return True on success, false if raw lines are not supported.
* @error Invalid Handle.
*/
native bool DrawPanelText(Handle panel, const char[] text);
/**
* Returns whether or not the given drawing flags are supported by
* the menu style.
*
* @param panel A MenuPanel Handle.
* @param style ITEMDRAW style flags.
* @return True if item is drawable, false otherwise.
* @error Invalid Handle.
*/
native bool CanPanelDrawFlags(Handle panel, style);
/**
* Sets the selectable key map of a panel. This is not supported by
* all styles (only by Radio, as of this writing).
*
* @param panel A MenuPanel Handle.
* @param keys An integer where each bit N allows key
* N+1 to be selected. If no keys are selectable,
* then key 0 (bit 9) is automatically set.
* @return True if supported, false otherwise.
*/
native bool SetPanelKeys(Handle panel, int keys);
/**
* Sends a panel to a client. Unlike full menus, the handler
* function will only receive the following actions, both of
* which will have INVALID_HANDLE for a menu, and the client
* as param1.
*
* MenuAction_Select (param2 will be the key pressed)
* MenuAction_Cancel (param2 will be the reason)
*
* Also, if the menu fails to display, no callbacks will be called.
*
* @param panel A MenuPanel Handle.
* @param client A client to draw to.
* @param handler The MenuHandler function to catch actions with.
* @param time Time to hold the menu for.
* @return True on success, false on failure.
* @error Invalid Handle.
*/
native bool SendPanelToClient(Handle panel, int client, MenuHandler handler, int time);
/**
* @brief Returns the amount of text the menu can still hold. If this is
* limit is reached or overflowed, the text is silently truncated.
*
* Radio menus: Currently 511 characters (512 bytes).
* Valve menus: Currently -1 (no meaning).
*
* @param panel A MenuPanel Handle.
* @return Number of characters that the menu can still hold,
* or -1 if there is no known limit.
* @error Invalid Handle.
*/
native int GetPanelTextRemaining(Handle panel);
/**
* @brief Returns the current key position.
*
* @param panel A MenuPanel Handle.
* @return Current key position starting at 1.
* @error Invalid Handle.
*/
native int GetPanelCurrentKey(Handle panel);
/**
* @brief Sets the next key position. This cannot be used
* to traverse backwards.
*
* @param panel A MenuPanel Handle.
* @param key Key that is greater or equal to
* GetPanelCurrentKey().
* @return True on success, false otherwise.
* @error Invalid Handle.
*/
native bool SetPanelCurrentKey(Handle panel, int key);
/**
* @brief Redraws menu text from inside a MenuAction_DisplayItem callback.
*
* @param text Menu text to draw.
* @return Item position; must be returned via the callback.
*/
native int RedrawMenuItem(const char[] text);
/**
* This function is provided for legacy code only. Some older plugins may use
* network messages instead of the panel API. This function wraps the panel
* API for eased portability into the SourceMod menu system.
*
* This function is only usable with the Radio Menu style. You do not need to
* split up your menu into multiple packets; SourceMod will break the string
* up internally.
*
* @param client Client index.
* @param str Full menu string as would be passed over the network.
* @param time Time to hold the menu for.
* @param keys Selectable key bitstring.
* @param handler Optional handler function, with the same rules as
* SendPanelToClient().
* @return True on success, false on failure.
* @error Invalid client index, or radio menus not supported.
*/
native bool InternalShowMenu(int client, const char[] str, int time, int keys=-1, MenuHandler handler=INVALID_FUNCTION);
/**
* Retrieves voting information from MenuAction_VoteEnd.
*
* @param param2 Second parameter of MenuAction_VoteEnd.
* @param winningVotes Number of votes received by the winning option.
* @param totalVotes Number of total votes received.
*/
stock void GetMenuVoteInfo(param2, &winningVotes, &totalVotes)
{
winningVotes = param2 & 0xFFFF;
totalVotes = param2 >> 16;
}
/**
* Quick stock to determine whether voting is allowed. This doesn't let you
* fine-tune a reason for not voting, so it's not recommended for lazily
* telling clients that voting isn't allowed.
*
* @return True if voting is allowed, false if voting is in progress
* or the cooldown is active.
*/
stock bool IsNewVoteAllowed()
{
if (IsVoteInProgress() || CheckVoteDelay() != 0)
{
return false;
}
return true;
}
Reference in New Issue View Git Blame Copy Permalink