bool FractionField::initialize_frac(const PolyRingFlat *R)
{
initialize_ring(R->charac(),
R->get_degree_ring(),
R->get_heft_vector());
R_ = R;
_MINUS_ONE = R->from_int(-1);
zeroV = from_int(0);
oneV = from_int(1);
minus_oneV = from_int(-1);
if (R->n_quotients() > 0
|| R->getCoefficients()->cast_to_FractionField() // disallowed in x-relem.cpp
|| R->getMonoid()->getNonTermOrderVariables()->len > 0) // disallowed in x-relem.cpp
use_gcd_simplify = false;
else
use_gcd_simplify = true;
#ifdef DEVELOPMENT
#warning "frac simplify: doesn't handle towers of fracs"
#endif
declare_field();
return true;
}
ring_elem RingZZ::preferred_associate(ring_elem f) const
{
mpz_ptr a = f.get_mpz();
if (mpz_sgn(a) >= 0)
return from_int(1);
return from_int(-1);
}
std::string formatting_options::get_par_str() const
{
std::string style;
switch (papAlign)
{
case formatting_options::align_right:
style+="text-align:right;";
break;
case formatting_options::align_center:
style+="text-align:center;";
break;
case formatting_options::align_justify:
style+="text-align:justify;";
break;
case formatting_options::align_left:
case formatting_options::align_error:
break;
}
if (papFirst!=0)
{
style+="text-indent:";
style+=from_int(papFirst);
style+="pt;";
}
if (papLeft!=0)
{
style+="margin-left:";
style+=from_int(papLeft);
style+="pt;";
}
if (papRight!=0)
{
style+="margin-right:";
style+=from_int(papRight);
style+="pt;";
}
if (papBefore!=0)
{
style+="margin-top:";
style+=from_int(papBefore);
style+="pt;";
}
if (papAfter!=0)
{
style+="margin-bottom:";
style+=from_int(papAfter);
style+="pt;";
}
if (style.empty())
return std::string("<p>");
else
{
style.insert(0, "<p style=\"");
return style+"\">";
}
}
bool QQ::initialize_QQ()
{
initialize_ring(0);
_elem_size = sizeof(mpq_t);
_zero_elem = new_elem();// this sets the element to 0.
#if 0
// trans_one = globalZZ->from_int(1);
#endif
declare_field();
zeroV = from_int(0);
oneV = from_int(1);
minus_oneV = from_int(-1);
return true;
}
bool RingZZ::initialize_ZZ(const PolynomialRing *deg_ring)
{
initialize_ring(0);
_elem_size = sizeof(mpz_t);
_zero_elem = new_elem();
mpz_init_set_si(_zero_elem, 0);
zeroV = from_int(0);
oneV = from_int(1);
minus_oneV = from_int(-1);
degree_ring = deg_ring;
coeffR = new CoefficientRingZZ_NTL(this);
return true;
}
ring_elem SchurRing::power(const ring_elem f, mpz_t n) const
{
if (mpz_sgn(n) < 0)
{
ERROR("element not invertible");
return from_int(1);
}
unsigned int n1;
if (!RingZZ::get_ui(n1, n))
{
ERROR("exponent too large");
return from_int(1);
}
return power(f,n1);
}
static int set_new_value(BaseTDBResolver *self, TDB_DATA urn, TDB_DATA attribute,
TDB_DATA value) {
TDB_DATA key,offset;
char buff[BUFF_SIZE];
char buff2[BUFF_SIZE];
uint32_t new_offset;
TDB_DATA_LIST i;
// Update the value in the db and replace with new value
key.dptr = (unsigned char *)buff;
key.dsize = calculate_key(self, urn, attribute, buff, BUFF_SIZE, 1);
// Lock the database
tdb_lockall(self->data_db);
// Go to the end and write the new record
new_offset = lseek(self->data_store_fd, 0, SEEK_END);
// The offset to the next item in the list
i.offset = 0;
i.length = value.dsize;
write(self->data_store_fd, &i, sizeof(i));
write(self->data_store_fd, value.dptr, value.dsize);
offset.dptr = (unsigned char *)buff2;
offset.dsize = from_int(new_offset, buff2, BUFF_SIZE);
tdb_store(self->data_db, key, offset, TDB_REPLACE);
//Done
tdb_unlockall(self->data_db);
return 1;
};
static PyObject *get_urn_by_id(BaseTDBResolver *self, PyObject *args, PyObject *kwds) {
static char *kwlist[] = {"id", NULL};
char buff[BUFF_SIZE];
uint32_t id;
PyObject *result, *id_obj;
TDB_DATA urn;
TDB_DATA key;
if(!PyArg_ParseTupleAndKeywords(args, kwds, "O", kwlist,
&id_obj))
return NULL;
id_obj = PyNumber_Long(id_obj);
if(!id_obj) return NULL;
id = PyLong_AsUnsignedLongLong(id_obj);
Py_DECREF(id_obj);
/* We get given an ID and we retrieve the URN it belongs to */
key.dptr = (unsigned char *)buff;
key.dsize = from_int(id, buff, BUFF_SIZE);
urn = tdb_fetch(self->urn_db, key);
if(urn.dptr) {
result = PyString_FromStringAndSize((char *)urn.dptr, urn.dsize);
free(urn.dptr);
return result;
};
Py_RETURN_NONE;
};
int main() {
bignum l1 = from_str("99"),
l2 = from_str("10");
printf("%s\n", to_str(from_int(666)));
printf("%d\n", to_int(from_str("666")));
bignum sum = plus(l1, l2);
printf("%s\n", to_str(sum));
bignum diff = minus(l1, l2);
printf("%s\n", to_str(diff));
printf("%i\n", lesser(l1, l2));
bignum muli = mul_int(l1, 2);
printf("%s\n", to_str(muli));
printf("%d\n", mod_int(l1, 10));
bignum divi = div_int(l1, 10);
printf("%s\n", to_str(divi));
bignum mul = multiply(l1, l2);
printf("%s\n", to_str(mul));
bignum div = divide(l1, l2);
printf("%s\n", to_str(div));
bignum mod = modulo(l1, l2);
printf("%s\n", to_str(mod));
return 0;
}
ring_elem RingZZ::invert(const ring_elem f) const
{
if (is_unit(f))
return copy(f);
else
return from_int(0);
}
bool Z_mod::initialize_Z_mod(int p)
{
initialize_ring(p);
declare_field();
int i,j,q,n;
if (P==2)
_minus_one = 0;
else
_minus_one = (P-1)/2;
if (P==2)
_prim_root = 1;
else
{
j=1;
for (i=2; (i<P && j<P-1); i++)
for (q=i,j=1; (q!=1 && j<P); q=(q*i)%P,j++);
_prim_root = i-1;
}
// cerr << "z_mod_p: creating table for P = " << P << endl;
_log_table = newarray_atomic(int,P);
_exp_table = newarray_atomic(int,P);
for (i=0, n=1; i<P-1; i++, n=(n*_prim_root)%P)
{
_log_table[n] = i; // i = log_(base _prim_root)(n)
_exp_table[i] = n; // n = (_prim_root)^i
}
_ZERO = P-1;
_exp_table[_ZERO] = 0;
_log_table[0] = _ZERO;
_P1 = P-1;
zeroV = from_int(0);
oneV = from_int(1);
minus_oneV = from_int(-1);
coeffR = new CoefficientRingZZp(P,_log_table, _exp_table);
aringZZp = new M2::ARingZZp(P); // WARNING: this uses that the primitive element is the SAME as computed above!!
// Remove this warning once Z_mod is not in existence any longer.
return true;
}
bool Z_mod::promote(const Ring *Rf, const ring_elem f, ring_elem &result) const
{
// Rf = Z ---> Z/p
if (Rf == globalZZ)
{
result = from_int(f.get_mpz());
return true;
}
return false;
}
TagIncludedValue operator +(TagIncludedValue rhs) const {
switch (this->type()) {
case TYPE_FIXNUM:
switch (rhs.type()) {
case TYPE_FIXNUM: {
fixint_t l = fix2int(this->u.iv);
fixint_t r = fix2int(rhs.u.iv);
r = l + r;
return from_int(r);
}
break;
case TYPE_FLOAT: {
double lv = fix2int(this->u.iv);
Object *ro = rhs.u.obj;
return from_float(lv + ro->u.fv);
}
break;
default:
abort();
}
break;
case TYPE_FLOAT: {
Object *lo = this->u.obj;
switch (rhs.type()) {
case TYPE_FIXNUM: {
/* fl + fi */
fixint_t r = fix2int(rhs.u.iv);
double a = lo->u.fv + r;
return from_float(a);
}
break;
case TYPE_FLOAT: {
Object *ro = rhs.u.obj;
/* fl + fl */
return from_float(lo->u.fv + ro->u.fv);
}
break;
default:
abort(); // ??
break;
}
}
break;
default:
abort(); // ??
}
abort(); // ??
}
virtual QVariant data (int int_role) const override
{
painter_server_model_role role = from_int (int_role);
if (role.second)
return current_active () == role.first;
else
{
item_paint_server server = current_server ();
server.set_current_type (role.first);
return QVariant::fromValue (server);
}
}
bool GF::promote(const Ring *Rf, const ring_elem f, ring_elem &result) const
{
// Rf = Z/p[x]/F(x) ---> GF(p,n)
// promotion: need to be able to know the value of 'x'.
// lift: need to compute (primite_element)^e
if (Rf != _originalR) return false;
result = from_int(0);
int exp[1];
for (Nterm *t = f; t != NULL; t = t->next)
{
ring_elem coef = from_int(_originalR->getCoefficientRing()->coerce_to_int(t->coeff));
_originalR->getMonoid()->to_expvector(t->monom, exp);
// exp[0] is the variable we want. Notice that since the ring is a quotient,
// this degree is < n (where Q_ = P^n).
ring_elem g = power(_x_exponent, exp[0]);
g = mult(g, coef);
internal_add_to(result, g);
}
return true;
}
ring_elem SchurRing::power(const ring_elem f, int n) const
{
ring_elem result = from_int(1);
if (n < 0)
{
ERROR("element not invertible");
return result;
}
for (int i=0; i<n; i++)
{
ring_elem g = mult(result, f);
remove(result);
result = g;
}
return result;
}
virtual void set_model_data (const std::map<int, QVariant> &data_map) override
{
auto changer = m_base_model->do_multi_change ();
for (auto && data_pair : data_map)
{
painter_server_model_role role = from_int (data_pair.first);
if (!role.second || !data_pair.second.toBool ())
continue;
item_paint_server server = current_server ();
server.set_current_type (role.first);
if (is_selected_fill ())
changer->set_data ((int)style_controller_role_t::FILL_SERVER, QVariant::fromValue (server));
else
changer->set_data ((int)style_controller_role_t::STROKE_SERVER, QVariant::fromValue (server));
}
}
/*
* Convert a object into another object
*/
Object *convert_object(Object *o, int type)
{
switch(get_type(o)) {
case T_INT :
return from_int(o, type);
case T_CHAR :
return from_char(o, type);
case T_STRING :
return from_string(o, type);
case T_FLOAT :
return from_float(o, type);
case T_BYTE_ARRAY :
return from_barray(o, type);
}
/* Invalid tyep specified */
return NULL;
}
/** Fetches the id for the given key from the database tdb - if
create_new is set and there is no id present, we create a new id
and return id.
*/
static uint32_t get_id(struct tdb_context *tdb, TDB_DATA key, int create_new) {
char buff[BUFF_SIZE];
TDB_DATA urn_id;
uint32_t max_id=0;
uint32_t result=0;
/* We get given an ID and we retrieve the URN it belongs to */
tdb_lockall(tdb);
urn_id = tdb_fetch(tdb, key);
if(urn_id.dptr) {
result = to_int(urn_id);
free(urn_id.dptr);
tdb_unlockall(tdb);
return result;
} else if(create_new) {
TDB_DATA max_key;
max_key.dptr = (unsigned char *)MAX_KEY;
max_key.dsize = strlen(MAX_KEY);
urn_id = tdb_fetch(tdb, max_key);
if(urn_id.dptr) {
max_id = to_int(urn_id);
free(urn_id.dptr);
};
max_id++;
// Update the new MAX_KEY
urn_id.dptr = (unsigned char *)buff;
urn_id.dsize = from_int(max_id, buff, BUFF_SIZE);
tdb_store(tdb, key, urn_id, TDB_REPLACE);
tdb_store(tdb, max_key, urn_id, TDB_REPLACE);
tdb_store(tdb, urn_id, key, TDB_REPLACE);
tdb_unlockall(tdb);
return max_id;
};
tdb_unlockall(tdb);
// This should never happen
return 0;
};
int main(int argc, char** argv) {
Player **Gamer;
int numberOfGamers = 6; // количество игроков за столом
int numberOfRounds=4;
Gamer = new Player*[6]; // 6 игроков
Pack Cards(0); // колода карт
Card FiveCard[5]; // 5 общих карт
int nRound = 1; // первый круг торговли
/* создадим numberOfGamers игроков */
for (int i = 0; i < numberOfGamers; i++) {
Gamer[i] = new Player("Gamer" + from_int(i), 50, i);
Gamer[i][0].SetCards(Cards.getCard(), Cards.getCard());
std::cout << Gamer[i][0].getLogin() << " "
<< Gamer[i][0].GetFirstCard().getRank() << " of "
<< Gamer[i][0].GetFirstCard().getSuit() << " ";
std::cout << Gamer[i][0].GetSecondCard().getRank() << " of "
<< Gamer[i][0].GetSecondCard().getSuit() << std::endl;
}
// ставки игроков для теста
/*
int Stavki[4][6] = {
{ 2, 2, 2, 2, 2, 2 },
{ 6, 5, 6, 6, 6, 6 },
{ 6, 0, 4, 5, 6, 6 },
{ 2, 0, 0, 0, 4, 5 } };*/
int **Stavki= new int*[numberOfRounds];
for (int i=0;i<numberOfRounds;i++)
Stavki[i]= new int[numberOfGamers];
createSetOfStakes(Stavki,numberOfRounds,numberOfGamers);
// объявление банка
Bank bank(Gamer, numberOfGamers);
// круг торговли и заполнение банка
std::cout << "Round " << nRound << std::endl;
// ставки игроков
for (int i = 0; i < numberOfGamers; i++) {
std::cout << "Gamer" << i + 1 << " stake is " << Stavki[nRound - 1][i]
<< " ";
bank.addPlayer(*Gamer[i], Stavki[nRound - 1][i], nRound - 1);
}
std::cout << std::endl;
std::cout << "------------Card Pack-----------" << std::endl;
for (int i = 0; i < 3; i++) {
FiveCard[i] = Cards.getCard();
std::cout << FiveCard[i].getRank() << " of " << FiveCard[i].getSuit()
<< std::endl;
}
// круг торговли и заполнение банка
std::cout << "Round " << ++nRound <<std::endl;
// ставки игроков
for (int i = 0; i < numberOfGamers; i++) {
std::cout << "Gamer" << i + 1 << " stake is" << Stavki[nRound - 1][i]
<< " ";
bank.addPlayer(*Gamer[i], Stavki[nRound - 1][i], nRound - 1);
}
std::cout << std::endl;
std::cout << "------------Card Pack-----------" << std::endl;
FiveCard[3] = Cards.getCard();
for (int i = 0; i < 4; i++) {
std::cout << FiveCard[i].getRank() << " of " << FiveCard[i].getSuit()
<< std::endl;
}
// круг торговли и заполнение банка
std::cout << "Round " << ++nRound << std::endl;;
// ставки игроков
for (int i = 0; i < numberOfGamers; i++) {
std::cout << "Gamer" << i + 1 << " stake is " << Stavki[nRound - 1][i]
<< " ";
bank.addPlayer(*Gamer[i], Stavki[nRound - 1][i], nRound - 1);
}
std::cout << std::endl;
std::cout << "------------Card Pack-----------" << std::endl;
FiveCard[4] = Cards.getCard();
for (int i = 0; i < 5; i++) {
std::cout << FiveCard[i].getRank() << " of " << FiveCard[i].getSuit()
<< std::endl;
}
// последний круг торговли и заполнение банка
std::cout << "Round " << ++nRound << std::endl;
// ставки игроков
for (int i = 0; i < numberOfGamers; i++) {
std::cout << "Gamer" << i + 1 << " stake is" << Stavki[nRound - 1][i]
<< " ";
bank.addPlayer(*Gamer[i], Stavki[nRound - 1][i], nRound - 1);
}
std::cout << std::endl;
Calculation counting(Gamer, FiveCard, 6);
counting.WinnersCalc();
for (int i = 0; i < 6; i++) {
std::cout << Gamer[i][0].getLogin() << " is in "
<< Gamer[i][0].getWinPlace() << " place " << " has "
<< counting.GetCombinationName(Gamer[i]) << std::endl;
}
// раздача денег
bank.winners();
std::cout << std::endl;
for (int i = 0; i < numberOfGamers; i++) {
std::cout << "Position table: " << Gamer[i]->getPosition() << " "<<Gamer[i]->getLogin()<<" ";
std::cout << Gamer[i]->getPurse() << "$"<<std::endl;
}
std::cout << "SumBank: " << bank.getSumBank() << std::endl;
for (int i = 0; i < 6; i++) {
delete[] Gamer[i];
}
delete[] Gamer;
return 0;
}
int cmd_set_timeout(struct libusb_device_handle* devh, int timeout) {
char dataptr[4];
from_int(timeout, dataptr);
return cmd_setter(devh, DOT11_SET_TIMEOUT, dataptr, 4);
}
bool GF::initialize_GF(const RingElement *prim)
{
// set the GF ring tables. Returns false if there is an error.
_primitive_element = prim;
_originalR = prim->get_ring()->cast_to_PolynomialRing();
initialize_ring(_originalR->charac(),
PolyRing::get_trivial_poly_ring());
declare_field();
int i,j;
if (_originalR->n_quotients() != 1)
{
ERROR("rawGaloisField expected an element of a quotient ring of the form ZZ/p[x]/(f)");
return false;
}
ring_elem f = _originalR->quotient_element(0);
Nterm *t = f;
int n = _originalR->getMonoid()->primary_degree(t->monom);
Q_ = P;
for (i=1; i<n; i++) Q_ *= P;
Qexp_ = n;
Q1_ = Q_-1;
_ZERO = 0;
_ONE = Q1_;
_MINUS_ONE = (P == 2 ? _ONE : Q1_/2);
// Get ready to create the 'one_table'
array<ring_elem> polys;
polys.append(_originalR->from_int(0));
ring_elem primelem = prim->get_value();
polys.append(_originalR->copy(primelem));
ring_elem oneR = _originalR->one();
_x_exponent = -1;
ring_elem x = _originalR->var(0);
if (_originalR->is_equal(primelem, x))
_x_exponent = 1;
for (i=2; i<Q_; i++)
{
ring_elem g = _originalR->mult(polys[i-1], primelem);
polys.append(g);
if (_originalR->is_equal(g, oneR)) break;
if (_originalR->is_equal(g, x))
_x_exponent = i;
}
if (polys.length() != Q_)
{
ERROR("GF: primitive element expected");
return false;
}
assert(_x_exponent >= 0);
// Set 'one_table'.
_one_table = newarray_atomic(int,Q_);
_one_table[0] = Q_-1;
for (i=1; i<=Q_-1; i++)
{
if (system_interrupted())
return false;
ring_elem f1 = _originalR->add(polys[i], oneR);
for (j=1; j<=Q_-1; j++)
if (_originalR->is_equal(f1, polys[j]))
break;
_one_table[i] = j;
}
// Create the Z/P ---> GF(Q) inclusion map
_from_int_table = newarray_atomic(int,P);
int a = _ONE;
_from_int_table[0] = _ZERO;
for (i=1; i<P; i++)
{
_from_int_table[i] = a;
a = _one_table[a];
}
zeroV = from_int(0);
oneV = from_int(1);
minus_oneV = from_int(-1);
// M2::GaloisFieldTable G(*_originalR, primelem);
// G.display(std::cout);
return true;
}
int cmd_set_datalink(struct libusb_device_handle* devh, int datalink) {
char dataptr[4];
from_int(datalink, dataptr);
return cmd_setter(devh, DOT11_SET_DATALINK, dataptr, 4);
}
static PyObject *add(BaseTDBResolver *self, PyObject *args, PyObject *kwds) {
char buff[BUFF_SIZE];
char buff2[BUFF_SIZE];
static char *kwlist[] = {"urn", "attribute", "value", "unique", NULL};
TDB_DATA urn;
TDB_DATA attribute;
TDB_DATA key;
PyObject *value_obj, *value_str;
TDB_DATA value;
TDB_DATA offset;
TDB_DATA_LIST i;
uint32_t previous_offset=0;
uint32_t new_offset;
int unique = 0;
attribute.dsize = 0;
urn.dsize = 0;
if(!PyArg_ParseTupleAndKeywords(args, kwds, "s#s#O|L", kwlist,
&urn.dptr, &urn.dsize,
&attribute.dptr, &attribute.dsize,
&value_obj, &unique))
return NULL;
// Convert the object to a string
value_str = PyObject_Str(value_obj);
if(!value_str) return NULL;
PyString_AsStringAndSize(value_str, (char **)&value.dptr,
&value.dsize);
/** If the value is already in the list, we just ignore this
request.
*/
if(unique && is_value_present(self, urn, attribute, value, 1)) {
goto exit;
};
// Ok if we get here, the value is not already stored there.
key.dptr = (unsigned char *)buff;
key.dsize = calculate_key(self, urn, attribute, buff, BUFF_SIZE, 1);
// Lock the data_db to synchronise access to the store:
tdb_lockall(self->data_db);
offset = tdb_fetch(self->data_db, key);
if(offset.dptr) {
previous_offset = to_int(offset);
free(offset.dptr);
};
// Go to the end and write the new record
new_offset = lseek(self->data_store_fd, 0, SEEK_END);
i.offset = previous_offset;
i.length = value.dsize;
write(self->data_store_fd, &i, sizeof(i));
write(self->data_store_fd, value.dptr, value.dsize);
// Now store the offset to this in the tdb database
value.dptr = (unsigned char *)buff2;
value.dsize = from_int(new_offset, buff2, BUFF_SIZE);
tdb_store(self->data_db, key, value, TDB_REPLACE);
// Done
tdb_unlockall(self->data_db);
exit:
Py_DECREF(value_str);
Py_RETURN_NONE;
};
std::string formatter::format(const formatting_options &_opt)
{
formatting_options last_opt, opt(_opt);
std::string result;
if (!opt_stack.empty())
{
int cnt=0;
fo_deque::reverse_iterator i;
for (i=opt_stack.rbegin(); i!=opt_stack.rend(); ++i)
{
if (*i==opt)
break;
++cnt;
}
if (cnt==0)
return "";
if (i!=opt_stack.rend())
{
while (cnt--)
{
result+="</span>";
opt_stack.pop_back();
}
return result;
}
last_opt=opt_stack.back();
}
if (last_opt.chpVAlign!=formatting_options::va_normal
&& last_opt.chpVAlign!=opt.chpVAlign)
{
int cnt=0;
fo_deque::reverse_iterator i;
for (i=opt_stack.rbegin(); i!=opt_stack.rend(); ++i)
{
if (i->chpVAlign==formatting_options::va_normal)
break;
++cnt;
}
while (cnt--)
{
result+="</span>";
opt_stack.pop_back();
}
last_opt=opt_stack.empty()?formatting_options():opt_stack.back();
}
std::string style;
if (opt.chpBold!=last_opt.chpBold)
{
style+="font-weight:";
style+=opt.chpBold?"bold":"normal";
style+=";";
}
if (opt.chpItalic!=last_opt.chpItalic)
{
style+="font-style:";
style+=opt.chpItalic?"italic":"normal";
style+=";";
}
if (opt.chpUnderline!=last_opt.chpUnderline)
{
style+="text-decoration:";
style+=opt.chpUnderline?"underline":"none";
style+=";";
}
if (opt.chpVAlign!=formatting_options::va_normal)
opt.chpFontSize=(int)(0.7*(opt.chpFontSize?opt.chpFontSize:24));
if (opt.chpFontSize!=last_opt.chpFontSize)
{
style+="font-size:";
style+=from_int(opt.chpFontSize/2);
style+="pt;";
}
if (opt.chpVAlign!=last_opt.chpVAlign)
{
style+="vertical-align:";
style+=opt.chpVAlign==formatting_options::va_sub?"sub":"super";
style+=";";
}
if (opt.chpFColor!=last_opt.chpFColor)
{
style+="color:";
style+=opt.chpFColor.r>0?"#"+hex(opt.chpFColor.r&0xFF)
+hex(opt.chpFColor.g&0xFF)
+hex(opt.chpFColor.b&0xFF)
:"WindowText";
style+=";";
}
if (opt.chpBColor!=last_opt.chpBColor)
{
style+="background-color:";
style+=opt.chpBColor.r>0?"#"+hex(opt.chpBColor.r&0xFF)
+hex(opt.chpBColor.g&0xFF)
+hex(opt.chpBColor.b&0xFF)
:"Window";
style+=";";
}
if (opt.chpHighlight!=last_opt.chpHighlight)
{
style+="background-color:";
switch (opt.chpHighlight)
{
case 0: style+="Window"; break;
case 1: style+="black"; break;
case 2: style+="blue"; break;
case 3: style+="aqua"; break;
case 4: style+="lime"; break;
case 5: style+="fuchsia"; break;
case 6: style+="red"; break;
case 7: style+="yellow"; break;
case 9: style+="navy"; break;
case 10: style+="teal"; break;
case 11: style+="green"; break;
case 12: style+="purple"; break;
case 13: style+="maroon"; break;
case 14: style+="olive"; break;
case 15: style+="gray"; break;
case 16: style+="silver"; break;
}
style+=";";
}
if (opt.chpFont!=last_opt.chpFont)
{
style+="font-family:'";
style+=opt.chpFont.name.empty()?"serif":opt.chpFont.name;
style+="'";
switch (opt.chpFont.family)
{
case font::ff_serif: style+=", serif"; break;
case font::ff_sans_serif: style+=", sans-serif"; break;
case font::ff_cursive: style+=", cursive"; break;
case font::ff_fantasy: style+=", fantasy"; break;
case font::ff_monospace: style+=", monospace"; break;
case font::ff_none: break;
}
style+=";";
}
opt_stack.push_back(opt);
return result+"<span style=\""+style+"\">";
}
int cmd_set_channel(struct libusb_device_handle* devh, int channel) {
char dataptr[4];
from_int(channel, dataptr);
return cmd_setter(devh, DOT11_SET_CHANNEL, dataptr, 4);
}
void prep_response(char r)
{
char arg = incoming_packet[2];
switch(r)
{
//Prepare id to be sent
case 'i':
prepare_packet(from_int(slave_id), sizeof(int));
break;
//Type
case 't':
prepare_packet( slave_type, strlen( slave_type ) );
break;
//Name
case 'n':
prepare_packet(slave_name, strlen( slave_name ) );
break;
//Deployment Date
case 'd':
prepare_packet(slave_init_date, sizeof(slave_init_date));
break;
//Number of read channels
case 'r':
prepare_packet(from_int(slave_rcount),sizeof(int));
break;
//Number of write channels
case 'w':
prepare_packet(from_int(slave_wcount),sizeof(int));
break;
//Start measurment on channel
case 'm':
{
//Wait for measurment
unsigned wait = slave_measure();
prepare_packet( from_int(wait), sizeof( unsigned ) );
waiting_measure = 1;
}
break;
//Channel value/output
case 'q':
if(arg < slave_rcount )
{
char* valstr = slave_read( arg );
prepare_packet( valstr, strlen( valstr ) );
}
else
prep_err();
break;
case 'f':
prepare_packet(slave_info, strlen( slave_info ) );
break;
//Echo
case 'e':
prepare_packet("e", 1);
break;
//Error
default:
prep_err();
break;
}
}
