int ob_init(struct order_book *ob)
{
if (!ob)
goto fail;
ob->ghbids = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, free);
if (!ob->ghbids)
goto fail;
ob->ghasks = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, free);
if (!ob->ghasks)
goto fail;
ob->gtasks = g_tree_new(g_uint_compare);
if (!ob->gtasks)
goto fail;
ob->gtbids = g_tree_new(g_uint_compare);
if (!ob->gtbids)
goto fail;
ob->glasks = NULL;
ob->glbids = NULL;
return 0;
fail:
ob_fini(ob);
return -1;
}
/**
* Initialize the RSFiletype subsystem, this MUST be called before any other
* rs_filetype_*-functions
*/
void
rs_filetype_init(void)
{
g_mutex_lock(&lock);
if (rs_filetype_is_initialized)
return;
rs_filetype_is_initialized = TRUE;
loaders = g_tree_new(tree_sort);
meta_loaders = g_tree_new(tree_sort);
g_mutex_unlock(&lock);
}
static void msn_login( account_t *acc )
{
struct im_connection *ic = imcb_new( acc );
struct msn_data *md = g_new0( struct msn_data, 1 );
ic->proto_data = md;
ic->flags |= OPT_PONGS | OPT_PONGED;
if( strchr( acc->user, '@' ) == NULL )
{
imcb_error( ic, "Invalid account name" );
imc_logout( ic, FALSE );
return;
}
md->ic = ic;
md->away_state = msn_away_state_list;
md->domaintree = g_tree_new( msn_domaintree_cmp );
md->ns->fd = -1;
msn_connections = g_slist_prepend( msn_connections, ic );
imcb_log( ic, "Connecting" );
msn_ns_connect( ic, md->ns, MSN_NS_HOST, MSN_NS_PORT );
}
static gchar* _make_base_string(
GSignondSessionData *session_data,
SoupURI* uri, gchar* nonce, gchar* timestamp)
{
GString* base_string = g_string_new("POST&");
gchar* base_uri;
if (soup_uri_uses_default_port(uri))
base_uri = g_strdup_printf("https://%s%s", soup_uri_get_host(uri),
soup_uri_get_path(uri));
else
base_uri = g_strdup_printf("https://%s:%u%s", soup_uri_get_host(uri),
soup_uri_get_port(uri),
soup_uri_get_path(uri));
gchar* base_uri_e = _percent_encode(base_uri);
g_string_append(base_string, base_uri_e);
g_string_append(base_string, "&");
g_free(base_uri);
g_free(base_uri_e);
GTree* parameters = g_tree_new((GCompareFunc)g_strcmp0);
const gchar* query_s = soup_uri_get_query(uri);
GHashTable* query;
if (query_s != NULL)
query = soup_form_decode(query_s);
else
query = soup_form_decode("");
g_hash_table_foreach(query, _insert_into_tree, parameters);
const gchar* callback_uri = gsignond_dictionary_get_string(session_data, "Callback");
if (callback_uri != NULL)
g_tree_insert(parameters, "oauth_callback", (gchar*)callback_uri);
const gchar* oauth_verifier = gsignond_dictionary_get_string(session_data, "_OauthVerifier");
if (oauth_verifier != NULL)
g_tree_insert(parameters, "oauth_verifier", (gchar*)oauth_verifier);
g_tree_insert(parameters, "oauth_consumer_key", (gchar*)gsignond_dictionary_get_string(session_data, "ConsumerKey"));
const gchar* oauth_temp_token = gsignond_dictionary_get_string(session_data, "_OauthTemporaryToken");
if (oauth_temp_token != NULL)
g_tree_insert(parameters, "oauth_token", (gchar*)oauth_temp_token);
g_tree_insert(parameters, "oauth_signature_method", (gchar*)gsignond_dictionary_get_string(session_data, "SignatureMethod"));
g_tree_insert(parameters, "oauth_nonce", nonce);
g_tree_insert(parameters, "oauth_timestamp", timestamp);
g_tree_insert(parameters, "oauth_version", "1.0");
GString* parameters_string = g_string_new(NULL);
g_tree_foreach(parameters, _make_parameters_string, parameters_string);
gchar* parameters_s = g_string_free(parameters_string, FALSE);
parameters_s[strlen(parameters_s)-1] = '\0'; //remove trailing '&'
gchar* parameters_encoded = _percent_encode(parameters_s);
g_string_append(base_string, parameters_encoded);
g_free(parameters_encoded);
g_free(parameters_s);
g_tree_destroy(parameters);
g_hash_table_destroy(query);
return g_string_free(base_string, FALSE);
}
int IDL_ns_check_for_ambiguous_inheritance (IDL_tree interface_ident, IDL_tree p)
{
/* We use a sorted heap to check for namespace collisions,
since we must do case-insensitive collision checks.
visited_interfaces is a hash of visited interface nodes, so
we only visit common ancestors once. */
GTree *ident_heap;
GHashTable *visited_interfaces;
int is_ambiguous = 0;
if (!p)
return 0;
ident_heap = g_tree_new (IDL_ident_cmp);
visited_interfaces = g_hash_table_new (g_direct_hash, g_direct_equal);
assert (IDL_NODE_TYPE (p) == IDLN_LIST);
for (; p; p = IDL_LIST (p).next) {
if (!IDL_ns_load_idents_to_tables (interface_ident, IDL_LIST (p).data,
ident_heap, visited_interfaces))
is_ambiguous = 1;
}
g_tree_destroy (ident_heap);
g_hash_table_destroy (visited_interfaces);
return is_ambiguous;
}
int emc_init_server(struct emc_server_context *ctx)
{
int result;
int max_workers;
char *emc_data_file;
g_thread_init(NULL);
max_workers = emc_config_table_get_or_default_int("emc_max_workers", EMC_DEFAULT_MAX_WORKERS);
emc_data_file = emc_config_table_get("emc_data_file");
ctx->nuauth_directory = g_tree_new( emc_netmask_order_func );
result = emc_parse_datafile(ctx, emc_data_file);
if (result < 0) {
return -1;
}
loop = ev_default_loop(0);
result = emc_setup_servers(loop, ctx);
if (result < 0) {
return -1;
}
ev_signal_init(&sigint_watcher, sigint_cb, SIGINT);
ev_signal_start(loop, &sigint_watcher);
ev_signal_init(&sigterm_watcher, sigint_cb, SIGTERM);
ev_signal_start(loop, &sigterm_watcher);
ev_signal_init(&sigusr1_watcher, sigusr1_cb, SIGUSR1);
ev_signal_start(loop, &sigusr1_watcher);
ev_async_init(&client_ready_signal, emc_client_ready_cb);
ev_async_start(loop, &client_ready_signal);
ctx->continue_processing = 1;
sigint_watcher.data = ctx;
sigterm_watcher.data = ctx;
sigusr1_watcher.data = ctx;
client_ready_signal.data = ctx;
g_thread_pool_set_max_unused_threads( (int)(max_workers/2) );
ctx->pool_tls_handshake = g_thread_pool_new((GFunc)emc_worker_tls_handshake, NULL,
max_workers, FALSE,
NULL);
ctx->pool_reader = g_thread_pool_new((GFunc)emc_worker_reader, NULL,
max_workers, FALSE,
NULL);
ctx->work_queue = g_async_queue_new();
ctx->tls_client_list_mutex = g_mutex_new();
log_printf(DEBUG_LEVEL_DEBUG, "Max: %d", g_thread_pool_get_max_unused_threads());
return 0;
}
void
xmms_object_connect (xmms_object_t *object, guint32 signalid,
xmms_object_handler_t handler, gpointer userdata)
{
GList *list = NULL;
xmms_object_handler_entry_t *entry;
g_return_if_fail (object);
g_return_if_fail (XMMS_IS_OBJECT (object));
g_return_if_fail (handler);
entry = g_new0 (xmms_object_handler_entry_t, 1);
entry->handler = handler;
entry->userdata = userdata;
if (!object->signals)
object->signals = g_tree_new (compare_signal_key);
else
list = g_tree_lookup (object->signals,
GINT_TO_POINTER (signalid));
list = g_list_prepend (list, entry);
/* store the list's new head in the tree */
g_tree_insert (object->signals, GINT_TO_POINTER (signalid), list);
}
int main() {
GTree *tokens;
gboolean is_first = TRUE;
gint i;
tokens = g_tree_new((GCompareFunc)g_ascii_strcasecmp);
for (i = 0; i < sql_token_get_last_id(); i++) {
/** only tokens with TK_SQL_* are keyworks */
if (0 != strncmp(sql_token_get_name(i, NULL), "TK_SQL_", sizeof("TK_SQL_") - 1)) continue;
g_tree_insert(tokens, ( gpointer ) (sql_token_get_name(i, NULL) + sizeof("TK_SQL_") - 1), GINT_TO_POINTER(i));
}
/* traverse the tree and output all keywords in a sorted way */
printf("static int sql_keywords[] = {");
g_tree_foreach(tokens, trav, &is_first);
printf("\n};\n");
printf("int *sql_keywords_get() { return sql_keywords; }\n");
printf("int sql_keywords_get_count() { return sizeof(sql_keywords) / sizeof(sql_keywords[0]); }\n");
g_tree_destroy(tokens);
return 0;
}
static void
fontsel_insert_face (const FT_Face face,
const gchar *file_name,
const gint face_index)
{
GTree *family;
FontFace *font;
gchar *name;
family = g_tree_lookup (families, face->family_name);
if (!family)
{
family = g_tree_new ((GCompareFunc) strcmp);
name = g_strdup (face->family_name);
g_tree_insert (families, name, family);
}
font = g_new (FontFace, 1);
font->file_name = g_strdup (file_name);
font->face_index = face_index;
font->family_name = g_strdup (face->family_name);
if (face->style_name)
name = g_strdup (face->style_name);
else
name = g_strdup ("(unknown)");
font->style_name = name;
g_tree_insert (family, name, font);
}
static void httpserver_init (HTTPServer *http_server)
{
gint i;
RequestData *request_data;
http_server->listen_thread = NULL;
http_server->thread_pool = NULL;
g_mutex_init (&(http_server->request_data_queue_mutex));
http_server->request_data_queue = g_queue_new ();
for (i=0; i<kMaxRequests; i++) {
request_data = (RequestData *)g_malloc (sizeof (RequestData));
g_mutex_init (&(request_data->events_mutex));
request_data->id = i;
request_data->num_headers = 0;
http_server->request_data_pointers[i] = request_data;
g_queue_push_head (http_server->request_data_queue, &http_server->request_data_pointers[i]);
}
g_mutex_init (&(http_server->idle_queue_mutex));
g_cond_init (&(http_server->idle_queue_cond));
http_server->idle_queue = g_tree_new ((GCompareFunc)compare_func);
g_mutex_init (&(http_server->block_queue_mutex));
g_cond_init (&(http_server->block_queue_cond));
http_server->block_queue = g_queue_new ();
http_server->total_click = 0;
http_server->encoder_click = 0;
http_server->system_clock = gst_system_clock_obtain ();
g_object_set (http_server->system_clock, "clock-type", GST_CLOCK_TYPE_REALTIME, NULL);
}
/* add a new playlist entry into the table (number, name and random/not random) */
void irmpc_playlist_add (unsigned int number, const char *name, bool random)
{
if (name == NULL) return;
if (playlist_name_storage == NULL) {
playlist_name_storage = g_string_chunk_new (64);
if (playlist_name_storage == NULL) return;
}
gchar *entry_name = g_string_chunk_insert (playlist_name_storage, name);
if (playlist_table == NULL) {
playlist_table = g_tree_new (irmpc_playlist_table_cmp_func);
if (playlist_table == NULL) return;
}
struct playlist_info *entry;
entry = (struct playlist_info *) malloc (sizeof (struct playlist_info));
if (entry == NULL) return;
entry->name = entry_name;
entry->random = random;
g_tree_insert (playlist_table, GINT_TO_POINTER(number), entry);
}
void b_malloc_init(unsigned long heap_nbytes)
{
bm = bitmap_init((heap_nbytes/BITMAP_BIT_NUM_BYTES)/CHAR_BIT);
heap_info = g_tree_new((GCompareFunc) compare_heap_entry);
heap = malloc(heap_nbytes);
}
int MailboxState_flush_recent(T M)
{
GList *recent;
if ((!M) || (M && MailboxState_getPermission(M) != IMAPPERM_READWRITE))
return DM_SUCCESS;
if (! g_tree_nnodes(M->recent_queue))
return DM_SUCCESS;
TRACE(TRACE_DEBUG,"flush [%d] recent messages", g_tree_nnodes(M->recent_queue));
recent = g_tree_keys(M->recent_queue);
if (recent) {
long long int changed = 0;
uint64_t seq = MailboxState_getSeq(M);
changed = _update_recent(g_list_slices_u64(recent,100), seq+1);
if (changed)
db_mailbox_seq_update(MailboxState_getId(M), 0);
}
g_list_free(g_list_first(recent));
g_tree_foreach(M->recent_queue, (GTraverseFunc)_free_recent_queue, M);
g_tree_destroy(M->recent_queue);
M->recent_queue = g_tree_new((GCompareFunc)ucmp);
return 0;
}
static void
wavegen_init(Machine *mach, WaveGenType type)
{
WaveGen *wavegen = WAVEGEN (mach);
machine_init (mach);
/* Set up callbacks
*/
mach->noteon = wavegen_noteon;
mach->noteoff = wavegen_noteoff;
mach->do_stuff = wavegen_do_stuff;
mach->all_notes_off = wavegen_all_notes_off;
mach->free = wavegen_free;
wavegen->notes = g_tree_new (note_compare_func);
wavegen->type = type;
#ifdef 0
if (type == WAVEGEN_SINE)
{
wavegen->wavetable_size = 1024;
wavegen->wavetable = g_new (gfloat, wavegen->wavetable_size);
init_wavetable_sine (wavegen->wavetable, wavegen->wavetable_size);
}
else
{
wavegen->wavetable_size = 0;
wavegen->wavetable = NULL;
}
#endif
}
void keyboard_init(void)
{
keys = g_hash_table_new((GHashFunc) g_str_hash,
(GCompareFunc) g_str_equal);
default_keys = g_hash_table_new((GHashFunc) g_str_hash,
(GCompareFunc) g_str_equal);
keyinfos = NULL;
key_states = g_tree_new((GCompareFunc) g_strcmp0);
key_config_frozen = 0;
memset(used_keys, 0, sizeof(used_keys));
settings_add_int("misc", "key_timeout", 0);
key_bind("command", "Run any command", NULL, NULL, (SIGNAL_FUNC) sig_command);
key_bind("key", "Specify name for key binding", NULL, NULL, (SIGNAL_FUNC) sig_key);
key_bind("multi", "Run multiple commands", NULL, NULL, (SIGNAL_FUNC) sig_multi);
key_bind("nothing", "Do nothing", NULL, NULL, (SIGNAL_FUNC) sig_nothing);
/* read the keyboard config when all key binds are known */
signal_add("irssi init read settings", (SIGNAL_FUNC) read_keyboard_config);
signal_add("setup reread", (SIGNAL_FUNC) read_keyboard_config);
signal_add("complete command bind", (SIGNAL_FUNC) sig_complete_bind);
command_bind("bind", NULL, (SIGNAL_FUNC) cmd_bind);
command_set_options("bind", "delete list");
}
void i2c_init(struct plugin *p, struct plugin_set *__un1, struct plug_args *pa)
{
char filename[FILENAME_MAX];
struct i2c_data *i2c = p->data = g_new(struct i2c_data,1);
i2c->is = g_tree_new(comp_int64);
i2c->outstanding = 0;
i2c->maxouts = 0;
i2c->oio_f = NULL;
if(pa->i2c_oio_f) {
get_filename(filename, "i2c_oio", pa->i2c_oio_f, pa->end_range);
i2c->oio_f = fopen(filename,"w");
if(!i2c->oio_f) perror_exit("Opening I2C detail file");
}
i2c->oio_hist_f = NULL;
if(pa->i2c_oio_hist_f) {
get_filename(filename, "i2c_oio_hist", pa->i2c_oio_hist_f, pa->end_range);
i2c->oio_hist_f = fopen(filename,"w");
if(!i2c->oio_hist_f) perror_exit("Opening I2C detail file");
}
i2c->oio = NULL;
i2c->oio_size = 0;
i2c->oio_prev_time = UINT64_MAX;
}
void init_plugs_ops()
{
int i;
for(i = 0; i < N_PLUGINS; ++i) {
ps_ops[i].event_tree = g_tree_new(comp_int);
if(plug_init_dest[i].ops_init)
plug_init_dest[i].ops_init(&ps_ops[i]);
}
}
/* --- functions --- */
static void
eva_main_loop_select_init (EvaMainLoopSelect *main_loop_select)
{
main_loop_select->fd_tree = g_tree_new (compare_raw_ints);
/* XXX: waste of time unless FD_ZERO is not a bitwise zero-ing */
FD_ZERO (&main_loop_select->read_set);
FD_ZERO (&main_loop_select->write_set);
FD_ZERO (&main_loop_select->except_set);
}
static GString *purple_fbapi_construct_request_vargs(PurpleAccount *account, const char *method, va_list args)
{
GTree *params;
const char *api_key, *api_secret;
const char *key, *value;
char call_id[21];
char *signature;
GString *body;
/* Read all paramters into a sorted tree */
params = g_tree_new((GCompareFunc)strcmp);
while ((key = va_arg(args, const char *)) != NULL)
{
value = va_arg(args, const char *);
g_tree_insert(params, (char *)key, (char *)value);
/* If we have a session_key then we need a call_id */
if (g_str_equal(key, "session_key")) {
struct timeval tv;
if (gettimeofday(&tv, NULL) != 0) {
time_t now;
purple_debug_error("fbapi",
"Error calling gettimeofday(): %s\n",
g_strerror(errno));
now = time(NULL);
strftime(call_id, sizeof(call_id), "%s000000", localtime(&now));
} else {
char tmp[22];
strftime(tmp, sizeof(tmp), "%s", localtime(&tv.tv_sec));
sprintf(call_id, "%s%06lu", tmp, (long unsigned int)tv.tv_usec);
}
g_tree_insert(params, "call_id", call_id);
}
}
api_key = purple_account_get_string(account, "fb_api_key", PURPLE_FBAPI_KEY);
api_secret = purple_account_get_string(account, "fb_api_secret", API_SECRET);
/* Add the method and api_key parameters to the list */
g_tree_insert(params, "method", (char *)method);
g_tree_insert(params, "api_key", (char *)api_key);
/* Add the signature parameter to the list */
signature = generate_signature((char *)api_secret, params);
g_tree_insert(params, "sig", signature);
/* Construct the body of the HTTP POST request */
body = g_string_new(NULL);
g_tree_foreach(params, append_params_to_body, body);
g_tree_destroy(params);
g_free(signature);
return body;
}
GTree* pooltag_build_tree() {
GTree *pooltags = g_tree_new((GCompareFunc) strcmp);
uint32_t i = 0;
for (; i < TAG_COUNT; i++) {
g_tree_insert(pooltags, (char*) tags[i].tag,
(char*) &tags[i]);
}
return pooltags;
}
void
wavegen_all_notes_off (Machine *mach)
{
WaveGen *wavegen = WAVEGEN (mach);
/* BAD STUFF: doesn't free the WaveGenNote! */
/* I know this (below) sucks, but I'm gonna switch to another
* tree implementation (libavl) */
g_tree_destroy (wavegen->notes);
wavegen->notes = g_tree_new (note_compare_func);
}
static void __ice_agent_initialize(struct ice_agent *ag) {
struct call_media *media = ag->media;
struct call *call = ag->call;
ag->candidate_hash = g_hash_table_new(__cand_hash, __cand_equal);
ag->pair_hash = g_hash_table_new(__pair_hash, __pair_equal);
ag->transaction_hash = g_hash_table_new(__trans_hash, __trans_equal);
ag->foundation_hash = g_hash_table_new(__found_hash, __found_equal);
ag->agent_flags = 0;
bf_copy(&ag->agent_flags, ICE_AGENT_CONTROLLING, &media->media_flags, MEDIA_FLAG_ICE_CONTROLLING);
ag->local_interface = media->interface;
ag->desired_family = media->desired_family;
ag->nominated_pairs = g_tree_new(__pair_prio_cmp);
ag->valid_pairs = g_tree_new(__pair_prio_cmp);
ag->succeeded_pairs = g_tree_new(__pair_prio_cmp);
ag->all_pairs = g_tree_new(__pair_prio_cmp);
create_random_ice_string(call, &ag->ufrag[1], 8);
create_random_ice_string(call, &ag->pwd[1], 26);
}
int main(void) {
GTree *t = g_tree_new((GCompareFunc)g_ascii_strcasecmp);
g_tree_insert(t, "d", "Detroit");
g_tree_insert(t, "a", "Atlanta");
g_tree_insert(t, "c", "Chicago");
g_tree_insert(t, "b", "Boston");
puts("Iterating over all nodes");
g_tree_foreach(t, (GTraverseFunc)iterate_all, NULL);
puts("Iterating over some specific nodes");
g_tree_foreach(t, (GTraverseFunc)iterate_some, NULL);
g_tree_destroy(t);
}
Execp *create_execp()
{
Execp *execp = calloc(1, sizeof(Execp));
execp->backend = calloc(1, sizeof(ExecpBackend));
execp->backend->child_pipe = -1;
execp->backend->cmd_pids = g_tree_new(cmp_ptr);
execp->backend->interval = 30;
execp->backend->cache_icon = TRUE;
execp->backend->centered = TRUE;
execp->backend->font_color.alpha = 0.5;
return execp;
}
void init_X11() {
server.dsp = XOpenDisplay(NULL);
if (!server.dsp) DIE("tint: could not open display.");
server_init_atoms();
server.screen = DefaultScreen(server.dsp);
server.root_win = RootWindow(server.dsp, server.screen);
server.desktop = server_get_current_desktop();
server_init_visual();
XSetErrorHandler((XErrorHandler)server_catch_error);
#ifdef HAVE_SN
// Initialize startup-notification
server.sn_dsp = sn_display_new(server.dsp, error_trap_push, error_trap_pop);
server.pids = g_tree_new(cmp_ptr);
// Setup a handler for child termination
struct sigaction act;
memset(&act, 0, sizeof(struct sigaction));
act.sa_handler = sigchld_handler;
if (sigaction(SIGCHLD, &act, 0)) {
perror("sigaction");
}
#endif // HAVE_SN
imlib_context_set_display(server.dsp);
imlib_context_set_visual(server.visual);
imlib_context_set_colormap(server.colormap);
/* Catch events */
XSelectInput(server.dsp, server.root_win,
PropertyChangeMask | StructureNotifyMask);
setlocale(LC_ALL, "");
// config file use '.' as decimal separator
setlocale(LC_NUMERIC, "POSIX");
// load default icon
gchar* path;
const gchar* const* data_dirs;
data_dirs = g_get_system_data_dirs();
int i;
for (i = 0; data_dirs[i] != NULL; i++) {
path = g_build_filename(data_dirs[i], "tinto", "default_icon.png", NULL);
if (g_file_test(path, G_FILE_TEST_EXISTS))
default_icon = imlib_load_image(path);
g_free(path);
}
// get monitor and desktop config
get_monitors();
get_desktops();
}
static inline void initialize_static()
{
if (!static_initialized)
{
GQuark q = 0;
administrands = g_tree_new(ptr_compare);
quark_to_char = g_hash_table_new(g_direct_hash, g_direct_equal);
char_to_quark = g_array_new(FALSE, FALSE, sizeof(GQuark));
g_hash_table_insert(quark_to_char, 0, 0);
g_array_append_val(char_to_quark, q);
static_initialized = TRUE;
}
}
int main(void) {
GTree *t = g_tree_new((GCompareFunc)g_ascii_strcasecmp);
g_tree_insert(t, "c", "Chicago");
printf("The tree height is %d\n", g_tree_height(t));
g_tree_insert(t, "b", "Boston");
g_tree_insert(t, "d", "Detroit");
printf("Height is now %d for %d nodes in the tree\n", g_tree_height(t),
g_tree_nnodes(t));
g_tree_remove(t, "d");
printf("Height is now %d for %d nodes in the tree\n", g_tree_height(t),
g_tree_nnodes(t));
g_tree_destroy(t);
}
/**
* Add a command that could be called from the client API to a object.
*
* @param object The object that should have the method.
* @param cmdid A command id.
* @param desc A command description.
*/
void
xmms_object_cmd_add (xmms_object_t *object, guint cmdid,
const xmms_object_cmd_func_t func)
{
g_return_if_fail (object);
g_return_if_fail (func);
if (!object->cmds)
object->cmds = g_tree_new (compare_cmd_key);
g_tree_insert (object->cmds, GUINT_TO_POINTER (cmdid),
(gpointer) func);
}
/* Rescan all the key combos and figure out which characters are supposed
to be treated as characters and which as key combos.
Yes, this is pretty slow function... */
static void key_states_rescan(void)
{
GString *temp;
memset(used_keys, 0, sizeof(used_keys));
g_tree_foreach(key_states, (GTraverseFunc) key_state_destroy,
NULL);
g_tree_destroy(key_states);
key_states = g_tree_new((GCompareFunc) g_strcmp0);
temp = g_string_new(NULL);
g_hash_table_foreach(keys, (GHFunc) key_states_scan_key, temp);
g_string_free(temp, TRUE);
}
/**
* itdb_track_id_tree_create:
* @itdb: an #Itdb_iTunesDB
*
* Creates a balanced-binary tree for quick ID lookup that is used in
* itdb_track_by_id_tree()
*
* Returns: a #GTree indexed by track IDs to be freed with
* itdb_track_id_tree_destroy() when no longer used
*/
GTree *itdb_track_id_tree_create (Itdb_iTunesDB *itdb)
{
GTree *idtree;
GList *gl;
g_return_val_if_fail (itdb, NULL);
idtree = g_tree_new (track_id_compare);
for (gl=itdb->tracks; gl; gl=gl->next)
{
Itdb_Track *tr = gl->data;
g_return_val_if_fail (tr, NULL);
g_tree_insert (idtree, &tr->id, tr);
}
return idtree;
}
