static gboolean
pairs_floats_cache_entry_equal (const PairsFloatsCacheEntry *a,
const PairsFloatsCacheEntry *b)
{
return (a->flags == b->flags &&
value_equal (a->vx, b->vx) &&
value_equal (a->vy, b->vy));
}
static void
notify_changes (GdkX11Screen *x11_screen,
GHashTable *old_list)
{
GHashTableIter iter;
GValue *setting, *old_setting;
const char *name;
if (x11_screen->xsettings != NULL)
{
g_hash_table_iter_init (&iter, x11_screen->xsettings);
while (g_hash_table_iter_next (&iter, (gpointer *) &name, (gpointer*) &setting))
{
old_setting = old_list ? g_hash_table_lookup (old_list, name) : NULL;
if (old_setting == NULL)
gdk_xsettings_notify (x11_screen, name, GDK_SETTING_ACTION_NEW);
else if (!value_equal (setting, old_setting))
gdk_xsettings_notify (x11_screen, name, GDK_SETTING_ACTION_CHANGED);
/* remove setting from old_list */
if (old_setting != NULL)
g_hash_table_remove (old_list, name);
}
}
if (old_list != NULL)
{
/* old_list now contains only deleted settings */
g_hash_table_iter_init (&iter, old_list);
while (g_hash_table_iter_next (&iter, (gpointer *) &name, (gpointer*) &old_setting))
gdk_xsettings_notify (x11_screen, name, GDK_SETTING_ACTION_DELETED);
}
}
static gboolean
single_floats_cache_entry_equal (const SingleFloatsCacheEntry *a,
const SingleFloatsCacheEntry *b)
{
return (a->flags == b->flags &&
value_equal (a->value, b->value));
}
struct value *
search_chain(struct chain *c, struct value *f)
{
while (c != NULL) {
if (value_equal(f, &c->value))
return &c->value;
c = c->next;
}
return NULL;
}
static int
wrap_value_equal (char *a)
{
struct gdb_wrapper_arguments **args = (struct gdb_wrapper_arguments **) a;
value_ptr val1, val2;
val1 = (value_ptr) (*args)->args[0].ptr;
val2 = (value_ptr) (*args)->args[1].ptr;
(*args)->result.integer = value_equal (val1, val2);
return 1;
}
static VALUE
aryval_index(VALUE self, VALUE obj)
{
value_struct_data *data;
int i;
Data_Get_Struct(self, value_struct_data, data);
for (i = 0; i < ValueArraySize(data->value); i++) {
if (value_equal(ValueArrayItem(data->value, i), obj))
return INT2NUM(i);
}
return Qnil;
}
bool trace_tree_augment(struct trace_tree **tree, struct trace *trace, struct action *a)
{
int i, j;
struct trace_tree **t = tree;
int num_events = trace->num_events;
if((*t)->type == TT_E) {
free(*t);
*t = events_to_tree(trace->events, trace->num_events, a);
return true;
}
for(i = 0; i < num_events; i++) {
struct event *ev = trace->events + i;
struct trace_tree_T *t_T;
struct trace_tree_V *t_V;
struct trace_tree_D *t_D;
struct trace_tree_G *t_G;
switch((*t)->type) {
case TT_T:
t_T = *(struct trace_tree_T **) t;
/* ev->type == EV_T */
assert(ev->type == EV_T);
if(ev->u.t.test) {
if(t_T->t->type == TT_E) {
free(t_T->t);
t_T->t = events_to_tree(ev + 1, num_events - i - 1, a);
return true;
} else {
t = &(t_T->t);
}
} else {
if(t_T->f->type == TT_E) {
free(t_T->f);
t_T->f = events_to_tree(ev + 1, num_events - i - 1, a);
return true;
} else {
t = &(t_T->f);
}
}
break;
case TT_V:
t_V = *(struct trace_tree_V **) t;
/* ev->type == EV_R */
assert(ev->type == EV_R);
for(j = 0; j < t_V->num_branches; j++) {
if(value_equal(t_V->branches[j].value, ev->u.r.value)) {
t = &(t_V->branches[j].tree);
break;
}
}
if(j == t_V->num_branches) {
t_V->num_branches++;
*t = realloc(*t,
sizeof(struct trace_tree_V) +
t_V->num_branches * sizeof(struct trace_tree_Vb));
t_V = *(struct trace_tree_V **) t;
t_V->branches[j].value = ev->u.r.value;
t_V->branches[j].tree = events_to_tree(ev + 1, num_events - i - 1, a);
return true;
}
break;
case TT_D:
/* ev->type == EV_RE */
assert(ev->type == EV_RE);
t_D = *(struct trace_tree_D **) t;
if(t_D->t->type == TT_E) {
free(t_D->t);
t_D->t = events_to_tree(ev + 1, num_events - i - 1, a);
return true;
} else {
t = &(t_D->t);
}
break;
case TT_G:
/* ev->type == EV_G */
assert(ev->type == EV_G);
t_G = *(struct trace_tree_G **) t;
if(t_G->t->type == TT_E) {
free(t_G->t);
t_G->t = events_to_tree(ev + 1, num_events - i - 1, a);
return true;
} else {
t = &(t_G->t);
}
break;
case TT_L:
break;
case TT_E:
break;
}
}
return false;
}
static GtkWidget *
fcombo_create_list (SheetObject *so,
GtkTreePath **clip, GtkTreePath **select, gboolean *make_buttons)
{
GnmFilterCombo *fcombo = GNM_FILTER_COMBO (so);
GnmFilter const *filter = fcombo->filter;
GnmRange r = filter->r;
Sheet *filtered_sheet;
UniqueCollection uc;
GtkTreeIter iter;
GtkListStore *model;
GtkWidget *list;
GPtrArray *sorted = g_ptr_array_new ();
unsigned i, field_num = gnm_filter_combo_index (fcombo);
gboolean is_custom = FALSE;
GnmValue const *v;
GnmValue const *cur_val = NULL;
model = gtk_list_store_new (4,
G_TYPE_STRING, G_TYPE_STRING, G_TYPE_INT, gnm_value_get_type ());
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter, 0, _("(All)"), 1, NULL, 2, 1, -1);
if (fcombo->cond == NULL || fcombo->cond->op[0] == GNM_FILTER_UNUSED)
*select = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter, 0, _("(Top 10...)"), 1, NULL, 2, 10,-1);
if (fcombo->cond != NULL &&
(GNM_FILTER_OP_TYPE_MASK & fcombo->cond->op[0]) == GNM_FILTER_OP_TOP_N)
*select = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
/* default to this we can easily revamp later */
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter, 0, _("(Custom...)"), 1, NULL, 2, 2, -1);
if (*select == NULL) {
is_custom = TRUE;
*select = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
}
r.start.row++;
/* r.end.row = XL actually extend to the first non-empty element in the list */
r.end.col = r.start.col += field_num;
uc.has_blank = FALSE;
uc.hash = g_hash_table_new_full ((GHashFunc)value_hash, (GEqualFunc)formatted_value_equal,
(GDestroyNotify)value_release, (GDestroyNotify)g_free);
uc.src_sheet = filter->sheet;
uc.date_conv = sheet_date_conv (uc.src_sheet);
/* We do not want to show items that are filtered by _other_ fields.
* The cleanest way to do that is to create a temporary sheet, apply
* all of the other conditions to it and use that as the source of visibility. */
if (filter->fields->len > 1) {
Workbook *wb = uc.src_sheet->workbook;
char *name = workbook_sheet_get_free_name (wb, "DummyFilterPopulate", FALSE, FALSE);
filtered_sheet = sheet_new (wb, name,
gnm_sheet_get_max_cols (uc.src_sheet),
gnm_sheet_get_max_rows (uc.src_sheet));
g_free (name);
for (i = 0 ; i < filter->fields->len ; i++)
if (i != field_num)
gnm_filter_combo_apply (g_ptr_array_index (filter->fields, i),
filtered_sheet);
sheet_foreach_cell_in_range (filtered_sheet,
CELL_ITER_IGNORE_HIDDEN,
&r,
(CellIterFunc)&cb_collect_content, &uc);
g_object_unref (filtered_sheet);
} else
sheet_foreach_cell_in_range (filter->sheet, CELL_ITER_ALL,
&r,
(CellIterFunc)&cb_collect_content, &uc);
g_hash_table_foreach (uc.hash, (GHFunc)cb_hash_domain, sorted);
g_ptr_array_sort (sorted, value_cmp);
if (fcombo->cond != NULL &&
fcombo->cond->op[0] == GNM_FILTER_OP_EQUAL &&
fcombo->cond->op[1] == GNM_FILTER_UNUSED) {
cur_val = fcombo->cond->value[0];
}
for (i = 0; i < sorted->len ; i++) {
char *label = NULL;
unsigned const max = 50;
char const *str = g_hash_table_lookup (uc.hash,
(v = g_ptr_array_index (sorted, i)));
gsize len = g_utf8_strlen (str, -1);
if (len > max + 3) {
label = g_strdup (str);
strcpy (g_utf8_offset_to_pointer (label, max), "...");
}
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter,
0, label ? label : str, /* Menu text */
1, str, /* Actual string selected on. */
2, 0,
3, v,
-1);
g_free (label);
if (i == 10)
*clip = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
if (cur_val != NULL && v != NULL && value_equal (cur_val, v)) {
gtk_tree_path_free (*select);
*select = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
}
}
if (uc.has_blank) {
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter, 0, _("(Blanks...)"), 1, NULL, 2, 3, -1);
if (fcombo->cond != NULL &&
fcombo->cond->op[0] == GNM_FILTER_OP_BLANKS)
*select = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter, 0, _("(Non Blanks...)"), 1, NULL, 2, 4, -1);
if (fcombo->cond != NULL &&
fcombo->cond->op[0] == GNM_FILTER_OP_NON_BLANKS)
*select = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
} else if (is_custom && fcombo->cond != NULL &&
(GNM_FILTER_OP_TYPE_MASK & fcombo->cond->op[0]) == GNM_FILTER_OP_BLANKS) {
gtk_tree_path_free (*select);
*select = NULL;
}
g_hash_table_destroy (uc.hash);
g_ptr_array_free (sorted, TRUE);
list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
g_object_unref (model);
gtk_tree_view_append_column (GTK_TREE_VIEW (list),
gtk_tree_view_column_new_with_attributes ("ID",
gtk_cell_renderer_text_new (), "text", 0,
NULL));
return list;
}
/* Distinguish between the same value with different formats */
static gboolean
formatted_value_equal (GnmValue const *a, GnmValue const *b)
{
return value_equal (a, b) && (VALUE_FMT(a) == VALUE_FMT(b));
}
static GtkWidget *
vcombo_create_list (SheetObject *so,
GtkTreePath **clip, GtkTreePath **select, gboolean *make_buttons)
{
GnmValidationCombo *vcombo = GNM_VALIDATION_COMBO (so);
unsigned i;
UniqueCollection uc;
GnmEvalPos ep;
GtkTreeIter iter;
GtkWidget *list;
GPtrArray *sorted;
GtkListStore *model;
GnmValue *v;
GnmValue const *cur_val;
GnmValidation const *val = vcombo->validation;
SheetView const *sv = vcombo->parent.sv;
g_return_val_if_fail (val != NULL, NULL);
g_return_val_if_fail (val->type == GNM_VALIDATION_TYPE_IN_LIST, NULL);
g_return_val_if_fail (val->deps[0].texpr != NULL, NULL);
g_return_val_if_fail (sv != NULL, NULL);
eval_pos_init_editpos (&ep, sv);
v = gnm_expr_top_eval (val->deps[0].texpr, &ep,
GNM_EXPR_EVAL_PERMIT_NON_SCALAR |
GNM_EXPR_EVAL_PERMIT_EMPTY |
GNM_EXPR_EVAL_ARRAY_CONTEXT);
if (NULL == v)
return NULL;
uc.date_conv = workbook_date_conv (sv->sheet->workbook);
uc.hash = g_hash_table_new_full ((GHashFunc)value_hash, (GEqualFunc)value_equal,
(GDestroyNotify)value_release, (GDestroyNotify)g_free);
value_area_foreach (v, &ep, CELL_ITER_IGNORE_BLANK,
(GnmValueIterFunc) cb_collect_unique, &uc);
value_release (v);
sorted = g_ptr_array_new ();
g_hash_table_foreach (uc.hash, (GHFunc)cb_hash_domain, sorted);
qsort (&g_ptr_array_index (sorted, 0),
sorted->len, sizeof (char *),
&value_cmp);
model = gtk_list_store_new (3,
G_TYPE_STRING, G_TYPE_STRING, gnm_value_get_type ());
cur_val = sheet_cell_get_value (ep.sheet, ep.eval.col, ep.eval.row);
for (i = 0; i < sorted->len ; i++) {
char *label = NULL;
unsigned const max = 50;
char const *str = g_hash_table_lookup (uc.hash,
(v = g_ptr_array_index (sorted, i)));
gsize len = g_utf8_strlen (str, -1);
if (len > max + 3) {
label = g_strdup (str);
strcpy (g_utf8_offset_to_pointer (label, max), "...");
}
gtk_list_store_append (model, &iter);
gtk_list_store_set (model, &iter,
0, label ? label : str, /* Menu text */
1, str, /* Actual string selected on. */
-1);
g_free (label);
if (i == 10)
*clip = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
if (cur_val != NULL && v != NULL && value_equal (cur_val, v)) {
gtk_tree_path_free (*select);
*select = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter);
}
}
g_hash_table_destroy (uc.hash);
g_ptr_array_free (sorted, TRUE);
list = gtk_tree_view_new_with_model (GTK_TREE_MODEL (model));
g_object_unref (model);
gtk_tree_view_append_column (GTK_TREE_VIEW (list),
gtk_tree_view_column_new_with_attributes ("ID",
gtk_cell_renderer_text_new (), "text", 0,
NULL));
return list;
}
int
value_save(struct process *p, struct value *value)
{
unsigned char squeeze = (unsigned char)value->type;
#ifdef DEBUG
process_render(process_err, "(save:%s ", type_name_table[(int)squeeze]);
if (value->type == VALUE_SYMBOL) {
process_render(process_err, "[%d] ", value_symbol_get_length(value));
}
value_portray(process_err, value);
process_render(process_err, ")\n");
#endif
stream_write(NULL, p, &squeeze, sizeof(squeeze));
if ((value->type & VALUE_STRUCTURED) == 0) {
stream_write(NULL, p, &value->value, sizeof(value->value));
} else {
unsigned int length, i;
switch (value->type) {
case VALUE_SYMBOL:
{
const char *token = value_symbol_get_token(value);
length = value_symbol_get_length(value);
stream_write(NULL, p, &length, sizeof(length));
stream_write(NULL, p, token, sizeof(char) * length);
break;
}
case VALUE_TUPLE:
{
struct value *tag = value_tuple_get_tag(value);
value_save(p, tag);
/* XXX should eventually dispatch to a handler based on tag. */
if (value_equal(tag, &tag_dict)) {
struct value dict_iter;
struct value *key;
value_dict_new_iter(&dict_iter, value);
length = value_dict_get_layer_size(value);
stream_write(NULL, p, &length, sizeof(length));
length = value_dict_get_length(value);
stream_write(NULL, p, &length, sizeof(length));
key = value_dict_iter_get_current_key(&dict_iter);
while (!value_is_null(key)) {
value_save(p, key);
value_save(p, value_dict_fetch(value, key)); /* XXX not so good; use iter */
value_dict_iter_advance(&dict_iter);
key = value_dict_iter_get_current_key(&dict_iter);
}
} else {
length = value_tuple_get_size(value);
stream_write(NULL, p, &length, sizeof(length));
for (i = 0; i < length; i++) {
value_save(p, value_tuple_fetch(value, i));
}
}
break;
}
default:
assert(value->type == VALUE_SYMBOL ||
value->type == VALUE_TUPLE);
break;
}
}
return 1;
}
/* From observation this gives the pixels at the fall off region */
void SpotLightFallOFFIntensityCalculator::GetFallOffRegionForNoAmbientLightBackground(const int& maxNumberOfRadiusSegment) {
std::vector<double>diffInIntensity = std::vector<double>(360,0);
for (int index = 0; index < 360; ++index) {
for (int block = 0; block < (maxNumberOfRadiusSegment-1); ++block) {
if ((Sector[index][block].size() == 0) || (Sector[index][block+1].size() == 0)){
continue;
}
int numberOfZeroIntensityVectorBlock1 = (int)std::count_if(SectorIntensity[index][block].begin(), SectorIntensity[index][block].end(), value_equal(Rgba(0, 0, 0)));
double ratio1 = (double)numberOfZeroIntensityVectorBlock1 / (double)Sector[index][block].size();
if (ratio1 > 0) {
int numberOfZeroIntensityVectorBlock2 = (int)std::count_if(SectorIntensity[index][block+1].begin(), SectorIntensity[index][block+1].end(), value_equal(Rgba(0, 0, 0)));
double ratio2 = (double)numberOfZeroIntensityVectorBlock2 / (double)Sector[index][block+1].size();
if (ratio2 > 0) {
std::cout << "Edge pixel = " << Sector[index][block][4].y << "," <<Sector[index][block][4].x << std::endl;
break;
}
}
}
}
}