Home - sourcemod-central - file revision - extensions/topmenus/TopMenu.cpp@efa6bfdd7571 Mercurial
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
extensions/topmenus/TopMenu.cpp
author Matt Woodrow <pred@alliedmods.net>
Fri Sep 26 19:08:49 2008 +1200 (2008-09-26)
changeset 2323 efa6bfdd7571
parent 2289 44045ead61cd
child 2510 3b2349600557
permissions -rw-r--r--
Core now detects and handles a changed maxplayers value (bug 2537 and bug 2758) 
     1 /**
     2  * vim: set ts=4 :
     3  * =============================================================================
     4  * SourceMod TopMenus Extension
     5  * Copyright (C) 2004-2008 AlliedModders LLC.  All rights reserved.
     6  * =============================================================================
     7  *
     8  * This program is free software; you can redistribute it and/or modify it under
     9  * the terms of the GNU General Public License, version 3.0, as published by the
    10  * Free Software Foundation.
    11  * 
    12  * This program is distributed in the hope that it will be useful, but WITHOUT
    13  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    14  * FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
    15  * details.
    16  *
    17  * You should have received a copy of the GNU General Public License along with
    18  * this program.  If not, see <http://www.gnu.org/licenses/>.
    19  *
    20  * As a special exception, AlliedModders LLC gives you permission to link the
    21  * code of this program (as well as its derivative works) to "Half-Life 2," the
    22  * "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
    23  * by the Valve Corporation.  You must obey the GNU General Public License in
    24  * all respects for all other code used.  Additionally, AlliedModders LLC grants
    25  * this exception to all derivative works.  AlliedModders LLC defines further
    26  * exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
    27  * or <http://www.sourcemod.net/license.php>.
    28  *
    29  * Version: $Id$
    30  */
    31 
    32 #include <stdlib.h>
    33 #include <stdarg.h>
    34 #include "TopMenu.h"
    35 
    36 struct obj_by_name_t
    37 {
    38 	unsigned int obj_index;
    39 	char name[64];
    40 };
    41 
    42 int _SortObjectNamesDescending(const void *ptr1, const void *ptr2);
    43 unsigned int strncopy(char *dest, const char *src, size_t count);
    44 size_t UTIL_Format(char *buffer, size_t maxlength, const char *fmt, ...);
    45 
    46 TopMenu::TopMenu(ITopMenuObjectCallbacks *callbacks)
    47 {
    48 	m_clients = NULL;
    49 	m_SerialNo = 1;
    50 	m_pTitle = callbacks;
    51 	m_max_clients = 0;
    52 
    53 	if (playerhelpers->IsServerActivated())
    54 	{
    55 		CreatePlayers(playerhelpers->GetMaxClients());
    56 	}
    57 }
    58 
    59 TopMenu::~TopMenu()
    60 {
    61 	/* Delete all categories */
    62 	while (m_Categories.size())
    63 	{
    64 		RemoveFromMenu(m_Categories[0]->obj->object_id);
    65 	}
    66 
    67 	/* Remove all objects */
    68 	for (size_t i = 0; i < m_Objects.size(); i++)
    69 	{
    70 		assert(m_Objects[i]->is_free == true);
    71 		delete m_Objects[i];
    72 	}
    73 
    74 	m_pTitle->OnTopMenuObjectRemoved(this, 0);
    75 
    76 	/* Delete all cached config entries */
    77 	for (size_t i = 0; i < m_Config.cats.size(); i++)
    78 	{
    79 		delete m_Config.cats[i];
    80 	}
    81 
    82 	/* Sweep players */
    83 	for (size_t i = 0; i <= (size_t)m_max_clients; i++)
    84 	{
    85 		TearDownClient(&m_clients[i]);
    86 	}
    87 	delete [] m_clients;
    88 }
    89 
    90 unsigned int TopMenu::CalcMemUsage()
    91 {
    92 	unsigned int size = sizeof(TopMenu);
    93 
    94 	size += m_Config.strings.GetMemTable()->MemUsage();
    95 	size += (m_Config.cats.size() * sizeof(int));
    96 	size += (sizeof(topmenu_player_t) * (ABSOLUTE_PLAYER_LIMIT + 1));
    97 	size += (m_SortedCats.size() * sizeof(unsigned int));
    98 	size += (m_UnsortedCats.size() * sizeof(unsigned int));
    99 	size += (m_Categories.size() * (sizeof(topmenu_category_t *) + sizeof(topmenu_category_t)));
   100 	size += (m_Objects.size() * (sizeof(topmenu_object_t *) + sizeof(topmenu_object_t)));
   101 	size += m_ObjLookup.mem_usage();
   102 
   103 	for (size_t i = 0; i < m_Categories.size(); i++)
   104 	{
   105 		size += m_Categories[i]->obj_list.size() * sizeof(topmenu_object_t *);
   106 		size += m_Categories[i]->sorted.size() * sizeof(topmenu_object_t *);
   107 		size += m_Categories[i]->unsorted.size() * sizeof(topmenu_object_t *);
   108 	}
   109 
   110 	return size;
   111 }
   112 
   113 void TopMenu::OnClientConnected(int client)
   114 {
   115 	if (m_clients == NULL)
   116 	{
   117 		return;
   118 	}
   119 
   120 	topmenu_player_t *player = &m_clients[client];
   121 	TearDownClient(player);
   122 }
   123 
   124 void TopMenu::OnClientDisconnected(int client)
   125 {
   126 	if (m_clients == NULL)
   127 	{
   128 		return;
   129 	}
   130 
   131 	topmenu_player_t *player = &m_clients[client];
   132 	TearDownClient(player);
   133 }
   134 
   135 void TopMenu::OnServerActivated(int max_clients)
   136 {
   137 	if (m_clients == NULL)
   138 	{
   139 		CreatePlayers(max_clients);
   140 	}
   141 }
   142 
   143 unsigned int TopMenu::AddToMenu(const char *name,
   144 								TopMenuObjectType type,
   145 								ITopMenuObjectCallbacks *callbacks,
   146 								IdentityToken_t *owner,
   147 								const char *cmdname,
   148 								FlagBits flags,
   149 								unsigned int parent)
   150 {
   151 	return AddToMenu2(name, type, callbacks, owner, cmdname, flags, parent, NULL);
   152 }
   153 
   154 unsigned int TopMenu::AddToMenu2(const char *name,
   155 								 TopMenuObjectType type,
   156 								 ITopMenuObjectCallbacks *callbacks,
   157 								 IdentityToken_t *owner,
   158 								 const char *cmdname,
   159 								 FlagBits flags,
   160 								 unsigned int parent,
   161 								 const char *info_string)
   162 {
   163 	/* Sanity checks */
   164 	if (type == TopMenuObject_Category && parent != 0)
   165 	{
   166 		return 0;
   167 	}
   168 	else if (type == TopMenuObject_Item && parent == 0)
   169 	{
   170 		return 0;
   171 	}
   172 	else if (m_ObjLookup.retrieve(name) != NULL)
   173 	{
   174 		return 0;
   175 	}
   176 	else if (type != TopMenuObject_Item && type != TopMenuObject_Category)
   177 	{
   178 		return 0;
   179 	}
   180 
   181 	/* If we're adding an item, make sure the parent is valid, 
   182 	 * and that the parent is a category.
   183 	 */
   184 	topmenu_object_t *parent_obj = NULL;
   185 	topmenu_category_t *parent_cat = NULL;
   186 	if (type == TopMenuObject_Item)
   187 	{
   188 		/* Check parent index.  Note it will be >= 1 here. */
   189 		if (parent > m_Objects.size() || m_Objects[parent - 1]->is_free)
   190 		{
   191 			return 0;
   192 		}
   193 		parent_obj = m_Objects[parent - 1];
   194 
   195 		/* Find an equivalent pointer in the category array. */
   196 		for (size_t i = 0; i < m_Categories.size(); i++)
   197 		{
   198 			if (m_Categories[i]->obj == parent_obj)
   199 			{
   200 				parent_cat = m_Categories[i];
   201 				break;
   202 			}
   203 		}
   204 
   205 		/* If none was found, leave. */
   206 		if (parent_cat == NULL)
   207 		{
   208 			return 0;
   209 		}
   210 	}
   211 
   212 	/* Re-use an old object pointer if we can. */
   213 	topmenu_object_t *obj = NULL;
   214 	for (size_t i = 0; i < m_Objects.size(); i++)
   215 	{
   216 		if (m_Objects[i]->is_free == true)
   217 		{
   218 			obj = m_Objects[i];
   219 			break;
   220 		}
   221 	}
   222 
   223 	/* Otherwise, allocate a new one. */
   224 	if (obj == NULL)
   225 	{
   226 		obj = new topmenu_object_t;
   227 		obj->object_id = ((unsigned int)m_Objects.size()) + 1;
   228 		m_Objects.push_back(obj);
   229 	}
   230 
   231 	/* Initialize the object's properties. */
   232 	obj->callbacks = callbacks;
   233 	obj->flags = flags;
   234 	obj->owner = owner;
   235 	obj->type = type;
   236 	obj->is_free = false;
   237 	obj->parent = parent_obj;
   238 	strncopy(obj->name, name, sizeof(obj->name));
   239 	strncopy(obj->cmdname, cmdname ? cmdname : "", sizeof(obj->cmdname));
   240 	strncopy(obj->info, info_string ? info_string : "", sizeof(obj->info));
   241 
   242 	if (obj->type == TopMenuObject_Category)
   243 	{
   244 		/* Create a new category entry */
   245 		topmenu_category_t *cat = new topmenu_category_t;
   246 		cat->obj = obj;
   247 		cat->reorder = false;
   248 		cat->serial = 1;
   249 
   250 		/* Add it, then update our serial change number. */
   251 		m_Categories.push_back(cat);
   252 		m_SerialNo++;
   253 
   254 		/* Updating sorting info */
   255 		m_bCatsNeedResort = true;
   256 	}
   257 	else if (obj->type == TopMenuObject_Item)
   258 	{
   259 		/* Update the category, mark it as needing changes */
   260 		parent_cat->obj_list.push_back(obj);
   261 		parent_cat->reorder = true;
   262 		parent_cat->serial++;
   263 
   264 		/* If the category just went from 0 to 1 items, mark it as 
   265 		 * changed, so clients get the category drawn.
   266 		 */
   267 		if (parent_cat->obj_list.size() == 1)
   268 		{
   269 			m_SerialNo++;
   270 		}
   271 	}
   272 
   273 	m_ObjLookup.insert(name, obj);
   274 
   275 	return obj->object_id;
   276 }
   277 
   278 const char *TopMenu::GetObjectInfoString(unsigned int object_id)
   279 {
   280 	if (object_id == 0 
   281 		|| object_id > m_Objects.size() 
   282 		|| m_Objects[object_id - 1]->is_free)
   283 	{
   284 		return NULL;
   285 	}
   286 
   287 	topmenu_object_t *obj = m_Objects[object_id - 1];
   288 
   289 	return obj->info;
   290 }
   291 
   292 const char *TopMenu::GetObjectName(unsigned int object_id)
   293 {
   294 	if (object_id == 0 
   295 		|| object_id > m_Objects.size() 
   296 		|| m_Objects[object_id - 1]->is_free)
   297 	{
   298 		return NULL;
   299 	}
   300 
   301 	topmenu_object_t *obj = m_Objects[object_id - 1];
   302 
   303 	return obj->name;
   304 }
   305 
   306 void TopMenu::RemoveFromMenu(unsigned int object_id)
   307 {
   308 	if (object_id == 0 
   309 		|| object_id > m_Objects.size() 
   310 		|| m_Objects[object_id - 1]->is_free)
   311 	{
   312 		return;
   313 	}
   314 
   315 	topmenu_object_t *obj = m_Objects[object_id - 1];
   316 
   317 	m_ObjLookup.remove(obj->name);
   318 
   319 	if (obj->type == TopMenuObject_Category)
   320 	{
   321 		/* Find it in the category list. */
   322 		for (size_t i = 0; i < m_Categories.size(); i++)
   323 		{
   324 			if (m_Categories[i]->obj == obj)
   325 			{
   326 				/* Mark all children as removed + free.  Note we could
   327 				 * call into RemoveMenuItem() for this, but it'd be very 
   328 				 * inefficient!
   329 				 */
   330 				topmenu_category_t *cat = m_Categories[i];
   331 				for (size_t j = 0; j < m_Categories[i]->obj_list.size(); j++)
   332 				{
   333 					m_ObjLookup.remove(cat->obj_list[j]->name);
   334 					cat->obj_list[j]->callbacks->OnTopMenuObjectRemoved(this, cat->obj_list[j]->object_id);
   335 					cat->obj_list[j]->is_free = true;
   336 				}
   337 				
   338 				/* Remove the category from the list, then delete it. */
   339 				m_Categories.erase(m_Categories.iterAt(i));
   340 				delete cat;
   341 				break;
   342 			}
   343 		}
   344 
   345 		/* Update the root as changed. */
   346 		m_SerialNo++;
   347 		m_bCatsNeedResort = true;
   348 	}
   349 	else if (obj->type == TopMenuObject_Item)
   350 	{
   351 		/* Find the category this item is in. */
   352 		topmenu_category_t *parent_cat = NULL;
   353 		for (size_t i = 0; i < m_Categories.size(); i++)
   354 		{
   355 			if (m_Categories[i]->obj == obj->parent)
   356 			{
   357 				parent_cat = m_Categories[i];
   358 				break;
   359 			}
   360 		}
   361 
   362 		/* Erase it from the category's lists. */
   363 		if (parent_cat)
   364 		{
   365 			for (size_t i = 0; i < parent_cat->obj_list.size(); i++)
   366 			{
   367 				if (parent_cat->obj_list[i] == obj)
   368 				{
   369 					parent_cat->obj_list.erase(parent_cat->obj_list.iterAt(i));
   370 
   371 					/* If this category now has no items, mark root as changed 
   372 					 * so clients won't get the category drawn anymore.
   373 					 */
   374 					if (parent_cat->obj_list.size() == 0)
   375 					{
   376 						m_SerialNo++;
   377 					}
   378 					break;
   379 				}
   380 			}
   381 
   382 			/* Update the category as changed. */
   383 			parent_cat->reorder = true;
   384 			parent_cat->serial++;
   385 		}
   386 	}
   387 
   388 	/* The callbacks pointer is still valid, so fire away! */
   389 	obj->callbacks->OnTopMenuObjectRemoved(this, object_id);
   390 
   391 	/* Finally, mark the object as free. */
   392 	obj->is_free = true;
   393 }
   394 
   395 bool TopMenu::DisplayMenu(int client, unsigned int hold_time, TopMenuPosition position)
   396 {
   397 	if (m_clients == NULL)
   398 	{
   399 		return false;
   400 	}
   401 
   402 	IGamePlayer *pPlayer = playerhelpers->GetGamePlayer(client);
   403 	if (!pPlayer->IsInGame())
   404 	{
   405 		return false;
   406 	}
   407 
   408 	UpdateClientRoot(client, pPlayer);
   409 
   410 	topmenu_player_t *pClient = &m_clients[client];
   411 	if (pClient->root == NULL)
   412 	{
   413 		return false;
   414 	}
   415 
   416 	bool return_value = false;
   417 
   418 	if (position == TopMenuPosition_LastCategory && 
   419 		pClient->last_category < m_Categories.size())
   420 	{
   421 		return_value = DisplayCategory(client, pClient->last_category, hold_time, true);
   422 		if (!return_value)
   423 		{
   424 			return_value = pClient->root->DisplayAtItem(client, hold_time, pClient->last_root_pos);
   425 		}
   426 	}
   427 	else if (position == TopMenuPosition_LastRoot)
   428 	{
   429 		pClient->root->DisplayAtItem(client, hold_time, pClient->last_root_pos);
   430 	}
   431 	else if (position == TopMenuPosition_Start)
   432 	{
   433 		pClient->last_position = 0;
   434 		pClient->last_category = 0;
   435 		return_value = pClient->root->Display(client, hold_time);
   436 	}
   437 
   438 	return return_value;
   439 }
   440 
   441 bool TopMenu::DisplayCategory(int client, unsigned int category, unsigned int hold_time, bool last_position)
   442 {
   443 	UpdateClientCategory(client, category);
   444 
   445 	topmenu_player_t *pClient = &m_clients[client];
   446 	if (category >= pClient->cat_count
   447 		|| pClient->cats[category].menu == NULL)
   448 	{
   449 		return false;
   450 	}
   451 
   452 	bool return_value = false;
   453 
   454 	topmenu_player_category_t *player_cat = &(pClient->cats[category]);
   455 
   456 	pClient->last_category = category;
   457 	if (last_position)
   458 	{
   459 		return_value = player_cat->menu->DisplayAtItem(client, hold_time, pClient->last_position);
   460 	}
   461 	else
   462 	{
   463 		return_value = player_cat->menu->Display(client, hold_time);
   464 	}
   465 
   466 	return return_value;
   467 }
   468 
   469 void TopMenu::OnMenuSelect2(IBaseMenu *menu, int client, unsigned int item, unsigned int item_on_page)
   470 {
   471 	const char *item_name = menu->GetItemInfo(item, NULL);
   472 	if (!item_name)
   473 	{
   474 		return;
   475 	}
   476 
   477 	topmenu_object_t *obj;
   478 	topmenu_player_t *pClient = &m_clients[client];
   479 	topmenu_object_t **pObject = m_ObjLookup.retrieve(item_name);
   480 	if (pObject == NULL)
   481 	{
   482 		return;
   483 	}
   484 
   485 	obj = *pObject;
   486 
   487 	/* We now have the object... what do we do with it? */
   488 	if (obj->type == TopMenuObject_Category)
   489 	{
   490 		/* If it's a category, the user wants to view it.. */
   491 		for (size_t i = 0; i < m_Categories.size(); i++)
   492 		{
   493 			if (m_Categories[i]->obj == obj)
   494 			{
   495 				pClient->last_root_pos = item_on_page;
   496 				if (!DisplayCategory(client, (unsigned int)i, MENU_TIME_FOREVER, false))
   497 				{
   498 					/* If we can't display the category, re-display the root menu */
   499 					DisplayMenu(client, MENU_TIME_FOREVER, TopMenuPosition_LastRoot);
   500 				}
   501 				break;
   502 			}
   503 		}
   504 	}
   505 	else
   506 	{
   507 		pClient->last_position = item_on_page;
   508 		
   509 		/* Re-check access in case this user had their credentials revoked */
   510 		if (obj->cmdname[0] != '\0' && !adminsys->CheckAccess(client, obj->cmdname, obj->flags, false))
   511 		{
   512 			DisplayMenu(client, 0, TopMenuPosition_LastCategory);
   513 			return;
   514 		}
   515 		
   516 		/* Pass the information on to the callback */
   517 		obj->callbacks->OnTopMenuSelectOption(this, client, obj->object_id);
   518 	}
   519 }
   520 
   521 void TopMenu::OnMenuDrawItem(IBaseMenu *menu, int client, unsigned int item, unsigned int &style)
   522 {
   523 	const char *item_name = menu->GetItemInfo(item, NULL);
   524 	if (!item_name)
   525 	{
   526 		return;
   527 	}
   528 
   529 	topmenu_object_t *obj;
   530 	topmenu_object_t **pObject = m_ObjLookup.retrieve(item_name);
   531 	if (pObject == NULL)
   532 	{
   533 		return;
   534 	}
   535 
   536 	obj = *pObject;
   537 
   538 	style = obj->callbacks->OnTopMenuDrawOption(this, client, obj->object_id);
   539 	if (style != ITEMDRAW_DEFAULT)
   540 	{
   541 		return;
   542 	}
   543 
   544 	if (obj->cmdname[0] == '\0')
   545 	{
   546 		return;
   547 	}
   548 
   549 	if (!adminsys->CheckAccess(client, obj->cmdname, obj->flags, false))
   550 	{
   551 		style = ITEMDRAW_IGNORE;
   552 	}
   553 }
   554 
   555 unsigned int TopMenu::OnMenuDisplayItem(IBaseMenu *menu,
   556 								int client,
   557 								IMenuPanel *panel,
   558 								unsigned int item,
   559 								const ItemDrawInfo &dr)
   560 {
   561 	const char *item_name = menu->GetItemInfo(item, NULL);
   562 	if (!item_name)
   563 	{
   564 		return 0;
   565 	}
   566 
   567 	topmenu_object_t *obj;
   568 	topmenu_object_t **pObject = m_ObjLookup.retrieve(item_name);
   569 	if (pObject == NULL)
   570 	{
   571 		return 0;
   572 	}
   573 
   574 	obj = *pObject;
   575 
   576 	/* Ask the object to render the text for this client */
   577 	char renderbuf[64];
   578 	obj->callbacks->OnTopMenuDisplayOption(this, client, obj->object_id, renderbuf, sizeof(renderbuf));
   579 
   580 	/* Build the new draw info */
   581 	ItemDrawInfo new_dr = dr;
   582 	new_dr.display = renderbuf;
   583 
   584 	/* Man I love the menu API.  Ask the panel to draw the item and give the position 
   585 	 * back to Core's renderer.  This way we don't have to worry about keeping the 
   586 	 * render buffer static!
   587 	 */
   588 	return panel->DrawItem(new_dr);
   589 }
   590 
   591 void TopMenu::OnMenuCancel(IBaseMenu *menu, int client, MenuCancelReason reason)
   592 {
   593 	if (reason == MenuCancel_ExitBack)
   594 	{
   595 		/* If the client chose exit back, they were on a category menu, and we can
   596 		 * now display the root menu from the last known position.
   597 		 */
   598 		DisplayMenu(client, 0, TopMenuPosition_LastRoot);
   599 	}
   600 }
   601 
   602 void TopMenu::UpdateClientRoot(int client, IGamePlayer *pGamePlayer)
   603 {
   604 	topmenu_player_t *pClient = &m_clients[client];
   605 	IGamePlayer *pPlayer = pGamePlayer ? pGamePlayer : playerhelpers->GetGamePlayer(client);
   606 
   607 	/* Determine if an update is necessary */
   608 	bool is_update_needed = false;
   609 	if (pClient->menu_serial != m_SerialNo)
   610 	{
   611 		is_update_needed = true;
   612 	}
   613 	else if (pPlayer->GetUserId() != pClient->user_id)
   614 	{
   615 		is_update_needed = true;
   616 	}
   617 
   618 	/* If no update is needed at the root level, just leave now */
   619 	if (!is_update_needed)
   620 	{
   621 		return;
   622 	}
   623 
   624 	/* First we need to flush the cache... */
   625 	TearDownClient(pClient);
   626 
   627 	/* Now, rebuild the category list, but don't create menus */
   628 	if (m_Categories.size() == 0)
   629 	{
   630 		pClient->cat_count = 0;
   631 		pClient->cats = NULL;
   632 	}
   633 	else
   634 	{
   635 		pClient->cat_count = (unsigned int)m_Categories.size();
   636 		pClient->cats = new topmenu_player_category_t[pClient->cat_count];
   637 		memset(pClient->cats, 0, sizeof(topmenu_player_category_t) * pClient->cat_count);
   638 	}
   639 
   640 	/* Re-sort the root categories if needed */
   641 	SortCategoriesIfNeeded();
   642 
   643 	/* Build the root menu */
   644 	IBaseMenu *root_menu = menus->GetDefaultStyle()->CreateMenu(this, myself->GetIdentity());
   645 
   646 	/* Add the sorted items */
   647 	for (size_t i = 0; i < m_SortedCats.size(); i++)
   648 	{
   649 		if (m_Categories[m_SortedCats[i]]->obj_list.size() == 0)
   650 		{
   651 			continue;
   652 		}
   653 		root_menu->AppendItem(m_Categories[m_SortedCats[i]]->obj->name, ItemDrawInfo(""));
   654 	}
   655 
   656 	/* Now we need to handle un-sorted items.  This is slightly trickier, as we need to 
   657 	 * pre-render each category name, and cache those names.  Phew!
   658 	 */
   659 	if (m_UnsortedCats.size())
   660 	{
   661 		obj_by_name_t *item_list = new obj_by_name_t[m_UnsortedCats.size()];
   662 		for (size_t i = 0; i < m_UnsortedCats.size(); i++)
   663 		{
   664 			obj_by_name_t *temp_obj = &item_list[i];
   665 			topmenu_object_t *obj = m_Categories[m_UnsortedCats[i]]->obj;
   666 			obj->callbacks->OnTopMenuDisplayOption(this,
   667 				client, 
   668 				obj->object_id,
   669 				temp_obj->name,
   670 				sizeof(temp_obj->name));
   671 			temp_obj->obj_index = m_UnsortedCats[i];
   672 		}
   673 
   674 		/* Sort our temp list */
   675 		qsort(item_list, m_UnsortedCats.size(), sizeof(obj_by_name_t), _SortObjectNamesDescending);
   676 
   677 		/* Add the new sorted categories */
   678 		for (size_t i = 0; i < m_UnsortedCats.size(); i++)
   679 		{
   680 			if (m_Categories[item_list[i].obj_index]->obj_list.size() == 0)
   681 			{
   682 				continue;
   683 			}
   684 			root_menu->AppendItem(m_Categories[item_list[i].obj_index]->obj->name, ItemDrawInfo(""));
   685 		}
   686 
   687 		delete [] item_list;
   688 	}
   689 
   690 	/* Set the menu's title */
   691 	char renderbuf[128];
   692 	m_pTitle->OnTopMenuDisplayTitle(this, client, 0, renderbuf, sizeof(renderbuf));
   693 	root_menu->SetDefaultTitle(renderbuf);
   694 
   695 	/* The client is now fully updated */
   696 	pClient->root = root_menu;
   697 	pClient->user_id = pPlayer->GetUserId();
   698 	pClient->menu_serial = m_SerialNo;
   699 	pClient->last_position = 0;
   700 	pClient->last_category = 0;
   701 	pClient->last_root_pos = 0;
   702 }
   703 
   704 void TopMenu::UpdateClientCategory(int client, unsigned int category)
   705 {
   706 	/* Update the client's root menu just in case it needs it.  This 
   707 	 * will validate that we have both a valid client and a valid
   708 	 * category structure for that client.
   709 	 */
   710 	UpdateClientRoot(client);
   711 
   712 	/* Now it's guaranteed that our category tables will be usable */
   713 	topmenu_player_t *pClient = &m_clients[client];
   714 	topmenu_category_t *cat = m_Categories[category];
   715 	topmenu_player_category_t *player_cat = &(pClient->cats[category]);
   716 
   717 	/* Does the category actually need updating? */
   718 	if (player_cat->serial == cat->serial)
   719 	{
   720 		return;
   721 	}
   722 
   723 	/* Destroy any existing menu */
   724 	if (player_cat->menu)
   725 	{
   726 		player_cat->menu->Destroy();
   727 		player_cat->menu = NULL;
   728 	}
   729 
   730 	if (pClient->last_category == category)
   731 	{
   732 		pClient->last_position = 0;
   733 	}
   734 
   735 	IBaseMenu *cat_menu = menus->GetDefaultStyle()->CreateMenu(this, myself->GetIdentity());
   736 	
   737 	/* Categories get an "exit back" button */
   738 	cat_menu->SetMenuOptionFlags(cat_menu->GetMenuOptionFlags() | MENUFLAG_BUTTON_EXITBACK);
   739 
   740 	/* Re-sort the category if needed */
   741 	SortCategoryIfNeeded(category);
   742 
   743 	/* Build the menu with the sorted items first */
   744 	for (size_t i = 0; i < cat->sorted.size(); i++)
   745 	{
   746 		cat_menu->AppendItem(cat->sorted[i]->name, ItemDrawInfo(""));
   747 	}
   748 
   749 	/* Now handle unsorted items */
   750 	if (cat->unsorted.size())
   751 	{
   752 		/* Build a list of the item names */
   753 		obj_by_name_t *item_list = new obj_by_name_t[cat->unsorted.size()];
   754 		for (size_t i = 0; i < cat->unsorted.size(); i++)
   755 		{
   756 			obj_by_name_t *item = &item_list[i];
   757 			topmenu_object_t *obj = cat->unsorted[i];
   758 			obj->callbacks->OnTopMenuDisplayOption(this,
   759 				client,
   760 				obj->object_id,
   761 				item->name,
   762 				sizeof(item->name));
   763 			item->obj_index = (unsigned int)i;
   764 		}
   765 
   766 		/* Sort the names */
   767 		qsort(item_list, cat->unsorted.size(), sizeof(obj_by_name_t), _SortObjectNamesDescending);
   768 
   769 		/* Add to the menu */
   770 		for (size_t i = 0; i < cat->unsorted.size(); i++)
   771 		{
   772 			cat_menu->AppendItem(cat->unsorted[item_list[i].obj_index]->name, ItemDrawInfo(""));
   773 		}
   774 
   775 		delete [] item_list;
   776 	}
   777 
   778 	/* Set the menu's title */
   779 	char renderbuf[128];
   780 	cat->obj->callbacks->OnTopMenuDisplayTitle(this, 
   781 		client, 
   782 		cat->obj->object_id, 
   783 		renderbuf, 
   784 		sizeof(renderbuf));
   785 	cat_menu->SetDefaultTitle(renderbuf);
   786 
   787 	/* We're done! */
   788 	player_cat->menu = cat_menu;
   789 	player_cat->serial = cat->serial;
   790 }
   791 
   792 void TopMenu::SortCategoryIfNeeded(unsigned int category)
   793 {
   794 	topmenu_category_t *cat = m_Categories[category];
   795 	if (!cat->reorder)
   796 	{
   797 		return;
   798 	}
   799 
   800 	cat->sorted.clear();
   801 	cat->unsorted.clear();
   802 
   803 	if (cat->obj_list.size() == 0)
   804 	{
   805 		cat->reorder = false;
   806 		return;
   807 	}
   808 
   809 	CVector<unsigned int> to_sort;
   810 	for (size_t i = 0; i < cat->obj_list.size(); i++)
   811 	{
   812 		to_sort.push_back(i);
   813 	}
   814 
   815 	/* Find a matching category in the configs */
   816 	config_category_t *config_cat = NULL; 
   817 	for (size_t i = 0; i < m_Config.cats.size(); i++)
   818 	{
   819 		if (strcmp(m_Config.strings.GetString(m_Config.cats[i]->name), cat->obj->name) == 0)
   820 		{
   821 			config_cat = m_Config.cats[i];
   822 			break;
   823 		}
   824 	}
   825 
   826 	/* If there is a matching category, build a pre-sorted item list */
   827 	if (config_cat != NULL)
   828 	{
   829 		/* Find matching objects in this category */
   830 		for (size_t i = 0; i < config_cat->commands.size(); i++)
   831 		{
   832 			const char *config_name = m_Config.strings.GetString(config_cat->commands[i]);
   833 			for (size_t j = 0; j < to_sort.size(); j++)
   834 			{
   835 				if (strcmp(config_name, cat->obj_list[to_sort[j]]->name) == 0)
   836 				{
   837 					/* Place in the final list, then remove from the temporary list */
   838 					cat->sorted.push_back(cat->obj_list[to_sort[j]]);
   839 					to_sort.erase(to_sort.iterAt(j));
   840 					break;
   841 				}
   842 			}
   843 		}
   844 	}
   845 
   846 	/* Push any remaining items onto the unsorted list */
   847 	for (size_t i = 0; i < to_sort.size(); i++)
   848 	{
   849 		cat->unsorted.push_back(cat->obj_list[to_sort[i]]);
   850 	}
   851 
   852 	cat->reorder = false;
   853 }
   854 
   855 void TopMenu::SortCategoriesIfNeeded()
   856 {
   857 	if (!m_bCatsNeedResort)
   858 	{
   859 		return;
   860 	}
   861 
   862 	/* Clear sort results */
   863 	m_SortedCats.clear();
   864 	m_UnsortedCats.clear();
   865 
   866 	if (m_Categories.size() == 0)
   867 	{
   868 		m_bCatsNeedResort = false;
   869 		return;
   870 	}
   871 
   872 	CVector<unsigned int> to_sort;
   873 	for (unsigned int i = 0; i < (unsigned int)m_Categories.size(); i++)
   874 	{
   875 		to_sort.push_back(i);
   876 	}
   877 
   878 	/* If we have any predefined categories, add them in as they appear. */
   879 	for (size_t i= 0; i < m_Config.cats.size(); i++)
   880 	{
   881 		/* Find this category and map it in if we can */
   882 		for (size_t j = 0; j < to_sort.size(); j++)
   883 		{
   884 			if (strcmp(m_Config.strings.GetString(m_Config.cats[i]->name), 
   885 					   m_Categories[to_sort[j]]->obj->name) == 0)
   886 			{
   887 				/* Add to the real list and remove from the temporary */
   888 				m_SortedCats.push_back(to_sort[j]);
   889 				to_sort.erase(to_sort.iterAt(j));
   890 				break;
   891 			}
   892 		}
   893 	}
   894 
   895 	/* Push any remaining items onto the unsorted list */
   896 	for (size_t i = 0; i < to_sort.size(); i++)
   897 	{
   898 		m_UnsortedCats.push_back(to_sort[i]);
   899 	}
   900 
   901 	m_bCatsNeedResort = false;
   902 }
   903 
   904 void TopMenu::CreatePlayers(int max_clients)
   905 {
   906 	m_max_clients = max_clients;
   907 	m_clients = (topmenu_player_t *)malloc(sizeof(topmenu_player_t) * (ABSOLUTE_PLAYER_LIMIT + 1));
   908 	memset(m_clients, 0, sizeof(topmenu_player_t) * (ABSOLUTE_PLAYER_LIMIT + 1));
   909 }
   910 
   911 void TopMenu::TearDownClient(topmenu_player_t *player)
   912 {
   913 	if (player->cats != NULL)
   914 	{
   915 		for (unsigned int i = 0; i < player->cat_count; i++)
   916 		{
   917 			topmenu_player_category_t *player_cat = &(player->cats[i]);
   918 			if (player_cat->menu != NULL)
   919 			{
   920 				player_cat->menu->Destroy();
   921 			}
   922 		}
   923 		delete [] player->cats;
   924 	}
   925 
   926 	if (player->root != NULL)
   927 	{
   928 		player->root->Destroy();
   929 	}
   930 
   931 	memset(player, 0, sizeof(topmenu_player_t));
   932 }
   933 
   934 bool TopMenu::LoadConfiguration(const char *file, char *error, size_t maxlength)
   935 {
   936 	SMCError err;
   937 	SMCStates states;
   938 
   939 	if ((err = textparsers->ParseFile_SMC(file, this, &states))
   940 		!= SMCError_Okay)
   941 	{
   942 		const char *err_string = textparsers->GetSMCErrorString(err);
   943 		if (!err_string)
   944 		{
   945 			err_string = "Unknown";
   946 		}
   947 
   948 		UTIL_Format(error, maxlength, "%s", err_string);
   949 
   950 		return false;
   951 	}
   952 
   953 	return true;
   954 }
   955 
   956 bool TopMenu::OnIdentityRemoval(IdentityToken_t *owner)
   957 {
   958 	/* First sweep the categories owned by us */
   959 	CVector<unsigned int> obj_list;
   960 	for (size_t i = 0; i < m_Categories.size(); i++)
   961 	{
   962 		if (m_Categories[i]->obj->owner == owner)
   963 		{
   964 			obj_list.push_back(m_Categories[i]->obj->object_id);
   965 		}
   966 	}
   967 
   968 	for (size_t i = 0; i < obj_list.size(); i++)
   969 	{
   970 		RemoveFromMenu(obj_list[i]);
   971 	}
   972 
   973 	/* Now we can look for actual items */
   974 	for (size_t i = 0; i < m_Objects.size(); i++)
   975 	{
   976 		if (m_Objects[i]->is_free)
   977 		{
   978 			continue;
   979 		}
   980 		if (m_Objects[i]->owner == owner)
   981 		{
   982 			assert(m_Objects[i]->type != TopMenuObject_Category);
   983 			RemoveFromMenu(m_Objects[i]->object_id);
   984 		}
   985 	}
   986 
   987 	return true;
   988 }
   989 
   990 #define PARSE_STATE_NONE		0
   991 #define PARSE_STATE_MAIN		1
   992 #define PARSE_STATE_CATEGORY	2
   993 unsigned int ignore_parse_level = 0;
   994 unsigned int current_parse_state = 0;
   995 config_category_t *cur_cat = NULL;
   996 
   997 void TopMenu::ReadSMC_ParseStart()
   998 {
   999 	current_parse_state = PARSE_STATE_NONE;
  1000 	ignore_parse_level = 0;
  1001 	cur_cat = NULL;
  1002 
  1003 	/* Reset the old config */
  1004 	m_Config.strings.Reset();
  1005 	for (size_t i = 0; i < m_Config.cats.size(); i++)
  1006 	{
  1007 		delete m_Config.cats[i];
  1008 	}
  1009 	m_Config.cats.clear();
  1010 }
  1011 
  1012 SMCResult TopMenu::ReadSMC_NewSection(const SMCStates *states, const char *name)
  1013 {
  1014 	if (ignore_parse_level)
  1015 	{
  1016 		ignore_parse_level++;
  1017 	}
  1018 	else
  1019 	{
  1020 		if (current_parse_state == PARSE_STATE_NONE)
  1021 		{
  1022 			if (strcmp(name, "Menu") == 0)
  1023 			{
  1024 				current_parse_state = PARSE_STATE_MAIN;
  1025 			}
  1026 			else
  1027 			{
  1028 				ignore_parse_level = 1;
  1029 			}
  1030 		}
  1031 		else if (current_parse_state == PARSE_STATE_MAIN)
  1032 		{
  1033 			cur_cat = new config_category_t;
  1034 			cur_cat->name = m_Config.strings.AddString(name);
  1035 			m_Config.cats.push_back(cur_cat);
  1036 			current_parse_state = PARSE_STATE_CATEGORY;
  1037 		}
  1038 		else
  1039 		{
  1040 			ignore_parse_level = 1;
  1041 		}
  1042 	}
  1043 
  1044 	return SMCResult_Continue;
  1045 }
  1046 
  1047 SMCResult TopMenu::ReadSMC_KeyValue(const SMCStates *states, const char *key, const char *value)
  1048 {
  1049 	if (ignore_parse_level > 0
  1050 		|| current_parse_state != PARSE_STATE_CATEGORY
  1051 		|| cur_cat == NULL)
  1052 	{
  1053 		return SMCResult_Continue;
  1054 	}
  1055 
  1056 	if (strcmp(key, "item") == 0)
  1057 	{
  1058 		cur_cat->commands.push_back(m_Config.strings.AddString(value));
  1059 	}
  1060 
  1061 	return SMCResult_Continue;
  1062 }
  1063 
  1064 SMCResult TopMenu::ReadSMC_LeavingSection(const SMCStates *states)
  1065 {
  1066 	if (ignore_parse_level)
  1067 	{
  1068 		ignore_parse_level--;
  1069 	}
  1070 	else
  1071 	{
  1072 		if (current_parse_state == PARSE_STATE_CATEGORY)
  1073 		{
  1074 			cur_cat = NULL;
  1075 			current_parse_state = PARSE_STATE_MAIN;
  1076 		}
  1077 		else if (current_parse_state == PARSE_STATE_MAIN)
  1078 		{
  1079 			current_parse_state = PARSE_STATE_NONE;
  1080 		}
  1081 	}
  1082 
  1083 	return SMCResult_Continue;
  1084 }
  1085 
  1086 unsigned int TopMenu::FindCategory(const char *name)
  1087 {
  1088 	topmenu_object_t **p_obj = m_ObjLookup.retrieve(name);
  1089 	if (!p_obj)
  1090 	{
  1091 		return 0;
  1092 	}
  1093 
  1094 	topmenu_object_t *obj = *p_obj;
  1095 	if (obj->type != TopMenuObject_Category)
  1096 	{
  1097 		return 0;
  1098 	}
  1099 
  1100 	return obj->object_id;
  1101 }
  1102 
  1103 void TopMenu::OnMaxPlayersChanged( int newvalue )
  1104 {
  1105 	m_max_clients = newvalue;
  1106 }
  1107 
  1108 int _SortObjectNamesDescending(const void *ptr1, const void *ptr2)
  1109 {
  1110 	obj_by_name_t *obj1 = (obj_by_name_t *)ptr1;
  1111 	obj_by_name_t *obj2 = (obj_by_name_t *)ptr2;
  1112 	return strcmp(obj1->name, obj2->name);
  1113 }
  1114 
  1115 unsigned int strncopy(char *dest, const char *src, size_t count)
  1116 {
  1117 	if (!count)
  1118 	{
  1119 		return 0;
  1120 	}
  1121 
  1122 	char *start = dest;
  1123 	while ((*src) && (--count))
  1124 	{
  1125 		*dest++ = *src++;
  1126 	}
  1127 	*dest = '\0';
  1128 
  1129 	return (dest - start);
  1130 }
  1131 
  1132 size_t UTIL_Format(char *buffer, size_t maxlength, const char *fmt, ...)
  1133 {
  1134 	va_list ap;
  1135 	va_start(ap, fmt);
  1136 	size_t len = vsnprintf(buffer, maxlength, fmt, ap);
  1137 	va_end(ap);
  1138 
  1139 	if (len >= maxlength)
  1140 	{
  1141 		buffer[maxlength - 1] = '\0';
  1142 		return (maxlength - 1);
  1143 	}
  1144 	else
  1145 	{
  1146 		return len;
  1147 	}
  1148 }
sourcemod-central
Feed