static void
notify_cb (const char *name,
XSettingsAction action,
XSettingsSetting *setting,
void *data)
{
int row;
char *text[4];
switch (action)
{
case XSETTINGS_ACTION_NEW:
text[NAME] = (char *)name;
text[TYPE] = text[VALUE] = text[SERIAL] = "";
row = gtk_clist_insert (GTK_CLIST (settings_clist), 0, text);
gtk_clist_set_row_data_full (GTK_CLIST (settings_clist), row,
g_strdup (name), (GDestroyNotify)g_free);
update_row (row, setting);
break;
case XSETTINGS_ACTION_CHANGED:
row = find_row (name);
update_row (row, setting);
break;
case XSETTINGS_ACTION_DELETED:
row = find_row (name);
gtk_clist_remove (GTK_CLIST (settings_clist), row);
break;
}
}
/*
* Print a solution row:
* - x = variable defined by that row
* - r = the row index
* - v = column indices (as an int_bag)
*/
static void dsolver_print_sol_row_core(FILE *f, dsolver_t *solver, int32_t x, int32_t r, int32_t *v) {
dcolumn_t *c, *b;
uint32_t i, n, m;
int32_t k, j;
// j = constant index for row r, j == -1 means constant = 0
b = solver->constant_column;
j = find_row(b, r);
if (v == NULL) {
n = 0;
m = 0;
} else {
m = ibag_nelems(v);
n = ibag_size(v);
}
if (m == 0 && j < 0) {
fprintf(f, "(= x_%"PRId32" 0)", x);
} else {
if (m > 1 || j >= 0) {
fprintf(f, "(= x_%"PRId32" (+", x);
} else {
fprintf(f, "(= x_%"PRId32, x);
}
// print the constant first
if (j >= 0) {
fprintf(f, " ");
q_print(f, &b->data[j].coeff);
}
// print the matrix element
for (i=0; i<n; i++) {
if (v[i] >= 0) {
assert(v[i] < solver->ncolumns);
c = solver->column[v[i]];
assert(c != NULL);
k = find_row(c, r);
assert(k >= 0);
fprintf(f, " ");
dsolver_print_monomial(f, &c->data[k].coeff, c->var, 'i');
}
}
if (m > 1 || j >= 0) {
fprintf(f, "))");
} else {
fprintf(f, ")");
}
}
}
int
fe_userlist_remove (session *sess, struct User *user)
{
GtkTreeIter *iter;
/* GtkAdjustment *adj;
gfloat val, end;*/
int sel;
iter = find_row (GTK_TREE_VIEW (sess->gui->user_tree),
sess->res->user_model, user, &sel);
if (!iter)
return 0;
/* adj = gtk_tree_view_get_vadjustment (GTK_TREE_VIEW (sess->gui->user_tree));
val = adj->value;*/
gtk_list_store_remove (sess->res->user_model, iter);
/* is it the front-most tab? */
/* if (gtk_tree_view_get_model (GTK_TREE_VIEW (sess->gui->user_tree))
== sess->res->user_model)
{
end = adj->upper - adj->lower - adj->page_size;
if (val > end)
val = end;
gtk_adjustment_set_value (adj, val);
}*/
return sel;
}
bool
fe_userlist_remove(session *sess, struct User const *user)
{
/* GtkAdjustment *adj;
gfloat val, end;*/
auto result = find_row (GTK_TREE_VIEW (sess->gui->user_tree),
static_cast<GtkTreeModel*>(sess->res->user_model), user);
if (!result.first)
return false;
/* adj = gtk_tree_view_get_vadjustment (GTK_TREE_VIEW (sess->gui->user_tree));
val = adj->value;*/
gtk_list_store_remove (static_cast<GtkListStore*>(sess->res->user_model), result.first.get());
/* is it the front-most tab? */
/* if (gtk_tree_view_get_model (GTK_TREE_VIEW (sess->gui->user_tree))
== sess->res->user_model)
{
end = adj->upper - adj->lower - adj->page_size;
if (val > end)
val = end;
gtk_adjustment_set_value (adj, val);
}*/
return result.second;
}
/*
* Print a row:
* - r = row index
* - v = array of columns where i occurs (as an integer vector)
*/
static void dsolver_print_row_vector(FILE *f, dsolver_t *solver, int32_t r, ivector_t *v) {
dcolumn_t *c, *b;
uint32_t i, n;
int32_t k, j;
// j = constant index for row r, j == -1 means constant = 0
b = solver->constant_column;
j = find_row(b, r);
n = v->size;
if (n == 0 && j < 0) {
fprintf(f, "(= 0 0)");
} else {
if (n > 1 || j >= 0) {
fprintf(f, "(= (+");
} else {
fprintf(f, "(=");
}
// print the matrix element
for (i=0; i<n; i++) {
assert(0 <= v->data[i] && v->data[i] < solver->ncolumns);
c = solver->column[v->data[i]];
assert(c != NULL);
k = find_row(c, r);
assert(k >= 0);
fprintf(f, " ");
dsolver_print_monomial(f, &c->data[k].coeff, c->var, 'x');
}
// print the constant
if (j >= 0) {
fprintf(f, " ");
q_print(f, &b->data[j].coeff);
}
// close parentheses
if (n > 1 || j >= 0) {
fprintf(f, ") 0)");
} else {
fprintf(f, " 0)");
}
}
}
void test_text_key() {
// Create a table named "Table".
auto db = grnxx::open_db("");
auto table = db->create_table("Table");
// Create a column named "Column".
auto column = table->create_column("Column", GRNXX_TEXT);
// Append three rows.
grnxx::Int row_id = table->insert_row();
column->set(row_id, grnxx::Text("1"));
row_id = table->insert_row();
column->set(row_id, grnxx::Text("12"));
row_id = table->insert_row();
column->set(row_id, grnxx::Text("123"));
// Set key column.
table->set_key_column("Column");
assert(table->key_column() == column);
// Duplicate keys must be rejected.
bool inserted = true;
row_id = table->find_or_insert_row(grnxx::Text("1"), &inserted);
assert(row_id.raw() == 0);
assert(!inserted);
row_id = table->find_or_insert_row(grnxx::Text("12"), &inserted);
assert(row_id.raw() == 1);
assert(!inserted);
row_id = table->find_or_insert_row(grnxx::Text("123"), &inserted);
assert(row_id.raw() == 2);
assert(!inserted);
// Append new keys.
grnxx::Datum datum;
row_id = table->find_or_insert_row(grnxx::Text("A"), &inserted);
assert(row_id.raw() == 3);
assert(inserted);
row_id = table->find_or_insert_row(grnxx::Text("AB"), &inserted);
assert(row_id.raw() == 4);
assert(inserted);
row_id = table->find_or_insert_row(grnxx::Text("ABC"), &inserted);
assert(row_id.raw() == 5);
assert(inserted);
// Find rows by key.
assert(table->find_row(grnxx::Text("1")).raw() == 0);
assert(table->find_row(grnxx::Text("12")).raw() == 1);
assert(table->find_row(grnxx::Text("123")).raw() == 2);
assert(table->find_row(grnxx::Text("A")).raw() == 3);
assert(table->find_row(grnxx::Text("AB")).raw() == 4);
assert(table->find_row(grnxx::Text("ABC")).raw() == 5);
assert(table->find_row(grnxx::Text::na()).is_na());
// Unset key column.
table->unset_key_column();
assert(!table->key_column());
}
Row<T> Array2D<T>::operator [] (int row)
{
if (row >= m_row)
throw Exception("Row index exceeds upper bounds");
else if (row < 0)
throw Exception("Row index exceeds lower bounds");
Row<T> find_row(*this, row);
return find_row;
}
Row<T> Array2D<T>::operator [] (int row) const
{
if (row >= m_row)
throw Exception("Row index exceeds upper bounds");
else if (row < 0)
throw Exception("Row index exceeds lower bounds");
const Array2D<T>& here = *this;
Row<T> find_row(const_cast<Array2D<T>&>(here), row);
return find_row;
}
void
fe_userlist_rehash (session *sess, struct User const *user)
{
auto result = find_row (GTK_TREE_VIEW (sess->gui->user_tree),
static_cast<GtkTreeModel*>(sess->res->user_model), user);
if (!result.first)
return;
int nick_color = 0;
if (prefs.hex_away_track && user->away)
nick_color = COL_AWAY;
else if (prefs.hex_gui_ulist_color)
nick_color = text_color_of(user->nick);
gtk_list_store_set (GTK_LIST_STORE (sess->res->user_model), result.first.get(),
COL_HOST, user->hostname ? user->hostname->c_str() : nullptr,
COL_GDKCOLOR, nick_color ? &colors[nick_color] : NULL,
-1);
}
void
fe_userlist_rehash (session * sess, struct User *user)
{
GtkTreeIter *iter;
int sel;
int do_away = TRUE;
iter = find_row (GTK_TREE_VIEW (sess->gui->user_tree),
sess->res->user_model, user, &sel);
if (!iter)
return;
if (prefs.away_size_max < 1 || !prefs.away_track)
do_away = FALSE;
gtk_list_store_set (GTK_LIST_STORE (sess->res->user_model), iter,
COL_HOST, user->hostname,
COL_GDKCOLOR, (do_away)
? (user->away ? &colors[COL_AWAY] : NULL)
: (NULL), -1);
}
void
fe_userlist_rehash (session *sess, struct User *user)
{
GtkTreeIter *iter;
int sel;
int nick_color = 0;
iter = find_row (GTK_TREE_VIEW (sess->gui->user_tree),
sess->res->user_model, user, &sel);
if (!iter)
return;
if (prefs.hex_away_track && user->away)
nick_color = COL_AWAY;
else if (prefs.hex_gui_ulist_color)
nick_color = text_color_of(user->nick);
gtk_list_store_set (GTK_LIST_STORE (sess->res->user_model), iter,
COL_HOST, user->hostname,
COL_GDKCOLOR, nick_color ? &colors[nick_color] : NULL,
-1);
}
/* This function stores the current move in the 2D array in game->state->table */
int store_move_in_table(struct game *myGame, char *currMoveString, struct move *currMove ){
int currColumn;
int currRow;
/* no need to use my_atoi */
currColumn = atoi(currMoveString);
/* check for wrong dimensions */
if (currColumn <= 0 || currColumn > myGame->columns) {
return 0;
}
/* store the column */
currMove->column = currColumn;
/* let's find the row */
currRow = find_row(myGame, currColumn);
/* another check */
if (currRow > myGame->rows) {
return 0;
}
/* move valid, store the row */
currMove->row = currRow;
return 1;
}
/*
* Print the solved columns
*/
void dsolver_print_solved_columns(FILE *f, dsolver_t *solver) {
dcolumn_t *c;
uint32_t j, n;
int32_t r, k;
n = solver->nsolved;
if (n == 0) {
fprintf(f, "No solved columns\n");
} else {
fprintf(f, "Solved columns:\n");
for (r=0; r<solver->nrows; r++) {
fprintf(f, "row[%"PRId32"]:", r);
for (j=0; j<n; j++) {
c = solver->solved_columns[j];
k = find_row(c, r);
if (k >= 0) {
fprintf(f, " ");
dsolver_print_monomial(f, &c->data[k].coeff, c->var, 'i');
}
}
fprintf(f, "\n");
}
}
}
void test_int_key() {
// Create a table named "Table".
auto db = grnxx::open_db("");
auto table = db->create_table("Table");
// Create a column named "Column".
auto column = table->create_column("Column", GRNXX_INT);
// Append three rows.
grnxx::Int row_id = table->insert_row();
column->set(row_id, grnxx::Int(1));
row_id = table->insert_row();
column->set(row_id, grnxx::Int(10));
row_id = table->insert_row();
column->set(row_id, grnxx::Int(100));
// Set key column.
table->set_key_column("Column");
assert(table->key_column() == column);
// Duplicate keys must be rejected.
bool inserted = true;
row_id = table->find_or_insert_row(grnxx::Int(1), &inserted);
assert(row_id.match(grnxx::Int(0)));
assert(!inserted);
row_id = table->find_or_insert_row(grnxx::Int(10), &inserted);
assert(row_id.match(grnxx::Int(1)));
assert(!inserted);
row_id = table->find_or_insert_row(grnxx::Int(100), &inserted);
assert(row_id.match(grnxx::Int(2)));
assert(!inserted);
// Append new keys.
grnxx::Datum datum;
row_id = table->find_or_insert_row(grnxx::Int(2), &inserted);
assert(inserted);
column->get(row_id, &datum);
assert(datum.as_int().raw() == 2);
row_id = table->find_or_insert_row(grnxx::Int(20), &inserted);
column->get(row_id, &datum);
assert(datum.as_int().raw() == 20);
row_id = table->find_or_insert_row(grnxx::Int(200), &inserted);
column->get(row_id, &datum);
assert(datum.as_int().raw() == 200);
row_id = table->find_or_insert_row(grnxx::Int(200000), &inserted);
column->get(row_id, &datum);
assert(datum.as_int().raw() == 200000);
row_id = table->find_or_insert_row(grnxx::Int(20000000000L), &inserted);
column->get(row_id, &datum);
assert(datum.as_int().raw() == 20000000000L);
// Find rows by key.
assert(table->find_row(grnxx::Int(1)).raw() == 0);
assert(table->find_row(grnxx::Int(10)).raw() == 1);
assert(table->find_row(grnxx::Int(100)).raw() == 2);
assert(table->find_row(grnxx::Int(2)).raw() == 3);
assert(table->find_row(grnxx::Int(20)).raw() == 4);
assert(table->find_row(grnxx::Int(200)).raw() == 5);
assert(table->find_row(grnxx::Int(200000)).raw() == 6);
assert(table->find_row(grnxx::Int(20000000000L)).raw() == 7);
assert(table->find_row(grnxx::Int::na()).is_na());
// Unset key column.
table->unset_key_column();
assert(!table->key_column());
// Test an N/A value.
column->set(grnxx::Int(0), grnxx::Int::na());
try {
table->set_key_column("Column");
assert(false);
} catch (...) {
}
// Test a trailing N/A value.
table->insert_row();
try {
table->set_key_column("Column");
assert(false);
} catch (...) {
}
}
int insert_element2( RowNode_handle *pp_r,int pos_row,int pos_col,int val )
{
RowNode_handle pRow = *pp_r, pRowFind;
int result;
/* dummy element node pointer to use in insert row calls */
ElementNode_handle pColumns = 0;
/* if matrix doesnt exist */
if(!pRow && val != 0)
{
/* make a row */
*pp_r = make_row(pos_row);
/* insert an element where desired */
result = insert_element(&(*pp_r)->elements, pos_col, val);
/* remove any rows that have been zero'd out */
ZeroRowRemover(pp_r);
/* return reuslt of insertion */
return result;
}
/* iterate through the rows */
while(pRow && pRow->pos != pos_row)
pRow = pRow->next;
/* insert element in row if found */
if(pRow && pRow->pos == pos_row)
{
/* insert element */
result = insert_element(&pRow->elements, pos_col, val);
/* remove any rows zero'd out */
ZeroRowRemover(pp_r);
/* return result of insertion */
return result;
}
else /* if row not found, insert it */
{
/* dont create row if val desired in non-existent row is 0 */
if(val == 0)
return 0;
/* insert a row into this matrix */
insert_row(pp_r, pos_row, pColumns);
/* get pointer to row inserted */
pRowFind = find_row(pp_r, pos_row);
/* insert element in row requested */
result = insert_element(&pRowFind->elements, pos_col, val);
/* remove any rows that have been zero'd out */
ZeroRowRemover(pp_r);
/* return result of insertion */
return result;
}
}
/*
* Print a row:
* - r = row index
* - v = array of columns where i occurs (as an int_bag)
* Assumptions on v:
* - it contains valid column indices with no repetition
* (negative numbers in v are skipped, cf. int_bags)
* - for every k in v, column k is non-null and contain an element for row r
*/
static void dsolver_print_row_core(FILE *f, dsolver_t *solver, int32_t r, int32_t *v) {
dcolumn_t *c, *b;
uint32_t i, n, m;
int32_t k, j;
char prefix;
/* if main_rows is 0, variables are written x_<xx>
* otherwise, variables are written i_<xxx>
*/
if (solver->main_rows == 0) {
prefix = 'x';
} else {
prefix = 'i';
}
// j = constant index for row r, j == -1 means constant = 0
b = solver->constant_column;
j = find_row(b, r);
if (v == NULL) {
m = 0;
n = 0;
} else {
m = ibag_nelems(v);
n = ibag_size(v);
}
if (m == 0 && j < 0) {
fprintf(f, "(= 0 0)");
} else {
if (m > 1 || j >= 0) {
fprintf(f, "(= (+");
} else {
fprintf(f, "(=");
}
// print the matrix element
for (i=0; i<n; i++) {
if (v[i] >= 0) {
assert(v[i] < solver->ncolumns);
c = solver->column[v[i]];
assert(c != NULL);
k = find_row(c, r);
assert(k >= 0);
fprintf(f, " ");
dsolver_print_monomial(f, &c->data[k].coeff, c->var, prefix);
}
}
// print the constant
if (j >= 0) {
fprintf(f, " ");
q_print(f, &b->data[j].coeff);
}
// close parentheses
if (m > 1 || j >= 0) {
fprintf(f, ") 0)");
} else {
fprintf(f, " 0)");
}
}
}
