251cced1f8
Various minor things done to project files Updated sample extension project file and updated makefile to the new unified version (more changes likely on the way) Updated regex project file and makefile --HG-- extra : convert_revision : svn%3A39bc706e-5318-0410-9160-8a85361fbb7c/trunk%401971
788 lines
27 KiB
SourcePawn
788 lines
27 KiB
SourcePawn
/**
|
|
* vim: set ts=4 :
|
|
* =============================================================================
|
|
* SourceMod (C)2004-2008 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 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 */
|
|
|
|
/**
|
|
* 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).
|
|
* @noreturn
|
|
*/
|
|
functag MenuHandler public(Handle:menu, MenuAction:action, param1, param2);
|
|
|
|
/**
|
|
* 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 Handle: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, client, 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, client, first_item, 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 AddMenuItem(Handle:menu,
|
|
const String:info[],
|
|
const String:display[],
|
|
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 String:info[],
|
|
const String:display[],
|
|
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, position);
|
|
|
|
/**
|
|
* Removes all items from a menu.
|
|
*
|
|
* @param menu Menu Handle.
|
|
* @noreturn
|
|
* @error Invalid Handle or menu position.
|
|
*/
|
|
native 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,
|
|
position,
|
|
String:infoBuf[],
|
|
infoBufLen,
|
|
&style=0,
|
|
String:dispBuf[]="",
|
|
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 GetMenuSelectionPosition();
|
|
|
|
/**
|
|
* Returns the number of items in a menu.
|
|
*
|
|
* @param menu Menu Handle.
|
|
* @return Number of items in the menu.
|
|
* @error Invalid Handle.
|
|
*/
|
|
native 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, itemsPerPage);
|
|
|
|
/**
|
|
* Returns a menu's pagination setting.
|
|
*
|
|
* @param menu Handle to the menu.
|
|
* @return Pagination setting.
|
|
* @error Invalid Handle.
|
|
*/
|
|
native 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.
|
|
* @noreturn
|
|
* @error Invalid Handle.
|
|
*/
|
|
native SetMenuTitle(Handle:menu, const String: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 GetMenuTitle(Handle:menu, String:buffer[], maxlength);
|
|
|
|
/**
|
|
* Creates a raw MenuPanel based off the menu's style.
|
|
* The Handle must be freed with CloseHandle().
|
|
*
|
|
* @return A new MenuPanel Handle.
|
|
* @error Invalid Handle.
|
|
*/
|
|
native Handle: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 SetMenuExitBackButton(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.
|
|
* @noreturn
|
|
* @error Invalid Handle.
|
|
*/
|
|
native CancelMenu(Handle:menu);
|
|
|
|
/**
|
|
* Retrieves a menu's option flags.
|
|
*
|
|
* @param menu Menu Handle.
|
|
* @return A bitstring of MENUFLAG bits.
|
|
* @error Invalid Handle.
|
|
*/
|
|
native 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.
|
|
* @noreturn
|
|
* @error Invalid Handle.
|
|
*/
|
|
native SetMenuOptionFlags(Handle:menu, 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.
|
|
*
|
|
* @noreturn
|
|
* @error If no vote is in progress.
|
|
*/
|
|
native 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.
|
|
* @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, clients[], numClients, time);
|
|
|
|
/**
|
|
* 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.
|
|
* @return True on success, false if this menu already has a vote session
|
|
* in progress.
|
|
* @error Invalid Handle.
|
|
*/
|
|
stock VoteMenuToAll(Handle:menu, time)
|
|
{
|
|
new num = GetMaxClients();
|
|
new total;
|
|
decl players[num];
|
|
|
|
for (new i=1; i<=num; i++)
|
|
{
|
|
if (!IsClientInGame(i))
|
|
{
|
|
continue;
|
|
}
|
|
players[total++] = i;
|
|
}
|
|
|
|
return VoteMenu(menu, players, total, time);
|
|
}
|
|
/**
|
|
* 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.
|
|
* @noreturn
|
|
*/
|
|
functag VoteHandler public(Handle:menu,
|
|
num_votes,
|
|
num_clients,
|
|
const client_info[][2],
|
|
num_items,
|
|
const 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.
|
|
* @noreturn
|
|
* @error Invalid Handle or callback.
|
|
*/
|
|
native 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 CheckVoteDelay();
|
|
|
|
/**
|
|
* 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 Handle:CreatePanel(Handle:hStyle=INVALID_HANDLE);
|
|
|
|
/**
|
|
* Creates a Menu from a MenuStyle. The Handle must be closed with
|
|
* CloseHandle().
|
|
*
|
|
* @parma 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 Handle: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 INVALID_HANDLE.
|
|
*/
|
|
native MenuSource:GetClientMenu(client, Handle:hStyle=INVALID_HANDLE);
|
|
|
|
/**
|
|
* 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(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 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 title Text to set as the title.
|
|
* @param onlyIfEmpty If true, the title will only be set if no title is set.
|
|
* @noreturn
|
|
* @error Invalid Handle.
|
|
*/
|
|
native Handle:SetPanelTitle(Handle:panel, const String: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 DrawPanelItem(Handle:panel, const String: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 DrawPanelText(Handle:panel, const String: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 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 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, 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, client, MenuHandler:handler, 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 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 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, 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 RedrawMenuItem(const String: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(client, const String:str[], time, keys=-1, MenuHandler:handler=MenuHandler:-1);
|
|
|
|
/**
|
|
* 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.
|
|
* @noreturn
|
|
*/
|
|
stock 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;
|
|
}
|