Home - sourcemod-central - file revision - extensions/topmenus/TopMenu.cpp@d30c252089be Mercurial
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
extensions/topmenus/TopMenu.cpp
author David Anderson <dvander@alliedmods.net>
Wed Dec 05 18:07:18 2007 +0000 (2007-12-05)
changeset 1766 d30c252089be
parent 1699 4368f4cc417b
child 1947 e73a1e51833b
permissions -rw-r--r--
sm_dump_handles now shows memory usage 
     1 /**
     2  * vim: set ts=4 :
     3  * =============================================================================
     4  * SourceMod Sample Extension
     5  * Copyright (C) 2004-2007 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) * m_max_clients);
    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 					cat->obj_list[j]->callbacks->OnTopMenuObjectRemoved(this, cat->obj_list[j]->object_id);
   334 					cat->obj_list[j]->is_free = true;
   335 				}
   336 				
   337 				/* Remove the category from the list, then delete it. */
   338 				m_Categories.erase(m_Categories.iterAt(i));
   339 				delete cat;
   340 				break;
   341 			}
   342 		}
   343 
   344 		/* Update the root as changed. */
   345 		m_SerialNo++;
   346 		m_bCatsNeedResort = true;
   347 	}
   348 	else if (obj->type == TopMenuObject_Item)
   349 	{
   350 		/* Find the category this item is in. */
   351 		topmenu_category_t *parent_cat = NULL;
   352 		for (size_t i = 0; i < m_Categories.size(); i++)
   353 		{
   354 			if (m_Categories[i]->obj == obj->parent)
   355 			{
   356 				parent_cat = m_Categories[i];
   357 				break;
   358 			}
   359 		}
   360 
   361 		/* Erase it from the category's lists. */
   362 		if (parent_cat)
   363 		{
   364 			for (size_t i = 0; i < parent_cat->obj_list.size(); i++)
   365 			{
   366 				if (parent_cat->obj_list[i] == obj)
   367 				{
   368 					parent_cat->obj_list.erase(parent_cat->obj_list.iterAt(i));
   369 
   370 					/* If this category now has no items, mark root as changed 
   371 					 * so clients won't get the category drawn anymore.
   372 					 */
   373 					if (parent_cat->obj_list.size() == 0)
   374 					{
   375 						m_SerialNo++;
   376 					}
   377 					break;
   378 				}
   379 			}
   380 
   381 			/* Update the category as changed. */
   382 			parent_cat->reorder = true;
   383 			parent_cat->serial++;
   384 		}
   385 	}
   386 
   387 	/* The callbacks pointer is still valid, so fire away! */
   388 	obj->callbacks->OnTopMenuObjectRemoved(this, object_id);
   389 
   390 	/* Finally, mark the object as free. */
   391 	obj->is_free = true;
   392 }
   393 
   394 bool TopMenu::DisplayMenu(int client, unsigned int hold_time, TopMenuPosition position)
   395 {
   396 	if (m_clients == NULL)
   397 	{
   398 		return false;
   399 	}
   400 
   401 	IGamePlayer *pPlayer = playerhelpers->GetGamePlayer(client);
   402 	if (!pPlayer->IsInGame())
   403 	{
   404 		return false;
   405 	}
   406 
   407 	UpdateClientRoot(client, pPlayer);
   408 
   409 	topmenu_player_t *pClient = &m_clients[client];
   410 	if (pClient->root == NULL)
   411 	{
   412 		return false;
   413 	}
   414 
   415 	bool return_value = false;
   416 
   417 	if (position == TopMenuPosition_LastCategory && 
   418 		pClient->last_category < m_Categories.size())
   419 	{
   420 		return_value = DisplayCategory(client, pClient->last_category, hold_time, true);
   421 		if (!return_value)
   422 		{
   423 			return_value = pClient->root->DisplayAtItem(client, hold_time, pClient->last_root_pos);
   424 		}
   425 	}
   426 	else if (position == TopMenuPosition_LastRoot)
   427 	{
   428 		pClient->root->DisplayAtItem(client, hold_time, pClient->last_root_pos);
   429 	}
   430 	else if (position == TopMenuPosition_Start)
   431 	{
   432 		pClient->last_position = 0;
   433 		pClient->last_category = 0;
   434 		return_value = pClient->root->Display(client, hold_time);
   435 	}
   436 
   437 	return return_value;
   438 }
   439 
   440 bool TopMenu::DisplayCategory(int client, unsigned int category, unsigned int hold_time, bool last_position)
   441 {
   442 	UpdateClientCategory(client, category);
   443 
   444 	topmenu_player_t *pClient = &m_clients[client];
   445 	if (category >= pClient->cat_count
   446 		|| pClient->cats[category].menu == NULL)
   447 	{
   448 		return false;
   449 	}
   450 
   451 	bool return_value = false;
   452 
   453 	topmenu_player_category_t *player_cat = &(pClient->cats[category]);
   454 
   455 	pClient->last_category = category;
   456 	if (last_position)
   457 	{
   458 		return_value = player_cat->menu->DisplayAtItem(client, hold_time, pClient->last_position);
   459 	}
   460 	else
   461 	{
   462 		return_value = player_cat->menu->Display(client, hold_time);
   463 	}
   464 
   465 	return return_value;
   466 }
   467 
   468 void TopMenu::OnMenuSelect2(IBaseMenu *menu, int client, unsigned int item, unsigned int item_on_page)
   469 {
   470 	const char *item_name = menu->GetItemInfo(item, NULL);
   471 	if (!item_name)
   472 	{
   473 		return;
   474 	}
   475 
   476 	topmenu_object_t *obj;
   477 	topmenu_player_t *pClient = &m_clients[client];
   478 	topmenu_object_t **pObject = m_ObjLookup.retrieve(item_name);
   479 	if (pObject == NULL)
   480 	{
   481 		return;
   482 	}
   483 
   484 	obj = *pObject;
   485 
   486 	/* We now have the object... what do we do with it? */
   487 	if (obj->type == TopMenuObject_Category)
   488 	{
   489 		/* If it's a category, the user wants to view it.. */
   490 		for (size_t i = 0; i < m_Categories.size(); i++)
   491 		{
   492 			if (m_Categories[i]->obj == obj)
   493 			{
   494 				pClient->last_root_pos = item_on_page;
   495 				if (!DisplayCategory(client, (unsigned int)i, MENU_TIME_FOREVER, false))
   496 				{
   497 					/* If we can't display the category, re-display the root menu */
   498 					DisplayMenu(client, MENU_TIME_FOREVER, TopMenuPosition_LastRoot);
   499 				}
   500 				break;
   501 			}
   502 		}
   503 	}
   504 	else
   505 	{
   506 		pClient->last_position = item_on_page;
   507 		
   508 		/* Re-check access in case this user had their credentials revoked */
   509 		if (obj->cmdname[0] != '\0' && !adminsys->CheckAccess(client, obj->cmdname, obj->flags, false))
   510 		{
   511 			DisplayMenu(client, 0, TopMenuPosition_LastCategory);
   512 			return;
   513 		}
   514 		
   515 		/* Pass the information on to the callback */
   516 		obj->callbacks->OnTopMenuSelectOption(this, client, obj->object_id);
   517 	}
   518 }
   519 
   520 void TopMenu::OnMenuDrawItem(IBaseMenu *menu, int client, unsigned int item, unsigned int &style)
   521 {
   522 	const char *item_name = menu->GetItemInfo(item, NULL);
   523 	if (!item_name)
   524 	{
   525 		return;
   526 	}
   527 
   528 	topmenu_object_t *obj;
   529 	topmenu_object_t **pObject = m_ObjLookup.retrieve(item_name);
   530 	if (pObject == NULL)
   531 	{
   532 		return;
   533 	}
   534 
   535 	obj = *pObject;
   536 
   537 	style = obj->callbacks->OnTopMenuDrawOption(this, client, obj->object_id);
   538 	if (style != ITEMDRAW_DEFAULT)
   539 	{
   540 		return;
   541 	}
   542 
   543 	if (obj->cmdname[0] == '\0')
   544 	{
   545 		return;
   546 	}
   547 
   548 	if (!adminsys->CheckAccess(client, obj->cmdname, obj->flags, false))
   549 	{
   550 		style = ITEMDRAW_IGNORE;
   551 	}
   552 }
   553 
   554 unsigned int TopMenu::OnMenuDisplayItem(IBaseMenu *menu,
   555 								int client,
   556 								IMenuPanel *panel,
   557 								unsigned int item,
   558 								const ItemDrawInfo &dr)
   559 {
   560 	const char *item_name = menu->GetItemInfo(item, NULL);
   561 	if (!item_name)
   562 	{
   563 		return 0;
   564 	}
   565 
   566 	topmenu_object_t *obj;
   567 	topmenu_object_t **pObject = m_ObjLookup.retrieve(item_name);
   568 	if (pObject == NULL)
   569 	{
   570 		return 0;
   571 	}
   572 
   573 	obj = *pObject;
   574 
   575 	/* Ask the object to render the text for this client */
   576 	char renderbuf[64];
   577 	obj->callbacks->OnTopMenuDisplayOption(this, client, obj->object_id, renderbuf, sizeof(renderbuf));
   578 
   579 	/* Build the new draw info */
   580 	ItemDrawInfo new_dr = dr;
   581 	new_dr.display = renderbuf;
   582 
   583 	/* Man I love the menu API.  Ask the panel to draw the item and give the position 
   584 	 * back to Core's renderer.  This way we don't have to worry about keeping the 
   585 	 * render buffer static!
   586 	 */
   587 	return panel->DrawItem(new_dr);
   588 }
   589 
   590 void TopMenu::OnMenuCancel(IBaseMenu *menu, int client, MenuCancelReason reason)
   591 {
   592 	if (reason == MenuCancel_ExitBack)
   593 	{
   594 		/* If the client chose exit back, they were on a category menu, and we can
   595 		 * now display the root menu from the last known position.
   596 		 */
   597 		DisplayMenu(client, 0, TopMenuPosition_LastRoot);
   598 	}
   599 }
   600 
   601 void TopMenu::UpdateClientRoot(int client, IGamePlayer *pGamePlayer)
   602 {
   603 	topmenu_player_t *pClient = &m_clients[client];
   604 	IGamePlayer *pPlayer = pGamePlayer ? pGamePlayer : playerhelpers->GetGamePlayer(client);
   605 
   606 	/* Determine if an update is necessary */
   607 	bool is_update_needed = false;
   608 	if (pClient->menu_serial != m_SerialNo)
   609 	{
   610 		is_update_needed = true;
   611 	}
   612 	else if (pPlayer->GetUserId() != pClient->user_id)
   613 	{
   614 		is_update_needed = true;
   615 	}
   616 
   617 	/* If no update is needed at the root level, just leave now */
   618 	if (!is_update_needed)
   619 	{
   620 		return;
   621 	}
   622 
   623 	/* First we need to flush the cache... */
   624 	TearDownClient(pClient);
   625 
   626 	/* Now, rebuild the category list, but don't create menus */
   627 	if (m_Categories.size() == 0)
   628 	{
   629 		pClient->cat_count = 0;
   630 		pClient->cats = NULL;
   631 	}
   632 	else
   633 	{
   634 		pClient->cat_count = (unsigned int)m_Categories.size();
   635 		pClient->cats = new topmenu_player_category_t[pClient->cat_count];
   636 		memset(pClient->cats, 0, sizeof(topmenu_player_category_t) * pClient->cat_count);
   637 	}
   638 
   639 	/* Re-sort the root categories if needed */
   640 	SortCategoriesIfNeeded();
   641 
   642 	/* Build the root menu */
   643 	IBaseMenu *root_menu = menus->GetDefaultStyle()->CreateMenu(this, myself->GetIdentity());
   644 
   645 	/* Add the sorted items */
   646 	for (size_t i = 0; i < m_SortedCats.size(); i++)
   647 	{
   648 		if (m_Categories[m_SortedCats[i]]->obj_list.size() == 0)
   649 		{
   650 			continue;
   651 		}
   652 		root_menu->AppendItem(m_Categories[m_SortedCats[i]]->obj->name, ItemDrawInfo(""));
   653 	}
   654 
   655 	/* Now we need to handle un-sorted items.  This is slightly trickier, as we need to 
   656 	 * pre-render each category name, and cache those names.  Phew!
   657 	 */
   658 	if (m_UnsortedCats.size())
   659 	{
   660 		obj_by_name_t *item_list = new obj_by_name_t[m_UnsortedCats.size()];
   661 		for (size_t i = 0; i < m_UnsortedCats.size(); i++)
   662 		{
   663 			obj_by_name_t *temp_obj = &item_list[i];
   664 			topmenu_object_t *obj = m_Categories[m_UnsortedCats[i]]->obj;
   665 			obj->callbacks->OnTopMenuDisplayOption(this,
   666 				client, 
   667 				obj->object_id,
   668 				temp_obj->name,
   669 				sizeof(temp_obj->name));
   670 			temp_obj->obj_index = m_UnsortedCats[i];
   671 		}
   672 
   673 		/* Sort our temp list */
   674 		qsort(item_list, m_UnsortedCats.size(), sizeof(obj_by_name_t), _SortObjectNamesDescending);
   675 
   676 		/* Add the new sorted categories */
   677 		for (size_t i = 0; i < m_UnsortedCats.size(); i++)
   678 		{
   679 			if (m_Categories[item_list[i].obj_index]->obj_list.size() == 0)
   680 			{
   681 				continue;
   682 			}
   683 			root_menu->AppendItem(m_Categories[item_list[i].obj_index]->obj->name, ItemDrawInfo(""));
   684 		}
   685 
   686 		delete [] item_list;
   687 	}
   688 
   689 	/* Set the menu's title */
   690 	char renderbuf[128];
   691 	m_pTitle->OnTopMenuDisplayTitle(this, client, 0, renderbuf, sizeof(renderbuf));
   692 	root_menu->SetDefaultTitle(renderbuf);
   693 
   694 	/* The client is now fully updated */
   695 	pClient->root = root_menu;
   696 	pClient->user_id = pPlayer->GetUserId();
   697 	pClient->menu_serial = m_SerialNo;
   698 	pClient->last_position = 0;
   699 	pClient->last_category = 0;
   700 	pClient->last_root_pos = 0;
   701 }
   702 
   703 void TopMenu::UpdateClientCategory(int client, unsigned int category)
   704 {
   705 	/* Update the client's root menu just in case it needs it.  This 
   706 	 * will validate that we have both a valid client and a valid
   707 	 * category structure for that client.
   708 	 */
   709 	UpdateClientRoot(client);
   710 
   711 	/* Now it's guaranteed that our category tables will be usable */
   712 	topmenu_player_t *pClient = &m_clients[client];
   713 	topmenu_category_t *cat = m_Categories[category];
   714 	topmenu_player_category_t *player_cat = &(pClient->cats[category]);
   715 
   716 	/* Does the category actually need updating? */
   717 	if (player_cat->serial == cat->serial)
   718 	{
   719 		return;
   720 	}
   721 
   722 	/* Destroy any existing menu */
   723 	if (player_cat->menu)
   724 	{
   725 		player_cat->menu->Destroy();
   726 		player_cat->menu = NULL;
   727 	}
   728 
   729 	if (pClient->last_category == category)
   730 	{
   731 		pClient->last_position = 0;
   732 	}
   733 
   734 	IBaseMenu *cat_menu = menus->GetDefaultStyle()->CreateMenu(this, myself->GetIdentity());
   735 	
   736 	/* Categories get an "exit back" button */
   737 	cat_menu->SetMenuOptionFlags(cat_menu->GetMenuOptionFlags() | MENUFLAG_BUTTON_EXITBACK);
   738 
   739 	/* Re-sort the category if needed */
   740 	SortCategoryIfNeeded(category);
   741 
   742 	/* Build the menu with the sorted items first */
   743 	for (size_t i = 0; i < cat->sorted.size(); i++)
   744 	{
   745 		cat_menu->AppendItem(cat->sorted[i]->name, ItemDrawInfo(""));
   746 	}
   747 
   748 	/* Now handle unsorted items */
   749 	if (cat->unsorted.size())
   750 	{
   751 		/* Build a list of the item names */
   752 		obj_by_name_t *item_list = new obj_by_name_t[cat->unsorted.size()];
   753 		for (size_t i = 0; i < cat->unsorted.size(); i++)
   754 		{
   755 			obj_by_name_t *item = &item_list[i];
   756 			topmenu_object_t *obj = cat->unsorted[i];
   757 			obj->callbacks->OnTopMenuDisplayOption(this,
   758 				client,
   759 				obj->object_id,
   760 				item->name,
   761 				sizeof(item->name));
   762 			item->obj_index = (unsigned int)i;
   763 		}
   764 
   765 		/* Sort the names */
   766 		qsort(item_list, cat->unsorted.size(), sizeof(obj_by_name_t), _SortObjectNamesDescending);
   767 
   768 		/* Add to the menu */
   769 		for (size_t i = 0; i < cat->unsorted.size(); i++)
   770 		{
   771 			cat_menu->AppendItem(cat->unsorted[item_list[i].obj_index]->name, ItemDrawInfo(""));
   772 		}
   773 
   774 		delete [] item_list;
   775 	}
   776 
   777 	/* Set the menu's title */
   778 	char renderbuf[128];
   779 	cat->obj->callbacks->OnTopMenuDisplayTitle(this, 
   780 		client, 
   781 		cat->obj->object_id, 
   782 		renderbuf, 
   783 		sizeof(renderbuf));
   784 	cat_menu->SetDefaultTitle(renderbuf);
   785 
   786 	/* We're done! */
   787 	player_cat->menu = cat_menu;
   788 	player_cat->serial = cat->serial;
   789 }
   790 
   791 void TopMenu::SortCategoryIfNeeded(unsigned int category)
   792 {
   793 	topmenu_category_t *cat = m_Categories[category];
   794 	if (!cat->reorder)
   795 	{
   796 		return;
   797 	}
   798 
   799 	cat->sorted.clear();
   800 	cat->unsorted.clear();
   801 
   802 	if (cat->obj_list.size() == 0)
   803 	{
   804 		cat->reorder = false;
   805 		return;
   806 	}
   807 
   808 	CVector<unsigned int> to_sort;
   809 	for (size_t i = 0; i < cat->obj_list.size(); i++)
   810 	{
   811 		to_sort.push_back(i);
   812 	}
   813 
   814 	/* Find a matching category in the configs */
   815 	config_category_t *config_cat = NULL; 
   816 	for (size_t i = 0; i < m_Config.cats.size(); i++)
   817 	{
   818 		if (strcmp(m_Config.strings.GetString(m_Config.cats[i]->name), cat->obj->name) == 0)
   819 		{
   820 			config_cat = m_Config.cats[i];
   821 			break;
   822 		}
   823 	}
   824 
   825 	/* If there is a matching category, build a pre-sorted item list */
   826 	if (config_cat != NULL)
   827 	{
   828 		/* Find matching objects in this category */
   829 		for (size_t i = 0; i < config_cat->commands.size(); i++)
   830 		{
   831 			const char *config_name = m_Config.strings.GetString(config_cat->commands[i]);
   832 			for (size_t j = 0; j < to_sort.size(); j++)
   833 			{
   834 				if (strcmp(config_name, cat->obj_list[to_sort[j]]->name) == 0)
   835 				{
   836 					/* Place in the final list, then remove from the temporary list */
   837 					cat->sorted.push_back(cat->obj_list[to_sort[j]]);
   838 					to_sort.erase(to_sort.iterAt(j));
   839 					break;
   840 				}
   841 			}
   842 		}
   843 	}
   844 
   845 	/* Push any remaining items onto the unsorted list */
   846 	for (size_t i = 0; i < to_sort.size(); i++)
   847 	{
   848 		cat->unsorted.push_back(cat->obj_list[to_sort[i]]);
   849 	}
   850 
   851 	cat->reorder = false;
   852 }
   853 
   854 void TopMenu::SortCategoriesIfNeeded()
   855 {
   856 	if (!m_bCatsNeedResort)
   857 	{
   858 		return;
   859 	}
   860 
   861 	/* Clear sort results */
   862 	m_SortedCats.clear();
   863 	m_UnsortedCats.clear();
   864 
   865 	if (m_Categories.size() == 0)
   866 	{
   867 		m_bCatsNeedResort = false;
   868 		return;
   869 	}
   870 
   871 	CVector<unsigned int> to_sort;
   872 	for (unsigned int i = 0; i < (unsigned int)m_Categories.size(); i++)
   873 	{
   874 		to_sort.push_back(i);
   875 	}
   876 
   877 	/* If we have any predefined categories, add them in as they appear. */
   878 	for (size_t i= 0; i < m_Config.cats.size(); i++)
   879 	{
   880 		/* Find this category and map it in if we can */
   881 		for (size_t j = 0; j < to_sort.size(); j++)
   882 		{
   883 			if (strcmp(m_Config.strings.GetString(m_Config.cats[i]->name), 
   884 					   m_Categories[to_sort[j]]->obj->name) == 0)
   885 			{
   886 				/* Add to the real list and remove from the temporary */
   887 				m_SortedCats.push_back(to_sort[j]);
   888 				to_sort.erase(to_sort.iterAt(j));
   889 				break;
   890 			}
   891 		}
   892 	}
   893 
   894 	/* Push any remaining items onto the unsorted list */
   895 	for (size_t i = 0; i < to_sort.size(); i++)
   896 	{
   897 		m_UnsortedCats.push_back(to_sort[i]);
   898 	}
   899 
   900 	m_bCatsNeedResort = false;
   901 }
   902 
   903 void TopMenu::CreatePlayers(int max_clients)
   904 {
   905 	m_max_clients = max_clients;
   906 	m_clients = (topmenu_player_t *)malloc(sizeof(topmenu_player_t) * (max_clients + 1));
   907 	memset(m_clients, 0, sizeof(topmenu_player_t) * (max_clients + 1));
   908 }
   909 
   910 void TopMenu::TearDownClient(topmenu_player_t *player)
   911 {
   912 	if (player->cats != NULL)
   913 	{
   914 		for (unsigned int i = 0; i < player->cat_count; i++)
   915 		{
   916 			topmenu_player_category_t *player_cat = &(player->cats[i]);
   917 			if (player_cat->menu != NULL)
   918 			{
   919 				player_cat->menu->Destroy();
   920 			}
   921 		}
   922 		delete [] player->cats;
   923 	}
   924 
   925 	if (player->root != NULL)
   926 	{
   927 		player->root->Destroy();
   928 	}
   929 
   930 	memset(player, 0, sizeof(topmenu_player_t));
   931 }
   932 
   933 bool TopMenu::LoadConfiguration(const char *file, char *error, size_t maxlength)
   934 {
   935 	SMCError err;
   936 	SMCStates states;
   937 
   938 	if ((err = textparsers->ParseFile_SMC(file, this, &states))
   939 		!= SMCError_Okay)
   940 	{
   941 		const char *err_string = textparsers->GetSMCErrorString(err);
   942 		if (!err_string)
   943 		{
   944 			err_string = "Unknown";
   945 		}
   946 
   947 		UTIL_Format(error, maxlength, "%s", err_string);
   948 
   949 		return false;
   950 	}
   951 
   952 	return true;
   953 }
   954 
   955 bool TopMenu::OnIdentityRemoval(IdentityToken_t *owner)
   956 {
   957 	/* First sweep the categories owned by us */
   958 	CVector<unsigned int> obj_list;
   959 	for (size_t i = 0; i < m_Categories.size(); i++)
   960 	{
   961 		if (m_Categories[i]->obj->owner == owner)
   962 		{
   963 			obj_list.push_back(m_Categories[i]->obj->object_id);
   964 		}
   965 	}
   966 
   967 	for (size_t i = 0; i < obj_list.size(); i++)
   968 	{
   969 		RemoveFromMenu(obj_list[i]);
   970 	}
   971 
   972 	/* Now we can look for actual items */
   973 	for (size_t i = 0; i < m_Objects.size(); i++)
   974 	{
   975 		if (m_Objects[i]->is_free)
   976 		{
   977 			continue;
   978 		}
   979 		if (m_Objects[i]->owner == owner)
   980 		{
   981 			assert(m_Objects[i]->type != TopMenuObject_Category);
   982 			RemoveFromMenu(m_Objects[i]->object_id);
   983 		}
   984 	}
   985 
   986 	return true;
   987 }
   988 
   989 #define PARSE_STATE_NONE		0
   990 #define PARSE_STATE_MAIN		1
   991 #define PARSE_STATE_CATEGORY	2
   992 unsigned int ignore_parse_level = 0;
   993 unsigned int current_parse_state = 0;
   994 config_category_t *cur_cat = NULL;
   995 
   996 void TopMenu::ReadSMC_ParseStart()
   997 {
   998 	current_parse_state = PARSE_STATE_NONE;
   999 	ignore_parse_level = 0;
  1000 	cur_cat = NULL;
  1001 
  1002 	/* Reset the old config */
  1003 	m_Config.strings.Reset();
  1004 	for (size_t i = 0; i < m_Config.cats.size(); i++)
  1005 	{
  1006 		delete m_Config.cats[i];
  1007 	}
  1008 	m_Config.cats.clear();
  1009 }
  1010 
  1011 SMCResult TopMenu::ReadSMC_NewSection(const SMCStates *states, const char *name)
  1012 {
  1013 	if (ignore_parse_level)
  1014 	{
  1015 		ignore_parse_level++;
  1016 	}
  1017 	else
  1018 	{
  1019 		if (current_parse_state == PARSE_STATE_NONE)
  1020 		{
  1021 			if (strcmp(name, "Menu") == 0)
  1022 			{
  1023 				current_parse_state = PARSE_STATE_MAIN;
  1024 			}
  1025 			else
  1026 			{
  1027 				ignore_parse_level = 1;
  1028 			}
  1029 		}
  1030 		else if (current_parse_state == PARSE_STATE_MAIN)
  1031 		{
  1032 			cur_cat = new config_category_t;
  1033 			cur_cat->name = m_Config.strings.AddString(name);
  1034 			m_Config.cats.push_back(cur_cat);
  1035 			current_parse_state = PARSE_STATE_CATEGORY;
  1036 		}
  1037 		else
  1038 		{
  1039 			ignore_parse_level = 1;
  1040 		}
  1041 	}
  1042 
  1043 	return SMCResult_Continue;
  1044 }
  1045 
  1046 SMCResult TopMenu::ReadSMC_KeyValue(const SMCStates *states, const char *key, const char *value)
  1047 {
  1048 	if (ignore_parse_level > 0
  1049 		|| current_parse_state != PARSE_STATE_CATEGORY
  1050 		|| cur_cat == NULL)
  1051 	{
  1052 		return SMCResult_Continue;
  1053 	}
  1054 
  1055 	if (strcmp(key, "item") == 0)
  1056 	{
  1057 		cur_cat->commands.push_back(m_Config.strings.AddString(value));
  1058 	}
  1059 
  1060 	return SMCResult_Continue;
  1061 }
  1062 
  1063 SMCResult TopMenu::ReadSMC_LeavingSection(const SMCStates *states)
  1064 {
  1065 	if (ignore_parse_level)
  1066 	{
  1067 		ignore_parse_level--;
  1068 	}
  1069 	else
  1070 	{
  1071 		if (current_parse_state == PARSE_STATE_CATEGORY)
  1072 		{
  1073 			cur_cat = NULL;
  1074 			current_parse_state = PARSE_STATE_MAIN;
  1075 		}
  1076 		else if (current_parse_state == PARSE_STATE_MAIN)
  1077 		{
  1078 			current_parse_state = PARSE_STATE_NONE;
  1079 		}
  1080 	}
  1081 
  1082 	return SMCResult_Continue;
  1083 }
  1084 
  1085 unsigned int TopMenu::FindCategory(const char *name)
  1086 {
  1087 	topmenu_object_t **p_obj = m_ObjLookup.retrieve(name);
  1088 	if (!p_obj)
  1089 	{
  1090 		return 0;
  1091 	}
  1092 
  1093 	topmenu_object_t *obj = *p_obj;
  1094 	if (obj->type != TopMenuObject_Category)
  1095 	{
  1096 		return 0;
  1097 	}
  1098 
  1099 	return obj->object_id;
  1100 }
  1101 
  1102 int _SortObjectNamesDescending(const void *ptr1, const void *ptr2)
  1103 {
  1104 	obj_by_name_t *obj1 = (obj_by_name_t *)ptr1;
  1105 	obj_by_name_t *obj2 = (obj_by_name_t *)ptr2;
  1106 	return strcmp(obj1->name, obj2->name);
  1107 }
  1108 
  1109 unsigned int strncopy(char *dest, const char *src, size_t count)
  1110 {
  1111 	if (!count)
  1112 	{
  1113 		return 0;
  1114 	}
  1115 
  1116 	char *start = dest;
  1117 	while ((*src) && (--count))
  1118 	{
  1119 		*dest++ = *src++;
  1120 	}
  1121 	*dest = '\0';
  1122 
  1123 	return (dest - start);
  1124 }
  1125 
  1126 size_t UTIL_Format(char *buffer, size_t maxlength, const char *fmt, ...)
  1127 {
  1128 	va_list ap;
  1129 	va_start(ap, fmt);
  1130 	size_t len = vsnprintf(buffer, maxlength, fmt, ap);
  1131 	va_end(ap);
  1132 
  1133 	if (len >= maxlength)
  1134 	{
  1135 		buffer[maxlength - 1] = '\0';
  1136 		return (maxlength - 1);
  1137 	}
  1138 	else
  1139 	{
  1140 		return len;
  1141 	}
  1142 }
sourcemod-central
Feed