void encoding(T state, Encoding* obj) {
if(obj->nil_p() || (!CBOOL(ascii_only()) && obj->ascii_compatible())) {
ascii_only(cNil);
num_chars(nil<Fixnum>());
valid_encoding(cNil);
}
if(byte_size() == 0 && !obj->nil_p() && obj->ascii_compatible()) {
ascii_only(cTrue);
num_chars(Fixnum::from(0));
valid_encoding(cTrue);
}
encoding(obj);
state->memory()->write_barrier(this, obj);
}
bool speech_dialog::scroll_text()
{
if(text_char_ < num_chars()) {
text_char_ = num_chars();
return false;
}
if(text_.size() > 2) {
markup_.erase(markup_.begin());
text_.erase(text_.begin());
text_char_ = text_.front().size();
return false;
}
return true;
}
void num_bytes(T state, Fixnum* obj) {
num_bytes(obj);
num_chars(nil<Fixnum>());
if(type_specific() == eRString) {
write_rstring(state);
}
}
hw_string* create_response_buffer(hw_http_response* response)
{
http_response* resp = (http_response*)response;
hw_string* response_string = malloc(sizeof(hw_string));
hw_string* cached_entry = get_cached_request(resp->status_code.value);
hw_string content_length;
int i = 0;
char length_header[] = "Content-Length: ";
int line_sep_size = sizeof(CRLF);
int header_buffer_incr = 512;
int body_size = resp->body.length + line_sep_size;
int header_size_remaining = header_buffer_incr;
int response_size = header_size_remaining + sizeof(length_header) + num_chars(resp->body.length) + 2 * line_sep_size + body_size + line_sep_size;
response_string->value = malloc(response_size);
response_string->length = 0;
append_string(response_string, cached_entry);
for (i=0; i< resp->number_of_headers; i++)
{
http_header header = resp->headers[i];
header_size_remaining -= header.name.length + 2 + header.value.length + line_sep_size;
if (header_size_remaining < 0) {
header_size_remaining += header_buffer_incr * ((-header_size_remaining/header_buffer_incr) + 1);
response_size += header_size_remaining;
response_string->value = realloc(response_string->value, response_size);
}
append_string(response_string, &header.name);
APPENDSTRING(response_string, ": ");
append_string(response_string, &header.value);
APPENDSTRING(response_string, CRLF);
}
/* Add the body */
APPENDSTRING(response_string, length_header);
string_from_int(&content_length, body_size, 10);
append_string(response_string, &content_length);
APPENDSTRING(response_string, CRLF CRLF);
if (resp->body.length > 0)
{
append_string(response_string, &resp->body);
}
APPENDSTRING(response_string, CRLF);
response_string->value[response_string->length] = '\0';
return response_string;
}
bool speech_dialog::process()
{
if(is_skipping_game()) {
return true;
}
++cycle_;
if(text_char_ < num_chars()) {
++text_char_;
}
const int ScrollSpeed = 20;
if(left_side_speaking_) {
if(horizontal_position_ > 0) {
horizontal_position_ -= ScrollSpeed;
if(horizontal_position_ < 0) {
horizontal_position_ = 0;
}
}
} else {
const int width = gui_section::get("speech_portrait_pane")->width();
if(horizontal_position_ < width) {
horizontal_position_ += ScrollSpeed;
if(horizontal_position_ > width) {
horizontal_position_ = width;
}
}
}
#if !defined(__ANDROID__)
if(expiration_ <= 0) {
joystick::update();
if(!joystick_up_pressed_ && joystick::up()) {
move_up();
}
if(!joystick_down_pressed_ && joystick::down()) {
move_down();
}
}
joystick_up_pressed_ = joystick::up();
joystick_down_pressed_ = joystick::down();
#endif
return cycle_ == expiration_;
}
bool speech_dialog::key_press(const SDL_Event& event)
{
static int last_mouse = 0;
if(text_char_ == num_chars() && options_.empty() == false) {
if(event.type == SDL_KEYDOWN) {
if(event.key.keysym.scancode == get_keycode(controls::CONTROL_UP)) {
move_up();
} else if(event.key.keysym.scancode == get_keycode(controls::CONTROL_DOWN)) {
move_down();
} else if(event.key.keysym.sym == SDLK_RETURN || event.key.keysym.sym == SDLK_SPACE ||
event.key.keysym.scancode == get_keycode(controls::CONTROL_JUMP) ||
event.key.keysym.scancode == get_keycode(controls::CONTROL_TONGUE)) {
return true;
}
}
#if defined(__ANDROID__)
// XXX: todo
#elif TARGET_IPHONE_SIMULATOR || TARGET_OS_IPHONE || TARGET_BLACKBERRY
if(event.type == SDL_MOUSEBUTTONDOWN)
{
last_mouse = event.button.which;
handle_mouse_move(event.button.x, event.button.y);
}
if (event.type == SDL_MOUSEMOTION)
{
if (event.motion.which == last_mouse)
handle_mouse_move(event.motion.x, event.motion.y);
}
if (event.type == SDL_MOUSEBUTTONUP)
{
if (event.motion.which == last_mouse)
{
last_mouse = -1;
return handle_mouse_move(event.motion.x, event.motion.y);
}
}
#endif
return false;
} else if (event.type != SDL_KEYDOWN && event.type != SDL_MOUSEBUTTONDOWN) {
return false; // only keydown and mousebuttondown should be handled by the rest of the function
}
return scroll_text();
}
static void
draw_controls (VidState *s)
{
int i;
if (s->control) {
for (i = 0; i < s->num_controls; i++) {
ControlInfo * ci = s->control_info + i;
if (ci->widget)
gtk_widget_destroy (ci->widget);
if (ci->label)
gtk_widget_destroy (ci->label);
if (ci->labelval)
gtk_widget_destroy (ci->labelval);
}
free (s->control_info);
s->control_info = NULL;
input_free_controls (s->control, s->num_controls);
s->control = NULL;
}
s->control = input_enum_controls (videoIn, &s->num_controls);
//fprintf(stderr,"V4L2_CID_BASE=0x%x\n",V4L2_CID_BASE);
//fprintf(stderr,"V4L2_CID_PRIVATE_BASE=0x%x\n",V4L2_CID_PRIVATE_BASE);
//fprintf(stderr,"V4L2_CID_PRIVATE_LAST=0x%x\n",V4L2_CID_PRIVATE_LAST);
fprintf(stderr,"Controls:\n");
for (i = 0; i < s->num_controls; i++) {
fprintf(stderr,"control[%d]: 0x%x",i,s->control[i].id);
fprintf (stderr," %s, %d:%d:%d, default %d\n", s->control[i].name,
s->control[i].min, s->control[i].step, s->control[i].max,
s->control[i].default_val);
}
if((s->control_info = malloc (s->num_controls * sizeof (ControlInfo)))==NULL){
printf("couldn't allocate memory for: s->control_info\n");
exit(1);
}
for (i = 0; i < s->num_controls; i++) {
ControlInfo * ci = s->control_info + i;
InputControl * c = s->control + i;
ci->idx = i;
ci->widget = NULL;
ci->label = NULL;
ci->labelval = NULL;
if (c->id == V4L2_CID_EXPOSURE_AUTO) {
int val;
ci->widget = gtk_check_button_new_with_label (c->name);
g_object_set_data (G_OBJECT (ci->widget), "control_info", ci);
gtk_widget_show (ci->widget);
gtk_table_attach (GTK_TABLE (s->table), ci->widget, 1, 3, 3+i, 4+i,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0, 0);
if (input_get_control (videoIn, c, &val) == 0) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ci->widget),
val==AUTO_EXP ? TRUE : FALSE);
}
else {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ci->widget),
c->default_val==AUTO_EXP ? TRUE : FALSE);
gtk_widget_set_sensitive (ci->widget, FALSE);
}
if (!c->enabled) {
gtk_widget_set_sensitive (ci->widget, FALSE);
}
g_signal_connect (G_OBJECT (ci->widget), "toggled",
G_CALLBACK (check_changed), s);
} else if (c->type == INPUT_CONTROL_TYPE_INTEGER) {
PangoFontDescription * desc;
int val;
if (c->step == 0)
c->step = 1;
ci->widget = gtk_hscale_new_with_range (c->min, c->max, c->step);
gtk_scale_set_draw_value (GTK_SCALE (ci->widget), FALSE);
/* This is a hack to use always round the HScale to integer
* values. Strangely, this functionality is normally only
* available when draw_value is TRUE. */
GTK_RANGE (ci->widget)->round_digits = 0;
gtk_table_attach (GTK_TABLE (s->table), ci->widget, 1, 2, 3+i, 4+i,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0, 0);
g_object_set_data (G_OBJECT (ci->widget), "control_info", ci);
ci->maxchars = MAX (num_chars (c->min), num_chars (c->max));
gtk_widget_show (ci->widget);
ci->labelval = gtk_label_new (NULL);
gtk_table_attach (GTK_TABLE (s->table), ci->labelval, 2, 3,
3+i, 4+i, GTK_FILL, 0, 0, 0);
desc = pango_font_description_new ();
pango_font_description_set_family_static (desc, "monospace");
gtk_widget_modify_font (ci->labelval, desc);
gtk_misc_set_alignment (GTK_MISC (ci->labelval), 1, 0.5);
if (input_get_control (videoIn, c, &val) == 0) {
gtk_range_set_value (GTK_RANGE (ci->widget), val);
}
else {
gtk_range_set_value (GTK_RANGE (ci->widget), c->default_val);
gtk_widget_set_sensitive (ci->widget, FALSE);
gtk_widget_set_sensitive (ci->labelval, FALSE);
}
if (!c->enabled) {
gtk_widget_set_sensitive (ci->widget, FALSE);
gtk_widget_set_sensitive (ci->labelval, FALSE);
}
set_slider_label (GTK_RANGE (ci->widget));
g_signal_connect (G_OBJECT (ci->widget), "value-changed",
G_CALLBACK (slider_changed), s);
gtk_widget_show (ci->labelval);
ci->label = gtk_label_new (g_strdup_printf ("%s:", c->name));
}
else if (c->type == INPUT_CONTROL_TYPE_BOOLEAN) {
int val;
ci->widget = gtk_check_button_new_with_label (c->name);
g_object_set_data (G_OBJECT (ci->widget), "control_info", ci);
gtk_widget_show (ci->widget);
gtk_table_attach (GTK_TABLE (s->table), ci->widget, 1, 3, 3+i, 4+i,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0, 0);
if (input_get_control (videoIn, c, &val) == 0) {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ci->widget),
val ? TRUE : FALSE);
}
else {
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (ci->widget),
c->default_val ? TRUE : FALSE);
gtk_widget_set_sensitive (ci->widget, FALSE);
}
if (!c->enabled) {
gtk_widget_set_sensitive (ci->widget, FALSE);
}
g_signal_connect (G_OBJECT (ci->widget), "toggled",
G_CALLBACK (check_changed), s);
}
else if (c->type == INPUT_CONTROL_TYPE_MENU) {
int val, j;
ci->widget = gtk_combo_box_new_text ();
for (j = 0; j <= c->max; j++) {
gtk_combo_box_append_text (GTK_COMBO_BOX (ci->widget), c->entries[j]);
}
gtk_table_attach (GTK_TABLE (s->table), ci->widget, 1, 3, 3+i, 4+i,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0, 0);
g_object_set_data (G_OBJECT (ci->widget), "control_info", ci);
gtk_widget_show (ci->widget);
if (input_get_control (videoIn, c, &val) == 0) {
gtk_combo_box_set_active (GTK_COMBO_BOX (ci->widget), val);
}
else {
gtk_combo_box_set_active (GTK_COMBO_BOX (ci->widget), c->default_val);
gtk_widget_set_sensitive (ci->widget, FALSE);
}
if (!c->enabled) {
gtk_widget_set_sensitive (ci->widget, FALSE);
}
g_signal_connect (G_OBJECT (ci->widget), "changed",
G_CALLBACK (combo_changed), s);
ci->label = gtk_label_new (g_strdup_printf ("%s:", c->name));
}
else {
fprintf (stderr, "TODO: implement menu and button\n");
continue;
}
if (ci->label) {
gtk_misc_set_alignment (GTK_MISC (ci->label), 1, 0.5);
gtk_table_attach (GTK_TABLE (s->table), ci->label, 0, 1, 3+i, 4+i,
GTK_FILL, 0, 0, 0);
gtk_widget_show (ci->label);
}
}
}
void num_bytes(T state, Fixnum* obj) {
num_bytes(obj);
num_chars(nil<Fixnum>());
update_handle(state);
}
void speech_dialog::draw() const
{
static const const_gui_section_ptr top_corner = gui_section::get("speech_dialog_top_corner");
static const const_gui_section_ptr bottom_corner = gui_section::get("speech_dialog_bottom_corner");
static const const_gui_section_ptr top_edge = gui_section::get("speech_dialog_top_edge");
static const const_gui_section_ptr bottom_edge = gui_section::get("speech_dialog_bottom_edge");
static const const_gui_section_ptr side_edge = gui_section::get("speech_dialog_side_edge");
static const const_gui_section_ptr arrow = gui_section::get("speech_dialog_arrow");
const_graphical_font_ptr font = graphical_font::get("default");
const int TextAreaHeight = 80;
const int TextBorder = 10;
int speaker_xpos = INT_MAX;
int speaker_ypos = INT_MAX;
const_entity_ptr speaker = left_side_speaking_ ? left_ : right_;
if(speaker) {
const screen_position& pos = last_draw_position();
const int screen_x = pos.x/100 + (graphics::screen_width()/2)*(-1.0/pos.zoom + 1.0);
const int screen_y = pos.y/100 + (graphics::screen_height()/2)*(-1.0/pos.zoom + 1.0);
speaker_xpos = (speaker->feet_x() - screen_x)*pos.zoom - 36;
speaker_ypos = (speaker->feet_y() - screen_y)*pos.zoom - 10;
}
if(pane_area_.w() == 0) {
pane_area_ = rect(
top_corner->width(),
preferences::virtual_screen_height() - TextAreaHeight + TextBorder,
preferences::virtual_screen_width() - top_corner->width()*2,
TextAreaHeight - bottom_corner->height());
if(speaker_ypos < 100) {
pane_area_ = rect(pane_area_.x(), top_corner->height() + 50, pane_area_.w(), pane_area_.h());
}
}
const rect text_area(pane_area_.x()-30, pane_area_.y()-30, pane_area_.w()+60, pane_area_.h()+60);
graphics::draw_rect(pane_area_, graphics::color(85, 53, 53, 255));
top_corner->blit(pane_area_.x() - top_corner->width(), pane_area_.y() - top_corner->height());
top_corner->blit(pane_area_.x2()-1, pane_area_.y() - top_corner->height(), -top_corner->width(), top_corner->height());
top_edge->blit(pane_area_.x(), pane_area_.y() - top_edge->height(), pane_area_.w(), top_edge->height());
bottom_corner->blit(pane_area_.x() - bottom_corner->width(), pane_area_.y2());
bottom_corner->blit(pane_area_.x2()-1, pane_area_.y2(), -bottom_corner->width(), bottom_corner->height());
bottom_edge->blit(pane_area_.x(), pane_area_.y2(), pane_area_.w(), bottom_edge->height());
side_edge->blit(pane_area_.x() - side_edge->width(), pane_area_.y(), side_edge->width(), pane_area_.h());
side_edge->blit(pane_area_.x2()-1, pane_area_.y(), -side_edge->width(), pane_area_.h());
if(speaker) {
//if the arrow to the speaker is within reasonable limits, then
//blit it.
if(speaker_xpos > top_corner->width() && speaker_xpos < graphics::screen_width() - top_corner->width() - arrow->width()) {
arrow->blit(speaker_xpos, pane_area_.y() - arrow->height() - 32);
}
}
//we center our text. Create a vector of the left edge of the text.
std::vector<int> text_left_align;
int total_height = 0;
for(int n = 0; n < text_.size(); ++n) {
rect area = font->dimensions(text_[n]);
if(n < 2) {
total_height += area.h();
}
const int width = area.w();
const int left = text_area.x() + text_area.w()/2 - width/2;
text_left_align.push_back(left);
}
int ypos = text_area.y() + (text_area.h() - total_height)/2;
int nchars = text_char_;
for(int n = 0; n < 2 && n < text_.size() && nchars > 0; ++n) {
std::string str(text_[n].begin(), text_[n].begin() +
std::min<int>(nchars, text_[n].size()));
//move the first line slightly up so that accents don't mess up centering
rect area = font->dimensions(str);
area = rect(text_left_align[n], ypos - 2, area.w(), area.h());
//draw the font by chunks of markup.
int xadj = 0;
const std::vector<TextMarkup>& markup = markup_[n];
for(int m = 0; m != markup.size(); ++m) {
const int begin_index = markup[m].begin;
const int end_index = std::min<int>(str.size(), m+1 == markup.size() ? str.size() : markup[m+1].begin);
if(begin_index >= end_index) {
continue;
}
if(markup[m].color) {
markup[m].color->set_as_current_color();
} else {
//default color of fonts.
glColor4ub(255, 187, 10, 255);
}
const rect r = font->draw(text_left_align[n] + xadj, ypos - 2, std::string(str.begin() + begin_index, str.begin() + end_index));
xadj += r.w();
}
glColor4f(1.0, 1.0, 1.0, 1.0);
//add some space between the lines
ypos = area.y2() + 4;
nchars -= text_[n].size();
}
if(text_.size() > 2 && text_char_ == num_chars() && (cycle_&16)) {
const_gui_section_ptr down_arrow = gui_section::get("speech_text_down_arrow");
down_arrow->blit(text_area.x2() - down_arrow->width() - 10, text_area.y2() - down_arrow->height() - 10);
}
if(text_char_ == num_chars() && options_.empty() == false) {
//const_gui_section_ptr options_panel = gui_section::get("speech_portrait_pane");
const_framed_gui_element_ptr options_panel = framed_gui_element::get("regular_window");
int xpos = graphics::screen_width() - OptionsX - option_width_ - OptionsBorder*2;
int ypos = graphics::screen_height() - OptionsY - OptionHeight*options_.size() - OptionsBorder*2;
options_panel->blit(xpos, ypos, OptionsBorder*2 + option_width_, OptionsBorder*2 + OptionHeight*options_.size(), true);
xpos += OptionsBorder + OptionXPad;
ypos += OptionsBorder;
glColor4ub(255, 187, 10, 255);
int index = 0;
foreach(const std::string& option, options_) {
#if TARGET_IPHONE_SIMULATOR || TARGET_OS_IPHONE
if(index == option_selected_) {
graphics::draw_rect(rect(xpos-OptionXPad, ypos, option_width_, OptionHeight), graphics::color(0xC74545FF));
glColor4ub(255, 187, 10, 255); //reset color to what it was, since draw_rect changes it
}
#endif
rect area = font->dimensions(option);
area = font->draw(xpos, ypos+(OptionHeight/3-area.h()/4), option);
#if !TARGET_IPHONE_SIMULATOR && !TARGET_OS_IPHONE
if(index == option_selected_) {
const_gui_section_ptr cursor = gui_section::get("cursor");
cursor->blit(area.x2(), area.y());
}
#endif
ypos += OptionHeight;
++index;
}
glColor4f(1.0, 1.0, 1.0, 1.0);
}
