source/entry.cpp

   1 #include <msp/gl/matrix.h>
   2 #include <msp/gl/meshbuilder.h>
   3 #include <msp/gl/texture.h>
   4 #include <msp/input/keys.h>
   5 #include "entry.h"
   6 #include "graphic.h"
   7 #include "part.h"
   8 #include "style.h"
   9 #include "vslider.h"
  10
  11 using namespace std;
  12
  13 namespace Msp {
  14 namespace GLtk {
  15
  16 Entry::Entry(const string &t):
  17         text(),
  18         multiline(false),
  19         edit_width(10),
  20         edit_height(1),
  21         edit_pos(0),
  22         first_row(0),
  23         visible_rows(1),
  24         text_part(0),
  25         slider(0),
  26         got_key_press(false)
  27 {
  28         set_text(t);
  29 }
  30
  31 void Entry::autosize()
  32 {
  33         if(!style)
  34                 return;
  35
  36         Widget::autosize();
  37
  38         if(text_part)
  39         {
  40                 const Sides &margin = text_part->get_margin();
  41                 const GL::Font &font = style->get_font();
  42                 unsigned en_width = static_cast<unsigned>(font.get_string_width("n")*style->get_font_size());
  43                 geom.w = max(geom.w, edit_width*en_width+margin.left+margin.right);
  44
  45                 unsigned line_height = static_cast<unsigned>((font.get_ascent()-font.get_descent())*style->get_font_size());
  46                 if(multiline)
  47                 {
  48                         unsigned line_spacing = style->get_font_size()*6/5;
  49                         geom.h = max(geom.h, line_height+line_spacing*(edit_height-1)+margin.top+margin.bottom);
  50                 }
  51                 else
  52                         geom.h = max(geom.h, line_height+margin.top+margin.bottom);
  53         }
  54
  55         if(multiline)
  56         {
  57                 if(const Part *slider_part = style->get_part("slider"))
  58                 {
  59                         Geometry sgeom = slider_part->get_geometry();
  60                         if(!sgeom.w || !sgeom.h)
  61                         {
  62                                 slider->autosize();
  63                                 if(!sgeom.w)
  64                                         sgeom.w = slider->get_geometry().w;
  65                                 if(!sgeom.h)
  66                                         sgeom.h = slider->get_geometry().h;
  67                         }
  68
  69                         const Sides &margin = slider_part->get_margin();
  70                         geom.w = max(geom.w, sgeom.w+margin.left+margin.right);
  71                         geom.h = max(geom.h, sgeom.h+margin.top+margin.bottom);
  72
  73                         reposition_slider();
  74                 }
  75
  76                 check_view_range();
  77         }
  78
  79         rebuild();
  80 }
  81
  82 void Entry::set_text(const string &t)
  83 {
  84         text = t;
  85         edit_pos = text.size();
  86
  87         if(multiline)
  88                 check_view_range();
  89
  90         rebuild();
  91 }
  92
  93 void Entry::set_edit_size(unsigned w, unsigned h)
  94 {
  95         edit_width = w;
  96         edit_height = h;
  97         signal_autosize_changed.emit();
  98 }
  99
 100 void Entry::set_multiline(bool m)
 101 {
 102         multiline = m;
 103         if(multiline)
 104         {
 105                 if(!slider)
 106                 {
 107                         slider = new VSlider;
 108                         add(*slider);
 109                         slider->set_step(1);
 110                         slider->signal_value_changed.connect(sigc::mem_fun(this, &Entry::slider_value_changed));
 111                         reposition_slider();
 112                 }
 113                 check_view_range();
 114         }
 115 }
 116
 117 void Entry::rebuild_special(const Part &part, CachedPart &cache)
 118 {
 119         if(part.get_name()=="text")
 120                 text.build(part, geom, first_row, cache);
 121         else if(part.get_name()=="cursor")
 122         {
 123                 const Graphic *graphic = part.get_graphic(state);
 124                 if(!text_part || !graphic)
 125                 {
 126                         cache.texture = 0;
 127                         return;
 128                 }
 129
 130                 unsigned row, col;
 131                 text.offset_to_coords(edit_pos, row, col);
 132
 133                 if(row<first_row || row>=first_row+visible_rows)
 134                 {
 135                         cache.texture = 0;
 136                         return;
 137                 }
 138
 139                 Geometry rgeom = text.coords_to_geometry(*text_part, geom, first_row, row, col);
 140
 141                 cache.texture = graphic->get_texture();
 142                 cache.clear_mesh();
 143
 144                 GL::MeshBuilder bld(*cache.mesh);
 145                 bld.matrix() *= GL::Matrix::translation(rgeom.x, rgeom.y, 0);
 146                 graphic->build(part.get_geometry().w, part.get_geometry().h, bld);
 147         }
 148 }
 149
 150 void Entry::render_special(const Part &part, GL::Renderer &renderer) const
 151 {
 152         if(part.get_name()=="slider" && multiline)
 153                 slider->render(renderer);
 154 }
 155
 156 void Entry::key_press(unsigned key, unsigned)
 157 {
 158         got_key_press = true;
 159         if(key==Input::KEY_LEFT)
 160         {
 161                 if(edit_pos>0)
 162                         set_edit_position(edit_pos-1);
 163         }
 164         else if(key==Input::KEY_RIGHT)
 165         {
 166                 if(edit_pos<text.size())
 167                         set_edit_position(edit_pos+1);
 168         }
 169         else if(key==Input::KEY_DOWN && multiline)
 170         {
 171                 unsigned row, col;
 172                 text.offset_to_coords(edit_pos, row, col);
 173                 set_edit_position(text.coords_to_offset(row+1, col));
 174         }
 175         else if(key==Input::KEY_UP && multiline)
 176         {
 177                 unsigned row, col;
 178                 text.offset_to_coords(edit_pos, row, col);
 179                 set_edit_position(row>0 ? text.coords_to_offset(row-1, col) : 0);
 180         }
 181         else if(key==Input::KEY_BACKSPACE)
 182         {
 183                 if(edit_pos>0)
 184                 {
 185                         text.erase(--edit_pos, 1);
 186                         check_view_range();
 187                         rebuild();
 188                 }
 189         }
 190         else if(key==Input::KEY_ENTER)
 191         {
 192                 if(multiline)
 193                 {
 194                         text.insert(edit_pos++, "\n");
 195                         check_view_range();
 196                         rebuild();
 197                 }
 198                 else
 199                         signal_enter.emit();
 200         }
 201 }
 202
 203 void Entry::character(wchar_t ch)
 204 {
 205         if(got_key_press && ch>=' ')
 206         {
 207                 text.insert(edit_pos, StringCodec::encode<StringCodec::Utf8>(StringCodec::ustring(1, ch)));
 208                 ++edit_pos;
 209                 rebuild();
 210         }
 211 }
 212
 213 void Entry::focus_out()
 214 {
 215         Widget::focus_out();
 216         got_key_press = false;
 217 }
 218
 219 void Entry::on_geometry_change()
 220 {
 221         reposition_slider();
 222
 223         if(multiline)
 224                 check_view_range();
 225 }
 226
 227 void Entry::on_style_change()
 228 {
 229         text.set_style(style);
 230
 231         if(!style)
 232         {
 233                 text_part = 0;
 234                 return;
 235         }
 236
 237         text_part = style->get_part("text");
 238
 239         reposition_slider();
 240
 241         if(multiline)
 242                 check_view_range();
 243 }
 244
 245 void Entry::set_edit_position(unsigned ep)
 246 {
 247         edit_pos = ep;
 248         check_view_range();
 249         rebuild();
 250 }
 251
 252 void Entry::reposition_slider()
 253 {
 254         if(!style || !slider)
 255                 return;
 256
 257         if(const Part *slider_part = style->get_part("slider"))
 258         {
 259                 Geometry sgeom = slider_part->get_geometry();
 260                 if(!sgeom.w || !sgeom.h)
 261                 {
 262                         slider->autosize();
 263                         if(!sgeom.w)
 264                                 sgeom.w = slider->get_geometry().w;
 265                         if(!sgeom.h)
 266                                 sgeom.h = slider->get_geometry().h;
 267                 }
 268
 269                 slider_part->get_alignment().apply(sgeom, geom, slider_part->get_margin());
 270                 slider->set_geometry(sgeom);
 271         }
 272 }
 273
 274 void Entry::check_view_range()
 275 {
 276         if(!multiline || !text_part)
 277                 return;
 278
 279         float font_size = style->get_font_size();
 280         unsigned line_spacing = static_cast<unsigned>(font_size*6/5);
 281
 282         const Sides &margin = text_part->get_margin();
 283         visible_rows = max((geom.h-margin.top-margin.bottom)/line_spacing, 1U);
 284
 285         unsigned row, col;
 286         text.offset_to_coords(edit_pos, row, col);
 287
 288         if(first_row>row)
 289                 first_row = row;
 290         else if(row>=first_row+visible_rows)
 291                 first_row = row+1-visible_rows;
 292
 293         unsigned scroll = max(text.get_n_lines(), visible_rows)-visible_rows;
 294         slider->set_range(0, scroll);
 295         slider->set_value(scroll-first_row);
 296 }
 297
 298 void Entry::slider_value_changed(double value)
 299 {
 300         if(text.get_n_lines()>visible_rows)
 301                 first_row = text.get_n_lines()-visible_rows-static_cast<unsigned>(value);
 302 }
 303
 304 } // namespace GLtk
 305 } // namespace Msp