smart_font_rep::smart_font_rep (
string name, font base_fn, font err_fn, string family2, string variant2,
string series2, string shape2, int sz2, int dpi2):
font_rep (name, base_fn), mfam (main_family (family2)),
family (family2), variant (variant2),
series (series2), shape (shape2), rshape (shape2),
sz (sz2), dpi (dpi2),
math_kind (0), italic_nr (-1),
fn (2), sm (get_smart_map (tuple (family2, variant2, series2, shape2)))
{
fn[SUBFONT_MAIN ]= base_fn;
fn[SUBFONT_ERROR]= err_fn;
if (shape == "mathitalic" || shape == "mathupright" || shape == "mathshape") {
if (is_math_family (mfam)) {
rshape= "right";
if (shape == "mathupright")
this->copy_math_pars (base_fn);
else {
tree key= tuple ("math", mfam, variant, series, rshape);
int nr= sm->add_font (key, REWRITE_MATH);
initialize_font (nr);
this->copy_math_pars (fn[nr]);
fn[SUBFONT_MAIN]= fn[nr];
}
}
else {
math_kind= 1;
if (shape == "mathupright") math_kind= 2;
if (shape == "mathshape") math_kind= 3;
rshape= "right";
if (math_kind == 2)
this->copy_math_pars (base_fn);
else {
italic_nr= sm->add_font (tuple ("fast-italic"), REWRITE_NONE);
initialize_font (italic_nr);
this->copy_math_pars (fn[italic_nr]);
}
(void) sm->add_font (tuple ("special"), REWRITE_SPECIAL);
(void) sm->add_font (tuple ("other"), REWRITE_NONE);
(void) sm->add_font (tuple ("regular"), REWRITE_LETTERS);
(void) sm->add_font (tuple ("bold-math"), REWRITE_LETTERS);
(void) sm->add_font (tuple ("italic-math"), REWRITE_LETTERS);
(void) sm->add_font (tuple ("bold-italic-math"), REWRITE_LETTERS);
(void) sm->add_font (tuple ("cal"), REWRITE_LETTERS);
(void) sm->add_font (tuple ("bold-cal"), REWRITE_LETTERS);
(void) sm->add_font (tuple ("frak"), REWRITE_LETTERS);
(void) sm->add_font (tuple ("bold-frak"), REWRITE_LETTERS);
(void) sm->add_font (tuple ("bbb"), REWRITE_LETTERS);
(void) sm->add_font (tuple ("tt"), REWRITE_LETTERS);
(void) sm->add_font (tuple ("ss"), REWRITE_LETTERS);
(void) sm->add_font (tuple ("bold-ss"), REWRITE_LETTERS);
(void) sm->add_font (tuple ("italic-ss"), REWRITE_LETTERS);
(void) sm->add_font (tuple ("bold-italic-ss"), REWRITE_LETTERS);
}
}
}
/**
* @brief Fills the fields from the existing entity.
*/
void EditEntityDialog::initialize() {
initialize_simple_booleans();
initialize_simple_integers();
initialize_simple_strings();
initialize_behavior();
initialize_breed();
initialize_damage_on_enemies();
initialize_destination();
initialize_destination_map();
initialize_direction();
initialize_font();
initialize_ground();
initialize_layer();
initialize_maximum_moves();
initialize_model();
initialize_name();
initialize_opening_method();
initialize_rank();
initialize_savegame_variable();
initialize_size();
initialize_sound();
initialize_sprite();
initialize_subtype();
initialize_transition();
initialize_treasure();
initialize_type();
initialize_weight();
initialize_xy();
adjustSize();
}
void
smart_font_rep::advance (string s, int& pos, string& r, int& nr) {
int* chv= sm->chv;
hashmap<string,int>& cht (sm->cht);
int start= pos;
nr= -1;
while (pos < N(s)) {
if (s[pos] != '<') {
int c= (int) (unsigned char) s[pos];
int next= chv[c];
if (math_kind != 0 && math_kind != 2 && is_letter (c) &&
(pos == 0 || !is_letter (s[pos-1])) &&
(pos+1 == N(s) || !is_letter (s[pos+1])))
next= italic_nr;
else if (chv[c] == -1) next= resolve (s (pos, pos+1));
if (next == nr) pos++;
else if (nr == -1) { pos++; nr= next; }
else break;
}
else {
int end= pos;
tm_char_forwards (s, end);
int next= cht[s (pos, end)];
if (next == -1) next= resolve (s (pos, end));
if (next == nr) pos= end;
else if (nr == -1) { pos= end; nr= next; }
else break;
}
}
r= s (start, pos);
if (nr < 0) return;
if (N(fn) <= nr || is_nil (fn[nr])) initialize_font (nr);
if (sm->fn_rewr[nr] != REWRITE_NONE)
r= rewrite (r, sm->fn_rewr[nr]);
//cout << "Got " << r << " in " << fn[nr]->res_name << "\n";
}
int
smart_font_rep::resolve (string c, string fam, int attempt) {
//cout << "Resolve " << c << " in " << fam << ", attempt " << attempt << "\n";
array<string> a= trimmed_tokenize (fam, "=");
if (N(a) >= 2) {
array<string> given= logical_font (family, variant, series, rshape);
fam= a[1];
array<string> b= tokenize (a[0], " ");
for (int i=0; i<N(b); i++) {
if (b[i] == "") continue;
bool ok= false;
array<string> v= tokenize (b[i], "|");
for (int j=0; j<N(v); j++) {
string wanted= locase_all (v[j]);
if (wanted == "") ok= true;
else if (contains (wanted, given)) ok= true;
else if (wanted == get_unicode_range (c)) ok= true;
else if (wanted == substitute_math_letter (c, 2)) ok= true;
else if (wanted == c) ok= true;
else {
array<string> w= tokenize (v[j], ":");
if (N(w) == 1) w << w[0];
if (N(w) == 2) {
int code = get_utf8_code (c);
int start= get_utf8_code (w[0]);
int end = get_utf8_code (w[1]);
if (code != -1 && code >= start && code <= end) ok= true;
}
}
}
if (!ok) return -1;
}
}
if (attempt == 1) {
bool ok= true;
if (fam == "cal" || fam == "cal*" ||
fam == "Bbb" || fam == "Bbb****")
ok= ok && is_alpha (c) && upcase_all (c) == c;
if (fam == "cal**" || fam == "Bbb*")
ok= ok && is_alpha (c);
if (!ok) return -1;
if (fam == mfam) {
if (fn[SUBFONT_MAIN]->supports (c))
return sm->add_char (tuple ("main"), c);
}
else {
font cfn= closest_font (fam, variant, series, rshape, sz, dpi, 1);
if (cfn->supports (c)) {
tree key= tuple (fam, variant, series, rshape, "1");
return sm->add_char (key, c);
}
}
if (is_math_family (fam)) {
tree key= tuple ("math", fam, variant, series, rshape);
int nr= sm->add_font (key, REWRITE_MATH);
initialize_font (nr);
if (fn[nr]->supports (rewrite (c, REWRITE_MATH)))
return sm->add_char (key, c);
}
if (fam == "roman" && N(c) > 1) {
tree key= tuple ("cyrillic", fam, variant, series, rshape);
int nr= sm->add_font (key, REWRITE_CYRILLIC);
initialize_font (nr);
if (fn[nr]->supports (rewrite (c, REWRITE_CYRILLIC)))
return sm->add_char (key, c);
}
}
if (attempt > 1) {
string range= get_unicode_range (c);
if (range != "") {
int a= attempt - 1;
string v= variant;
if (v == "rm") v= range;
else v= v * "-" * range;
font cfn= closest_font (fam, v, series, rshape, sz, dpi, a);
//cout << "Trying " << c << " in " << cfn->res_name << "\n";
if (cfn->supports (c)) {
tree key= tuple (fam, v, series, rshape, as_string (a));
return sm->add_char (key, c);
}
}
}
return -1;
}
c_text_display::c_text_display()
{
initialize_font();
}
