/*******************************************************************************
* Description :
* Argurments :
* Return value :
* Modify :
* warning :
*******************************************************************************/
static void list_sort(ListHandle handle, SortingMode mode)
{
if(mode & SORT_ASCII) {
handle->list = g_list_sort_with_data(handle->list, (GCompareDataFunc)compare_ascii, &mode);
}
else if(mode & SORT_UNICODE) {
handle->list = g_list_sort_with_data(handle->list, (GCompareDataFunc)compare_unicode, &mode);
}
else {
handle->list = g_list_sort_with_data(handle->list, (GCompareDataFunc)compare_constant, &mode);
}
}
static resource_t *
find_compatible_tuple(resource_t *rsc_lh, resource_t * rsc, enum rsc_role_e filter,
gboolean current)
{
GListPtr scratch = NULL;
resource_t *pair = NULL;
node_t *active_node_lh = NULL;
active_node_lh = rsc_lh->fns->location(rsc_lh, NULL, current);
if (active_node_lh) {
return find_compatible_tuple_by_node(rsc_lh, active_node_lh, rsc, filter, current);
}
scratch = g_hash_table_get_values(rsc_lh->allowed_nodes);
scratch = g_list_sort_with_data(scratch, sort_node_weight, NULL);
for (GListPtr gIter = scratch; gIter != NULL; gIter = gIter->next) {
node_t *node = (node_t *) gIter->data;
pair = find_compatible_tuple_by_node(rsc_lh, node, rsc, filter, current);
if (pair) {
goto done;
}
}
pe_rsc_debug(rsc, "Can't pair %s with %s", rsc_lh->id, rsc->id);
done:
g_list_free(scratch);
return pair;
}
void ptk_file_list_sort ( PtkFileList* list )
{
GHashTable* old_order;
gint *new_order;
GtkTreePath *path;
GList* l;
int i;
if( list->n_files <=1 )
return;
old_order = g_hash_table_new( g_direct_hash, g_direct_equal );
/* save old order */
for( i = 0, l = list->files; l; l = l->next, ++i )
g_hash_table_insert( old_order, l, GINT_TO_POINTER(i) );
/* sort the list */
list->files = g_list_sort_with_data( list->files,
ptk_file_list_compare, list );
/* save new order */
new_order = g_new( int, list->n_files );
for( i = 0, l = list->files; l; l = l->next, ++i )
new_order[i] = GPOINTER_TO_INT( g_hash_table_lookup( old_order, l ) );
g_hash_table_destroy( old_order );
path = gtk_tree_path_new ();
gtk_tree_model_rows_reordered (GTK_TREE_MODEL (list),
path, NULL, new_order);
gtk_tree_path_free (path);
g_free( new_order );
}
void
uprof_context_foreach_counter (UProfContext *context,
GCompareDataFunc sort_compare_func,
UProfCounterResultCallback callback,
void * data)
{
GList *l;
GList *counters;
GList *all_counters = NULL;
g_return_if_fail (context != NULL);
g_return_if_fail (callback != NULL);
/* If the context has been linked with other contexts, then we want
* a flat list of counters we can sort... */
/* XXX: may want a dirty flag mechanism to avoid repeating this
* too often! */
if (context->links)
{
_uprof_context_for_self_and_links_recursive (context,
copy_counters_list_cb,
&all_counters);
counters = all_counters;
}
else
counters = context->counters;
if (sort_compare_func)
counters = g_list_sort_with_data (counters, sort_compare_func, data);
for (l = counters; l != NULL; l = l->next)
callback (l->data, data);
g_list_free (all_counters);
}
static void
gxi_sort_ambiguous_list (GncXmlImportData *data)
{
data->ambiguous_list = g_list_sort_with_data (
data->ambiguous_list, (GCompareDataFunc) ambiguous_cmp, data);
}
static void
gum_sanity_checker_print_block_leaks_summary (GumSanityChecker * self,
GList * block_groups)
{
GList * groups, * cur;
groups = g_list_copy (block_groups);
groups = g_list_sort_with_data (groups,
gum_sanity_checker_compare_groups, self);
gum_sanity_checker_print (self, "\tCount\tSize\n");
gum_sanity_checker_print (self, "\t-----\t----\n");
for (cur = groups; cur != NULL; cur = cur->next)
{
GumAllocationGroup * group = (GumAllocationGroup *) cur->data;
if (group->alive_now == 0)
continue;
gum_sanity_checker_printf (self, "\t%u\t%u\n",
group->alive_now, group->size);
}
g_list_free (groups);
}
static void
gum_sanity_checker_print_instance_leaks_details (GumSanityChecker * self,
GList * stale)
{
GList * instances, * cur;
instances = g_list_copy (stale);
instances = g_list_sort_with_data (instances,
gum_sanity_checker_compare_instances, self);
gum_sanity_checker_print (self, "\tAddress\t\tRefCount\tGType\n");
gum_sanity_checker_print (self, "\t--------\t--------\t-----\n");
for (cur = instances; cur != NULL; cur = cur->next)
{
GumInstanceDetails details;
gum_sanity_checker_details_from_instance (self, &details, cur->data);
gum_sanity_checker_printf (self, "\t%p\t%d%s\t%s\n",
details.address,
details.ref_count,
details.ref_count <= 9 ? "\t" : "",
details.type_name);
}
g_list_free (instances);
}
static void
gum_sanity_checker_print_instance_leaks_summary (GumSanityChecker * self,
GList * stale)
{
GHashTable * count_by_type;
GList * cur, * keys;
count_by_type = gum_sanity_checker_count_leaks_by_type_name (self, stale);
keys = g_hash_table_get_keys (count_by_type);
keys = g_list_sort_with_data (keys,
gum_sanity_checker_compare_type_names, count_by_type);
gum_sanity_checker_print (self, "\tCount\tGType\n");
gum_sanity_checker_print (self, "\t-----\t-----\n");
for (cur = keys; cur != NULL; cur = cur->next)
{
const gchar * type_name = (const gchar *) cur->data;
guint count;
count = GPOINTER_TO_UINT (g_hash_table_lookup (count_by_type,
type_name));
gum_sanity_checker_printf (self, "\t%u\t%s\n", count, type_name);
}
g_list_free (keys);
g_hash_table_unref (count_by_type);
}
node_t *
clone_color(resource_t *rsc, node_t *prefer, pe_working_set_t *data_set)
{
GListPtr nodes = NULL;
clone_variant_data_t *clone_data = NULL;
get_clone_variant_data(clone_data, rsc);
if (is_not_set(rsc->flags, pe_rsc_provisional)) {
return NULL;
} else if (is_set(rsc->flags, pe_rsc_allocating)) {
pe_rsc_debug(rsc, "Dependency loop detected involving %s", rsc->id);
return NULL;
}
if (is_set(rsc->flags, pe_rsc_promotable)) {
apply_master_prefs(rsc);
}
set_bit(rsc->flags, pe_rsc_allocating);
pe_rsc_trace(rsc, "Processing %s", rsc->id);
/* this information is used by sort_clone_instance() when deciding in which
* order to allocate clone instances
*/
for (GListPtr gIter = rsc->rsc_cons; gIter != NULL; gIter = gIter->next) {
rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data;
pe_rsc_trace(rsc, "%s: Coloring %s first", rsc->id, constraint->rsc_rh->id);
constraint->rsc_rh->cmds->allocate(constraint->rsc_rh, prefer, data_set);
}
for (GListPtr gIter = rsc->rsc_cons_lhs; gIter != NULL; gIter = gIter->next) {
rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data;
rsc->allowed_nodes =
constraint->rsc_lh->cmds->merge_weights(constraint->rsc_lh, rsc->id, rsc->allowed_nodes,
constraint->node_attribute,
(float)constraint->score / INFINITY,
(pe_weights_rollback | pe_weights_positive));
}
dump_node_scores(show_scores ? 0 : scores_log_level, rsc, __FUNCTION__, rsc->allowed_nodes);
nodes = g_hash_table_get_values(rsc->allowed_nodes);
nodes = sort_nodes_by_weight(nodes, NULL, data_set);
rsc->children = g_list_sort_with_data(rsc->children, sort_clone_instance, data_set);
distribute_children(rsc, rsc->children, nodes, clone_data->clone_max, clone_data->clone_node_max, data_set);
g_list_free(nodes);
if (is_set(rsc->flags, pe_rsc_promotable)) {
color_promotable(rsc, data_set);
}
clear_bit(rsc->flags, pe_rsc_provisional);
clear_bit(rsc->flags, pe_rsc_allocating);
pe_rsc_trace(rsc, "Done allocating %s", rsc->id);
return NULL;
}
void fs_queue_sort(fs_queue *queue, GCompareDataFunc compare_func,
void * user_data) {
g_return_if_fail(queue != NULL );
g_return_if_fail(compare_func != NULL );
queue->head = g_list_sort_with_data(queue->head, compare_func, user_data);
queue->tail = g_list_last(queue->head);
}
GList *
nautilus_sort_columns (GList *columns,
char **column_order)
{
return g_list_sort_with_data (columns,
(GCompareDataFunc)column_compare,
column_order);
}
GList *
glade_gtk_action_bar_get_children (GladeWidgetAdaptor * adaptor,
GObject * container)
{
GList *children;
children = GWA_GET_CLASS (GTK_TYPE_CONTAINER)->get_children (adaptor, container);
return g_list_sort_with_data (children, (GCompareDataFunc) sort_children, container);
}
GList *
nemo_sort_columns (GList *columns,
char **column_order)
{
if (!column_order) {
return NULL;
}
return g_list_sort_with_data (columns,
(GCompareDataFunc)column_compare,
column_order);
}
static void
print_timers (UProfContext *context)
{
GList *root_timers;
GList *l;
root_timers = uprof_context_get_root_timer_results ();
root_timers =
g_list_sort_with_data (context->root_timers,
(GCompareDataFunc)_uprof_timer_compare_total_times,
NULL);
for (l = context->timers; l != NULL; l = l->next)
{
UProfTimerState *timer = l->data;
timer->children =
g_list_sort_with_data (timer->children,
(GCompareDataFunc)
_uprof_timer_compare_total_times,
NULL);
}
}
void
uprof_context_foreach_timer (UProfContext *context,
GCompareDataFunc sort_compare_func,
UProfTimerResultCallback callback,
void * data)
{
GList *l;
GList *timers;
GList *all_timers = NULL;
g_return_if_fail (context != NULL);
g_return_if_fail (callback != NULL);
#ifdef DEBUG_TIMER_HEIRACHY
g_print ("uprof_context_foreach_timer (context = %s):\n",
context->name);
#endif
/* If the context has been linked with other contexts, then we want
* a flat list of timers we can sort...
*
* XXX: If for example there are 3 contexts A, B and C where A and B
* are linked and then C is linked to A and B then we are careful
* not to duplicate the timers of C twice.
*/
/* XXX: may want a dirty flag mechanism to avoid repeating this
* too often! */
if (context->links)
{
_uprof_context_for_self_and_links_recursive (context,
copy_timers_list_cb,
&all_timers);
timers = all_timers;
}
else
timers = context->timers;
#ifdef DEBUG_TIMER_HEIRACHY
g_print (" all combined timers:\n");
for (l = timers; l != NULL; l = l->next)
g_print (" timer->name: %s\n", ((UProfObjectState *)l->data)->name);
#endif
if (sort_compare_func)
timers = g_list_sort_with_data (timers, sort_compare_func, data);
for (l = timers; l != NULL; l = l->next)
callback (l->data, data);
g_list_free (all_timers);
}
static void
gum_sanity_checker_print_block_leaks_details (GumSanityChecker * self,
GList * stale)
{
GList * blocks, * cur;
blocks = g_list_copy (stale);
blocks = g_list_sort_with_data (blocks,
gum_sanity_checker_compare_blocks, self);
gum_sanity_checker_print (self, "\tAddress\t\tSize\n");
gum_sanity_checker_print (self, "\t--------\t----\n");
for (cur = blocks; cur != NULL; cur = cur->next)
{
GumAllocationBlock * block = (GumAllocationBlock *) cur->data;
guint i;
gum_sanity_checker_printf (self, "\t%p\t%u\n",
block->address, block->size);
for (i = 0; i != block->return_addresses.len; i++)
{
GumReturnAddress addr = block->return_addresses.items[i];
GumReturnAddressDetails rad;
if (gum_return_address_details_from_address (addr, &rad))
{
gchar * file_basename;
file_basename = g_path_get_basename (rad.file_name);
gum_sanity_checker_printf (self, "\t %p %s!%s %s:%u\n",
rad.address,
rad.module_name, rad.function_name,
file_basename, rad.line_number);
g_free (file_basename);
}
else
{
gum_sanity_checker_printf (self, "\t %p\n", addr);
}
}
}
g_list_free (blocks);
}
static gboolean
query_completed_cb (GcalShellSearchProvider *search_provider,
GcalManager *manager)
{
GcalShellSearchProviderPrivate *priv = search_provider->priv;
GList *events, *l;
GVariantBuilder builder;
time_t current_time_t;
g_hash_table_remove_all (priv->events);
events = gcal_manager_get_shell_search_events (priv->manager);
if (events == NULL)
{
g_dbus_method_invocation_return_value (priv->pending_search->invocation, g_variant_new ("(as)", NULL));
goto out;
}
g_variant_builder_init (&builder, G_VARIANT_TYPE ("as"));
current_time_t = time (NULL);
events = g_list_sort_with_data (events, (GCompareDataFunc) sort_event_data, ¤t_time_t);
for (l = events; l != NULL; l = g_list_next (l))
{
const gchar *uid;
uid = gcal_event_get_uid (l->data);
if (g_hash_table_contains (priv->events, uid))
continue;
g_variant_builder_add (&builder, "s", uid);
g_hash_table_insert (priv->events, g_strdup (uid), l->data);
}
g_list_free (events);
g_dbus_method_invocation_return_value (priv->pending_search->invocation, g_variant_new ("(as)", &builder));
out:
g_object_unref (priv->pending_search->invocation);
g_strfreev (priv->pending_search->terms);
g_clear_pointer (&(priv->pending_search), g_free);
g_application_release (g_application_get_default ());
return FALSE;
}
static void
search_panel_propagate_sort_order (CcSearchPanel *self)
{
GList *keys, *l;
GPtrArray *sort_order;
sort_order = g_ptr_array_new ();
keys = g_hash_table_get_keys (self->priv->sort_order);
keys = g_list_sort_with_data (keys, propagate_compare_func, self);
for (l = keys; l != NULL; l = l->next)
g_ptr_array_add (sort_order, l->data);
g_ptr_array_add (sort_order, NULL);
g_settings_set_strv (self->priv->search_settings, "sort-order",
(const gchar **) sort_order->pdata);
g_ptr_array_unref (sort_order);
g_list_free (keys);
}
static void
gnc_prefs_sort_pages (GtkNotebook *notebook)
{
gint n_pages, i;
GList *tabs = NULL, *iter = NULL;
g_return_if_fail (GTK_IS_NOTEBOOK (notebook));
/* gather tabs */
n_pages = gtk_notebook_get_n_pages (notebook);
for (i = n_pages - 1; i >= 0; i--)
tabs = g_list_prepend (tabs, gtk_notebook_get_nth_page (notebook, i));
/* sort in local copy */
tabs = g_list_sort_with_data (tabs, (GCompareDataFunc) tab_cmp, notebook);
/* reorder tabs */
for (i = 0, iter = tabs; iter; i++, iter = iter->next)
gtk_notebook_reorder_child (notebook, GTK_WIDGET (iter->data), i);
g_list_free (tabs);
}
/**
* gtk_test_find_sibling:
* @base_widget: Valid widget, part of a widget hierarchy
* @widget_type: Type of a aearched for sibling widget
*
* This function will search siblings of @base_widget and siblings of its
* ancestors for all widgets matching @widget_type.
* Of the matching widgets, the one that is geometrically closest to
* @base_widget will be returned.
* The general purpose of this function is to find the most likely "action"
* widget, relative to another labeling widget. Such as finding a
* button or text entry widget, given its corresponding label widget.
*
* Returns: (transfer none): a widget of type @widget_type if any is found.
*
* Since: 2.14
**/
GtkWidget*
gtk_test_find_sibling (GtkWidget *base_widget,
GType widget_type)
{
GList *siblings = NULL;
GtkWidget *tmpwidget = base_widget;
gpointer data[2];
/* find all sibling candidates */
while (tmpwidget)
{
tmpwidget = gtk_widget_get_parent (tmpwidget);
siblings = g_list_concat (siblings, test_list_descendants (tmpwidget, widget_type));
}
/* sort them by distance to base_widget */
data[0] = gtk_widget_get_toplevel (base_widget);
data[1] = base_widget;
siblings = g_list_sort_with_data (siblings, widget_geo_cmp, data);
/* pick nearest != base_widget */
siblings = g_list_remove (siblings, base_widget);
tmpwidget = siblings ? siblings->data : NULL;
g_list_free (siblings);
return tmpwidget;
}
static void fill_in_presets(GtkWidget *combo)
{
GList *items;
GList *preset;
preset = preset_list;
items = NULL;
while (preset)
{
items = g_list_append(items, preset->data);
preset = g_list_next(preset);
}
if (!items)
items = g_list_append(items, "");
/* sort via strcmp() */
items = g_list_sort_with_data(items, (GCompareDataFunc)strcmp, NULL);
gtk_combo_set_popdown_strings(GTK_COMBO(combo), items);
g_list_free(items);
}
void
mex_column_set_sort_func (MexColumn *column,
MexActorSortFunc func,
gpointer userdata)
{
MexColumnPrivate *priv;
g_return_if_fail (MEX_IS_COLUMN (column));
priv = column->priv;
if ((priv->sort_func != func) || (priv->sort_data != userdata))
{
priv->sort_func = func;
priv->sort_data = userdata;
if (func)
{
priv->children = g_list_sort_with_data (priv->children,
(GCompareDataFunc)func,
userdata);
clutter_actor_queue_relayout (CLUTTER_ACTOR (column));
}
}
}
GList *dt_get_papers(const dt_printer_info_t *printer)
{
const char *printer_name = printer->name;
GList *result = NULL;
#if ((CUPS_VERSION_MAJOR == 1) && (CUPS_VERSION_MINOR >= 7)) || CUPS_VERSION_MAJOR > 1
#if defined(__APPLE__) && MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_9
if (cupsConnectDest != NULL && cupsCopyDestInfo != NULL && cupsGetDestMediaCount != NULL &&
cupsGetDestMediaByIndex != NULL && cupsFreeDestInfo != NULL)
#endif
{
cups_dest_t *dests;
int num_dests = cupsGetDests(&dests);
cups_dest_t *dest = cupsGetDest(printer_name, NULL, num_dests, dests);
int cancel = 0; // important
char resource[1024];
if (dest)
{
http_t *hcon = cupsConnectDest(dest, 0, 2000, &cancel, resource, sizeof(resource), NULL, (void *)NULL);
if (hcon)
{
cups_size_t size;
cups_dinfo_t *info = cupsCopyDestInfo (hcon, dest);
const int count = cupsGetDestMediaCount(hcon, dest, info, CUPS_MEDIA_FLAGS_DEFAULT);
for (int k=0; k<count; k++)
{
if (cupsGetDestMediaByIndex(hcon, dest, info, k, CUPS_MEDIA_FLAGS_DEFAULT, &size))
{
if (size.width!=0 && size.length!=0 && !paper_exists(result, size.media))
{
pwg_media_t *med = pwgMediaForPWG (size.media);
char common_name[MAX_NAME] = { 0 };
if (med->ppd)
g_strlcpy(common_name, med->ppd, sizeof(common_name));
else
g_strlcpy(common_name, size.media, sizeof(common_name));
dt_paper_info_t *paper = (dt_paper_info_t*)malloc(sizeof(dt_paper_info_t));
g_strlcpy(paper->name, size.media, sizeof(paper->name));
g_strlcpy(paper->common_name, common_name, sizeof(paper->common_name));
paper->width = (double)size.width / 100.0;
paper->height = (double)size.length / 100.0;
result = g_list_append (result, paper);
dt_print(DT_DEBUG_PRINT,
"[print] new media paper %4d %6.2f x %6.2f (%s) (%s)\n",
k, paper->width, paper->height, paper->name, paper->common_name);
}
}
}
cupsFreeDestInfo(info);
httpClose(hcon);
}
else
dt_print(DT_DEBUG_PRINT, "[print] cannot connect to printer %s (cancel=%d)\n", printer_name, cancel);
}
cupsFreeDests(num_dests, dests);
}
#endif
// check now PPD page sizes
const char *PPDFile = cupsGetPPD(printer_name);
ppd_file_t *ppd = ppdOpenFile(PPDFile);
if (ppd)
{
ppd_size_t *size = ppd->sizes;
for (int k=0; k<ppd->num_sizes; k++)
{
if (size->width!=0 && size->length!=0 && !paper_exists(result, size->name))
{
dt_paper_info_t *paper = (dt_paper_info_t*)malloc(sizeof(dt_paper_info_t));
g_strlcpy(paper->name, size->name, MAX_NAME);
g_strlcpy(paper->common_name, size->name, MAX_NAME);
paper->width = (double)dt_pdf_point_to_mm(size->width);
paper->height = (double)dt_pdf_point_to_mm(size->length);
result = g_list_append (result, paper);
dt_print(DT_DEBUG_PRINT,
"[print] new ppd paper %4d %6.2f x %6.2f (%s) (%s)\n",
k, paper->width, paper->height, paper->name, paper->common_name);
}
size++;
}
ppdClose(ppd);
g_unlink(PPDFile);
}
result = g_list_sort_with_data (result, (GCompareDataFunc)sort_papers, NULL);
return result;
}
static void
master_promotion_order(resource_t * rsc, pe_working_set_t * data_set)
{
GListPtr gIter = NULL;
node_t *node = NULL;
node_t *chosen = NULL;
clone_variant_data_t *clone_data = NULL;
get_clone_variant_data(clone_data, rsc);
if (clone_data->merged_master_weights) {
return;
}
clone_data->merged_master_weights = TRUE;
crm_trace("Merging weights for %s", rsc->id);
set_bit(rsc->flags, pe_rsc_merging);
gIter = rsc->children;
for (; gIter != NULL; gIter = gIter->next) {
resource_t *child = (resource_t *) gIter->data;
crm_trace("Sort index: %s = %d", child->id, child->sort_index);
}
dump_node_scores(LOG_DEBUG_3, rsc, "Before", rsc->allowed_nodes);
gIter = rsc->children;
for (; gIter != NULL; gIter = gIter->next) {
resource_t *child = (resource_t *) gIter->data;
chosen = child->fns->location(child, NULL, FALSE);
if (chosen == NULL || child->sort_index < 0) {
crm_trace("Skipping %s", child->id);
continue;
}
node = (node_t *) pe_hash_table_lookup(rsc->allowed_nodes, chosen->details->id);
CRM_ASSERT(node != NULL);
/* adds in master preferences and rsc_location.role=Master */
crm_trace("Adding %s to %s from %s", score2char(child->sort_index), node->details->uname,
child->id);
node->weight = merge_weights(child->sort_index, node->weight);
}
dump_node_scores(LOG_DEBUG_3, rsc, "Middle", rsc->allowed_nodes);
gIter = rsc->rsc_cons;
for (; gIter != NULL; gIter = gIter->next) {
rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data;
/* (re-)adds location preferences of resources that the
* master instance should/must be colocated with
*/
if (constraint->role_lh == RSC_ROLE_MASTER) {
crm_trace("RHS: %s with %s: %d", constraint->rsc_lh->id, constraint->rsc_rh->id,
constraint->score);
rsc->allowed_nodes =
constraint->rsc_rh->cmds->merge_weights(constraint->rsc_rh, rsc->id,
rsc->allowed_nodes,
constraint->node_attribute,
constraint->score / INFINITY,
constraint->score ==
INFINITY ? FALSE : TRUE, FALSE);
}
}
gIter = rsc->rsc_cons_lhs;
for (; gIter != NULL; gIter = gIter->next) {
rsc_colocation_t *constraint = (rsc_colocation_t *) gIter->data;
/* (re-)adds location preferences of resource that wish to be
* colocated with the master instance
*/
if (constraint->role_rh == RSC_ROLE_MASTER) {
crm_trace("LHS: %s with %s: %d", constraint->rsc_lh->id, constraint->rsc_rh->id,
constraint->score);
rsc->allowed_nodes =
constraint->rsc_lh->cmds->merge_weights(constraint->rsc_lh, rsc->id,
rsc->allowed_nodes,
constraint->node_attribute,
constraint->score / INFINITY, TRUE, TRUE);
}
}
gIter = rsc->rsc_tickets;
for (; gIter != NULL; gIter = gIter->next) {
rsc_ticket_t *rsc_ticket = (rsc_ticket_t *) gIter->data;
if (rsc_ticket->role_lh == RSC_ROLE_MASTER && rsc_ticket->ticket->granted == FALSE) {
resource_location(rsc, NULL, -INFINITY, "__stateful_without_ticket__", data_set);
}
}
dump_node_scores(LOG_DEBUG_3, rsc, "After", rsc->allowed_nodes);
/* write them back and sort */
gIter = rsc->children;
for (; gIter != NULL; gIter = gIter->next) {
resource_t *child = (resource_t *) gIter->data;
chosen = child->fns->location(child, NULL, FALSE);
if (is_not_set(child->flags, pe_rsc_managed) && child->next_role == RSC_ROLE_MASTER) {
child->sort_index = INFINITY;
} else if (chosen == NULL || child->sort_index < 0) {
crm_trace("%s: %d", child->id, child->sort_index);
} else {
node = (node_t *) pe_hash_table_lookup(rsc->allowed_nodes, chosen->details->id);
CRM_ASSERT(node != NULL);
child->sort_index = node->weight;
}
crm_trace("Set sort index: %s = %d", child->id, child->sort_index);
}
rsc->children = g_list_sort_with_data(rsc->children, sort_master_instance, data_set);
clear_bit(rsc->flags, pe_rsc_merging);
}
GList *sortWords(GHashTable *map)
{
GList *words = g_hash_table_get_keys(map);
GList *sorted_words = g_list_sort_with_data(words, (GCompareDataFunc) get_freq, (gpointer) map);
return sorted_words;
}
GRegex *filter_regex = NULL;
selector->populate_liststore_is_idle = FALSE;
DEBUG_SELECTOR_TIMER_DECL
DEBUG_SELECTOR_TIMER_NEW
gtk_list_store_clear (selector->liststore);
selector_store = selector->selector_store;
filter = gedit_open_document_selector_store_get_filter (selector_store);
if (filter && *filter != '\0')
{
DEBUG_SELECTOR (g_print ("Selector(%p): populate liststore: all lists\n", selector););
filter_items = fileitem_list_filter (selector->all_items, (const gchar *)filter);
filter_items = g_list_sort_with_data (filter_items, (GCompareDataFunc)sort_items_by_mru, NULL);
fileitem_list_remove_duplicates (filter_items);
filter_regex = g_regex_new (filter, G_REGEX_CASELESS, 0, NULL);
}
else
{
gint recent_limit;
GList *recent_items;
DEBUG_SELECTOR (g_print ("Selector(%p): populate liststore: recent files list\n", selector););
recent_limit = gedit_open_document_selector_store_get_recent_limit (selector_store);
if (recent_limit > 0 )
{
int main(int argc, char** argv)
{
GSList *l1, *l2;
GList *tri1, *tri2;
int np1 = 0, np2 = 0;
struct point *pt1, *pt2;
//struct triangle_pair *t;
int i;
double width, height, e1, e2;
int discarded;
GList *tp, *tmp;
int np, nm;
l1 = read_star_list ((argc > 1) ? argv[1] : "starf1.list", &width, &height);
e1 = POS_EPSILON * MAX(width, height);
l2 = read_star_list ((argc > 2) ? argv[2] : "starf2.list", &width, &height);
e2 = POS_EPSILON * MAX(width, height);
//printf("e1 %lf, e2 %lf\n", e1, e2);
/* a) select points to be matched */
pt1 = filter_point_list (l1, &np1, e1);
pt2 = filter_point_list (l2, &np2, e2);
//printf("got %d, %d points\n", np1, np2);
/* b) generate triangle lists */
tri1 = generate_triangles (pt1, np1, e1);
tri2 = generate_triangles (pt2, np2, e2);
printf("got %d, %d triangles\n", g_list_length(tri1), g_list_length(tri2));
/* c) triangle match */
/* sort in increasing order of ratio and determine max ratio tolerance */
double rtol1 = 0.0, rtol2 = 0.0, maxtol;
tri1 = g_list_sort_with_data (tri1, (GCompareDataFunc) ratio_compare, &rtol1);
tri2 = g_list_sort_with_data (tri2, (GCompareDataFunc) ratio_compare, &rtol2);
maxtol = rtol1 + rtol2;
//print_triangle_list(pt1, tri1);
//print_triangle_list(pt2, tri2);
/* match the triangles */
GList *tripairs = match_triangles(tri1, tri2);
printf("got %d tripairs\n", g_list_length(tripairs));
//print_triangle_pairs(pt1, pt2, tripairs);
i = 0; discarded = 1;
while (discarded && i < MAX_LOGM_ITER) {
double avg, stdev, f = 0;
np = 0; nm = 0;
avg = 0.0;
for (tp = tripairs; tp; tp = g_list_next(tp)) {
struct triangle_pair *t = tp->data;
//printf("delta log P %lf\n", t->t1->logP - t->t2->logP);
avg += t->t1->logP - t->t2->logP;
if (t->t1->clockwise == t->t2->clockwise)
np++;
else
nm++;
}
avg /= (nm + np);
stdev = 0.0;
for (tp = tripairs; tp; tp = g_list_next(tp)) {
struct triangle_pair *t = tp->data;
stdev += sqr(t->t1->logP - t->t2->logP - avg);
}
stdev = sqrt(stdev / (nm + np));
int mt = abs(np - nm);
int mf = np + nm - mt;
if (mf > mt)
f = 1.0;
else if (0.1 * mt > 1.0 * mf)
f = 3.0;
else
f = 2.0;
printf("iter %3d, avg %lf, stdev %lf, n+ %5d, n- %5d, factor %lf\n", i, avg, stdev, np, nm, f);
discarded = 0;
for (tp = tripairs; tp; ) {
struct triangle_pair *t = tp->data;
if (fabs(t->t1->logP - t->t2->logP - avg) > f * stdev) {
discarded = 1;
tmp = tp->next;
tripairs = g_list_delete_link (tripairs, tp);
tp = tmp;
continue;
}
tp = g_list_next(tp);
}
i++;
}
if (discarded) {
printf("failed\n");
}
for (tp = tripairs; tp; ) {
struct triangle_pair *t = tp->data;
if ((np > nm && t->t1->clockwise != t->t2->clockwise) ||
(nm > np && t->t1->clockwise == t->t2->clockwise)) {
tmp = tp->next;
tripairs = g_list_delete_link (tripairs, tp);
tp = tmp;
continue;
}
tp = g_list_next(tp);
}
#if 0
for (tp = tripairs; tp; tp = g_list_next(tp)) {
struct triangle_pair *t = tp->data;
printf("%d %d\n", pt1[t->t1->v[0]].id, pt2[t->t2->v[0]].id);
printf("%d %d\n", pt1[t->t1->v[1]].id, pt2[t->t2->v[1]].id);
printf("%d %d\n", pt1[t->t1->v[2]].id, pt2[t->t2->v[2]].id);
}
#endif
print_triangle_pairs(pt1, pt2, tripairs);
printf("rtol1 = %lf, rtol2 = %lf, %d matches\n", rtol1, rtol2, g_list_length(tripairs));
return 0;
}
static gboolean
st_container_navigate_focus (StWidget *widget,
ClutterActor *from,
GtkDirectionType direction)
{
StContainer *container = ST_CONTAINER (widget);
ClutterActor *container_actor, *focus_child;
GList *children, *l;
container_actor = CLUTTER_ACTOR (widget);
if (from == container_actor)
return FALSE;
/* Figure out if @from is a descendant of @container, and if so,
* set @focus_child to the immediate child of @container that
* contains (or *is*) @from.
*/
focus_child = from;
while (focus_child && clutter_actor_get_parent (focus_child) != container_actor)
focus_child = clutter_actor_get_parent (focus_child);
if (st_widget_get_can_focus (widget))
{
if (!focus_child)
{
/* Accept focus from outside */
clutter_actor_grab_key_focus (container_actor);
return TRUE;
}
else
{
/* Yield focus from within: since @container itself is
* focusable we don't allow the focus to be navigated
* within @container.
*/
return FALSE;
}
}
/* See if we can navigate within @focus_child */
if (focus_child && ST_IS_WIDGET (focus_child))
{
if (st_widget_navigate_focus (ST_WIDGET (focus_child), from, direction, FALSE))
return TRUE;
}
/* At this point we know that we want to navigate focus to one of
* @container's immediate children; the next one after @focus_child,
* or the first one if @focus_child is %NULL. (With "next" and
* "first" being determined by @direction.)
*/
children = st_container_get_focus_chain (container);
if (direction == GTK_DIR_TAB_FORWARD ||
direction == GTK_DIR_TAB_BACKWARD)
{
if (direction == GTK_DIR_TAB_BACKWARD)
children = g_list_reverse (children);
if (focus_child)
{
/* Remove focus_child and any earlier children */
while (children && children->data != focus_child)
children = g_list_delete_link (children, children);
if (children)
children = g_list_delete_link (children, children);
}
}
else /* direction is an arrow key, not tab */
{
StContainerChildSortData sort_data;
/* Compute the allocation box of the previous focused actor, in
* @container's coordinate space. If there was no previous focus,
* use the coordinates of the appropriate edge of @container.
*
* Note that all of this code assumes the actors are not
* transformed (or at most, they are all scaled by the same
* amount). If @container or any of its children is rotated, or
* any child is inconsistently scaled, then the focus chain will
* probably be unpredictable.
*/
if (focus_child)
{
clutter_actor_get_allocation_box (focus_child, &sort_data.box);
}
else
{
clutter_actor_get_allocation_box (CLUTTER_ACTOR (container), &sort_data.box);
switch (direction)
{
case GTK_DIR_UP:
sort_data.box.y1 = sort_data.box.y2;
break;
case GTK_DIR_DOWN:
sort_data.box.y2 = sort_data.box.y1;
break;
case GTK_DIR_LEFT:
sort_data.box.x1 = sort_data.box.x2;
break;
case GTK_DIR_RIGHT:
sort_data.box.x2 = sort_data.box.x1;
break;
default:
g_warn_if_reached ();
}
}
sort_data.direction = direction;
if (focus_child)
children = filter_by_position (children, &sort_data.box, direction);
if (children)
children = g_list_sort_with_data (children, sort_by_position, &sort_data);
}
/* Now try each child in turn */
for (l = children; l; l = l->next)
{
if (ST_IS_WIDGET (l->data))
{
if (st_widget_navigate_focus (l->data, from, direction, FALSE))
{
g_list_free (children);
return TRUE;
}
}
}
g_list_free (children);
return FALSE;
}
/*!
\brief populate_dlog_choices_pf() is called when the datalogging tab is loaded
by glade AFTER the realtime variable definitions have been loaded and
processed. All of the logable variables are then placed here for user
selecting during datalogging.
*/
G_MODULE_EXPORT void populate_dlog_choices(void)
{
guint i,j,k;
GList *list = NULL;
GtkWidget *vbox = NULL;
GtkWidget *table = NULL;
GtkWidget *button = NULL;
GtkWidget *label = NULL;
gint table_rows = 0;
gconstpointer * object = NULL;
gchar * dlog_name = NULL;
gchar * tooltip = NULL;
Rtv_Map *rtv_map = NULL;
ENTER();
rtv_map = (Rtv_Map *)DATA_GET(global_data,"rtv_map");
if (DATA_GET(global_data,"leaving"))
{
EXIT();
return;
}
if (!((DATA_GET(global_data,"connected")) &&
(DATA_GET(global_data,"interrogated"))))
{
EXIT();
return;
}
if (!DATA_GET(global_data,"rtvars_loaded"))
{
MTXDBG(CRITICAL,_("CRITICAL ERROR, Realtime Variable definitions are NOT LOADED!!!\n"));
EXIT();
return;
}
set_title(g_strdup(_("Populating Datalogger...")));
vbox = lookup_widget("dlog_logable_vars_vbox1");
if (!GTK_IS_WIDGET(vbox))
{
printf(_("datalogger windows not present, returning\n"));
EXIT();
return;
}
table_rows = ceil((float)rtv_map->derived_total/(float)TABLE_COLS);
table = gtk_table_new(table_rows,TABLE_COLS,FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table),0);
gtk_table_set_col_spacings(GTK_TABLE(table),0);
gtk_container_set_border_width(GTK_CONTAINER(table),0);
gtk_box_pack_start(GTK_BOX(vbox),table,TRUE,TRUE,0);
/* Update status of the delimiter buttons... */
switch ((GINT)DATA_GET(global_data,"preferred_delimiter"))
{
case COMMA:
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(lookup_widget("dlog_comma_delimit_radio_button")),TRUE);
gtk_toggle_button_toggled(GTK_TOGGLE_BUTTON(lookup_widget("dlog_comma_delimit_radio_button")));
break;
case TAB:
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(lookup_widget("dlog_tab_delimit_radio_button")),TRUE);
gtk_toggle_button_toggled(GTK_TOGGLE_BUTTON(lookup_widget("dlog_tab_delimit_radio_button")));
break;
default:
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(lookup_widget("dlog_comma_delimit_radio_button")),TRUE);
gtk_toggle_button_toggled(GTK_TOGGLE_BUTTON(lookup_widget("dlog_comma_delimit_radio_button")));
break;
}
j = 0;
k = 0;
/* Put into GList and sort it */
for (i=0;i<rtv_map->derived_total;i++)
list = g_list_prepend(list,(gpointer)g_ptr_array_index(rtv_map->rtv_list,i));
list = g_list_sort_with_data(list,list_object_sort,(gpointer)"dlog_gui_name");
for (i=0;i<rtv_map->derived_total;i++)
{
tooltip = NULL;
dlog_name = NULL;
//object = g_ptr_array_index(rtv_map->rtv_list,i);
object = (gconstpointer *)g_list_nth_data(list,i);
dlog_name = (gchar *)DATA_GET(object,"dlog_gui_name");
button = gtk_check_button_new();
label = gtk_label_new(NULL);
gtk_label_set_markup(GTK_LABEL(label),dlog_name);
gtk_container_add(GTK_CONTAINER(button),label);
tooltip = (gchar *)(DATA_GET(object,"tooltip"));
if (tooltip)
gtk_widget_set_tooltip_text(button,tooltip);
/* Bind button to the object, Done so that we can set the state
* of the buttons from elsewhere...
*/
DATA_SET(object,"dlog_button",(gpointer)button);
/* Bind object to the button */
OBJ_SET(button,"object",(gpointer)object);
g_signal_connect(G_OBJECT(button),"toggled",
G_CALLBACK(log_value_set),
NULL);
if ((GINT)DATA_GET(object,"log_by_default") == 1)
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button),TRUE);
gtk_table_attach (GTK_TABLE (table), button, j, j+1, k, k+1,
(GtkAttachOptions) (GTK_EXPAND|GTK_FILL|GTK_SHRINK),
(GtkAttachOptions) (GTK_FILL|GTK_SHRINK),
//(GtkAttachOptions) (GTK_FILL|GTK_SHRINK),
//(GtkAttachOptions) (GTK_FILL|GTK_SHRINK),
0, 0);
j++;
if (j == TABLE_COLS)
{
k++;
j = 0;
}
}
g_list_free(list);
gtk_widget_show_all(vbox);
set_title(g_strdup(_("Datalogger Ready...")));
EXIT();
return;
}
void
dacp_share_ctrl_int (DMAPShare * share,
SoupServer * server,
SoupMessage * message,
const char *path,
GHashTable * query, SoupClientContext * context)
{
const char *rest_of_path;
DACPShare *dacp_share = DACP_SHARE (share);
g_debug ("Path is %s.", path);
if (query) {
g_hash_table_foreach (query, debug_param, NULL);
}
rest_of_path = strchr (path + 1, '/');
/* If calling /ctrl-int without args, the client doesnt need a
* session-id, otherwise it does and it should be validated. */
if ((rest_of_path != NULL)
&&
(!_dmap_share_session_id_validate
(share, context, message, query, NULL))) {
soup_message_set_status (message, SOUP_STATUS_FORBIDDEN);
return;
}
if (rest_of_path == NULL) {
/* CACI control-int
* MSTT status
* MUTY update type
* MTCO specified total count
* MRCO returned count
* MLCL listing
* MLIT listing item
* MIID item id
* CMIK Unknown (TRUE)
* CMSP Unknown (TRUE)
* CMSV Unknown (TRUE)
* CASS Unknown (TRUE)
* CASU Unknown (TRUE)
* CASG Unknown (TRUE)
*/
GNode *caci;
GNode *mlcl;
GNode *mlit;
// dacp.controlint
caci = dmap_structure_add (NULL, DMAP_CC_CACI);
// dmap.status
dmap_structure_add (caci, DMAP_CC_MSTT,
(gint32) DMAP_STATUS_OK);
// dmap.updatetype
dmap_structure_add (caci, DMAP_CC_MUTY, 0);
// dmap.specifiedtotalcount
dmap_structure_add (caci, DMAP_CC_MTCO, (gint32) 1);
// dmap.returnedcount
dmap_structure_add (caci, DMAP_CC_MRCO, (gint32) 1);
// dmap.listing
mlcl = dmap_structure_add (caci, DMAP_CC_MLCL);
// dmap.listingitem
mlit = dmap_structure_add (mlcl, DMAP_CC_MLIT);
// dmap.itemid
dmap_structure_add (mlit, DMAP_CC_MIID, (gint32) 1);
// Unknown (TRUE)
dmap_structure_add (mlit, DMAP_CC_CMIK, (gint32) 1);
// Unknown (TRUE)
dmap_structure_add (mlit, DMAP_CC_CMSP, (gint32) 1);
// Unknown (TRUE)
dmap_structure_add (mlit, DMAP_CC_CMSV, (gint32) 1);
// Unknown (TRUE)
dmap_structure_add (mlit, DMAP_CC_CASS, (gint32) 1);
// Unknown (TRUE)
dmap_structure_add (mlit, DMAP_CC_CASU, (gint32) 1);
// Unknown (TRUE)
dmap_structure_add (mlit, DMAP_CC_CASG, (gint32) 1);
_dmap_share_message_set_from_dmap_structure (share, message,
caci);
dmap_structure_destroy (caci);
} else if (g_ascii_strcasecmp ("/1/getproperty", rest_of_path) == 0) {
gchar *properties_query, **properties, **property;
GNode *cmgt;
properties_query = g_hash_table_lookup (query, "properties");
if (!properties_query) {
g_warning ("No property specified");
return;
}
cmgt = dmap_structure_add (NULL, DMAP_CC_CMGT);
dmap_structure_add (cmgt, DMAP_CC_MSTT, DMAP_STATUS_OK);
properties = g_strsplit (properties_query, ",", -1);
for (property = properties; *property; property++) {
if (g_ascii_strcasecmp (*property, "dmcp.volume") ==
0) {
gulong volume;
g_object_get (dacp_share->priv->player,
"volume", &volume, NULL);
//g_debug ("Sending volume: %lu", volume);
dmap_structure_add (cmgt, DMAP_CC_CMVO,
volume);
} else {
g_warning ("Unhandled property %s",
*property);
}
}
g_strfreev (properties);
_dmap_share_message_set_from_dmap_structure (share, message,
cmgt);
dmap_structure_destroy (cmgt);
} else if (g_ascii_strcasecmp ("/1/setproperty", rest_of_path) == 0) {
if (g_hash_table_lookup (query, "dmcp.volume")) {
gdouble volume =
strtod (g_hash_table_lookup
(query, "dmcp.volume"), NULL);
g_object_set (dacp_share->priv->player, "volume",
(gulong) volume, NULL);
}
soup_message_set_status (message, SOUP_STATUS_NO_CONTENT);
} else if (g_ascii_strcasecmp ("/1/getspeakers", rest_of_path) == 0) {
GNode *casp;
casp = dmap_structure_add (NULL, DMAP_CC_CASP);
dmap_structure_add (casp, DMAP_CC_MSTT,
(gint32) DMAP_STATUS_OK);
dmap_structure_add (casp, DMAP_CC_MDCL);
dmap_structure_add (casp, DMAP_CC_CAIA, TRUE);
dmap_structure_add (casp, DMAP_CC_MINM, "Computer");
dmap_structure_add (casp, DMAP_CC_MSMA, (gint32) 0);
_dmap_share_message_set_from_dmap_structure (share, message,
casp);
dmap_structure_destroy (casp);
} else if (g_ascii_strcasecmp ("/1/playstatusupdate", rest_of_path) ==
0) {
gchar *revision =
g_hash_table_lookup (query, "revision-number");
gint revision_number = atoi (revision);
if (revision_number >= dacp_share->priv->current_revision) {
g_object_ref (message);
dacp_share->priv->update_queue =
g_slist_prepend (dacp_share->
priv->update_queue, message);
g_signal_connect_object (message, "finished",
G_CALLBACK
(status_update_message_finished),
dacp_share, 0);
soup_server_pause_message (server, message);
} else {
dacp_share_fill_playstatusupdate (dacp_share,
message);
}
} else if (g_ascii_strcasecmp ("/1/playpause", rest_of_path) == 0) {
dacp_player_play_pause (dacp_share->priv->player);
soup_message_set_status (message, SOUP_STATUS_NO_CONTENT);
} else if (g_ascii_strcasecmp ("/1/pause", rest_of_path) == 0) {
dacp_player_pause (dacp_share->priv->player);
soup_message_set_status (message, SOUP_STATUS_NO_CONTENT);
} else if (g_ascii_strcasecmp ("/1/nextitem", rest_of_path) == 0) {
dacp_player_next_item (dacp_share->priv->player);
soup_message_set_status (message, SOUP_STATUS_NO_CONTENT);
} else if (g_ascii_strcasecmp ("/1/previtem", rest_of_path) == 0) {
dacp_player_prev_item (dacp_share->priv->player);
soup_message_set_status (message, SOUP_STATUS_NO_CONTENT);
} else if (g_ascii_strcasecmp ("/1/nowplayingartwork", rest_of_path)
== 0) {
guint width = 320;
guint height = 320;
gchar *artwork_filename;
gchar *buffer;
gsize buffer_len;
if (g_hash_table_lookup (query, "mw"))
width = atoi (g_hash_table_lookup (query, "mw"));
if (g_hash_table_lookup (query, "mh"))
height = atoi (g_hash_table_lookup (query, "mh"));
artwork_filename =
dacp_player_now_playing_artwork (dacp_share->
priv->player, width,
height);
if (!artwork_filename) {
g_debug ("No artwork for currently playing song");
soup_message_set_status (message,
SOUP_STATUS_NOT_FOUND);
return;
}
#ifdef HAVE_GDKPIXBUF
GdkPixbuf *artwork =
gdk_pixbuf_new_from_file_at_scale (artwork_filename,
width, height,
TRUE, NULL);
if (!artwork) {
g_debug ("Error loading image file");
g_free (artwork_filename);
soup_message_set_status (message,
SOUP_STATUS_INTERNAL_SERVER_ERROR);
return;
}
if (!gdk_pixbuf_save_to_buffer
(artwork, &buffer, &buffer_len, "png", NULL, NULL)) {
g_debug ("Error saving artwork to PNG");
g_object_unref (artwork);
g_free (artwork_filename);
soup_message_set_status (message,
SOUP_STATUS_INTERNAL_SERVER_ERROR);
return;
}
g_object_unref (artwork);
#else
if (!g_file_get_contents
(artwork_filename, &buffer, &buffer_len, NULL)) {
g_debug ("Error getting artwork data");
g_free (artwork_filename);
soup_message_set_status (message,
SOUP_STATUS_INTERNAL_SERVER_ERROR);
return;
}
#endif
g_free (artwork_filename);
soup_message_set_status (message, SOUP_STATUS_OK);
soup_message_set_response (message, "image/png",
SOUP_MEMORY_TAKE, buffer,
buffer_len);
} else if (g_ascii_strcasecmp ("/1/cue", rest_of_path) == 0) {
gchar *command;
command = g_hash_table_lookup (query, "command");
if (!command) {
g_debug ("No CUE command specified");
soup_message_set_status (message,
SOUP_STATUS_NO_CONTENT);
return;
} else if (g_ascii_strcasecmp ("clear", command) == 0) {
dacp_player_cue_clear (dacp_share->priv->player);
soup_message_set_status (message,
SOUP_STATUS_NO_CONTENT);
} else if (g_ascii_strcasecmp ("play", command) == 0) {
GNode *cacr;
gchar *record_query;
gchar *sort_by;
GHashTable *records;
GList *sorted_records;
GSList *filter_def;
DMAPDb *db;
gint index =
atoi (g_hash_table_lookup (query, "index"));
g_object_get (share, "db", &db, NULL);
record_query = g_hash_table_lookup (query, "query");
filter_def = _dmap_share_build_filter (record_query);
records = dmap_db_apply_filter (db, filter_def);
sorted_records = g_hash_table_get_values (records);
sort_by = g_hash_table_lookup (query, "sort");
if (g_strcmp0 (sort_by, "album") == 0) {
sorted_records =
g_list_sort_with_data (sorted_records,
(GCompareDataFunc)
daap_record_cmp_by_album,
db);
} else if (sort_by != NULL) {
g_warning ("Unknown sort column: %s",
sort_by);
}
dacp_player_cue_play (dacp_share->priv->player,
sorted_records, index);
g_list_free (sorted_records);
g_hash_table_unref (records);
dmap_share_free_filter (filter_def);
cacr = dmap_structure_add (NULL, DMAP_CC_CACR);
dmap_structure_add (cacr, DMAP_CC_MSTT,
DMAP_STATUS_OK);
dmap_structure_add (cacr, DMAP_CC_MIID, index);
_dmap_share_message_set_from_dmap_structure (share,
message,
cacr);
dmap_structure_destroy (cacr);
} else {
g_warning ("Unhandled cue command: %s", command);
soup_message_set_status (message,
SOUP_STATUS_NO_CONTENT);
return;
}
} else {
g_warning ("Unhandled ctrl-int command: %s", rest_of_path);
soup_message_set_status (message, SOUP_STATUS_BAD_REQUEST);
}
}
