source/list.cpp

   1 /* $Id$
   2
   3 This file is part of libmspgltk
   4 Copyright © 2007-2011  Mikko Rasa, Mikkosoft Productions
   5 Distributed under the LGPL
   6 */
   7
   8 #include <msp/gl/immediate.h>
   9 #include <msp/gl/matrix.h>
  10 #include <msp/gl/transform.h>
  11 #include "graphic.h"
  12 #include "list.h"
  13 #include "part.h"
  14 #include "style.h"
  15 #include "text.h"
  16 #include "vslider.h"
  17
  18 using namespace std;
  19
  20 namespace Msp {
  21 namespace GLtk {
  22
  23 List::List():
  24         sel_index(-1),
  25         first(0),
  26         n_visible(1),
  27         row_height(1),
  28         items_part(0)
  29 {
  30         add(slider);
  31         slider.set_step(1);
  32         slider.signal_value_changed.connect(sigc::mem_fun(this, &List::slider_value_changed));
  33 }
  34
  35 void List::autosize()
  36 {
  37         autosize_rows(5);
  38 }
  39
  40 void List::autosize_rows(unsigned n)
  41 {
  42         if(!style)
  43                 return;
  44
  45         Widget::autosize();
  46
  47         if(items_part)
  48         {
  49                 const Sides &margin = items_part->get_margin();
  50                 float font_size = style->get_font()->get_default_size();
  51
  52                 unsigned max_w = 0;
  53                 for(vector<string>::iterator i=items.begin(); i!=items.end(); ++i)
  54                 {
  55                         unsigned w = static_cast<unsigned>(style->get_font()->get_string_width(*i)*font_size);
  56                         max_w = max(max_w, w);
  57                 }
  58
  59                 geom.w = max(geom.w, max_w+margin.left+margin.right);
  60                 geom.h = max(geom.h, n*row_height+margin.top+margin.bottom);
  61         }
  62
  63         if(const Part *slider_part = style->get_part("slider"))
  64         {
  65                 Geometry sgeom = slider_part->get_geometry();
  66                 if(!sgeom.w || !sgeom.h)
  67                 {
  68                         slider.autosize();
  69                         if(!sgeom.w)
  70                                 sgeom.w = slider.get_geometry().w;
  71                         if(!sgeom.h)
  72                                 sgeom.h = slider.get_geometry().h;
  73                 }
  74
  75                 const Sides &margin = slider_part->get_margin();
  76                 geom.w = max(geom.w, sgeom.w+margin.left+margin.right);
  77                 geom.h = max(geom.h, sgeom.h+margin.top+margin.bottom);
  78
  79                 reposition_slider();
  80         }
  81
  82         check_view_range();
  83 }
  84
  85 void List::autosize_all()
  86 {
  87         autosize_rows(items.size());
  88 }
  89
  90 void List::append(const string &v)
  91 {
  92         items.push_back(v);
  93         check_view_range();
  94 }
  95
  96 void List::insert(unsigned i, const string &v)
  97 {
  98         if(i>items.size())
  99                 throw InvalidParameterValue("Index out of range");
 100
 101         items.insert(items.begin()+i, v);
 102         check_view_range();
 103 }
 104
 105 void List::remove(unsigned i)
 106 {
 107         if(i>items.size())
 108                 throw InvalidParameterValue("Index out of range");
 109
 110         items.erase(items.begin()+i);
 111         if(sel_index>static_cast<int>(i))
 112                 --sel_index;
 113         else if(sel_index==static_cast<int>(i))
 114                 sel_index = -1;
 115
 116         check_view_range();
 117 }
 118
 119 void List::clear()
 120 {
 121         items.clear();
 122         sel_index = -1;
 123
 124         check_view_range();
 125 }
 126
 127 void List::set_selected_index(int i)
 128 {
 129         if(i<0)
 130                 sel_index = -1;
 131         else if(i<static_cast<int>(items.size()))
 132         {
 133                 sel_index = i;
 134                 signal_item_selected.emit(sel_index, items[sel_index]);
 135         }
 136         else
 137                 throw InvalidParameterValue("Index out of range");
 138 }
 139
 140 const string &List::get_selected() const
 141 {
 142         if(sel_index<0)
 143                 throw InvalidState("No selection");
 144
 145         return items[sel_index];
 146 }
 147
 148 void List::render_special(const Part &part) const
 149 {
 150         if(part.get_name()=="items")
 151         {
 152                 const Sides &margin = part.get_margin();
 153                 Geometry pgeom = geom;
 154                 pgeom.h = row_height+margin.top+margin.bottom;
 155
 156                 GL::PushMatrix push_mtx;
 157                 GL::translate(0, geom.h-pgeom.h, 0);
 158
 159                 for(unsigned i=0; (i<n_visible && first+i<items.size()); ++i)
 160                 {
 161                         if(i!=0)
 162                                 GL::translate(0, -static_cast<int>(row_height), 0);
 163                         Text(*style, items[first+i]).render(part, pgeom);
 164                 }
 165         }
 166         else if(part.get_name()=="selection")
 167         {
 168                 if(sel_index>=static_cast<int>(first) && sel_index<static_cast<int>(first+n_visible))
 169                 {
 170                         const Sides &margin = part.get_margin();
 171
 172                         Geometry pgeom = geom;
 173                         pgeom.h = row_height;
 174                         pgeom.w -= margin.left+margin.right;
 175
 176                         Geometry rgeom = part.get_geometry();
 177                         rgeom.y += geom.h-margin.top-row_height*(sel_index-first+1);
 178                         rgeom.x += margin.left;
 179                         part.get_alignment().apply(rgeom, pgeom);
 180
 181                         GL::push_matrix();
 182                         GL::translate(rgeom.x, rgeom.y, 0);
 183                         part.get_graphic(state)->render(rgeom.w, rgeom.h);
 184                         GL::pop_matrix();
 185                 }
 186         }
 187         else if(part.get_name()=="slider")
 188                 slider.render();
 189 }
 190
 191 void List::button_press(int x, int y, unsigned btn)
 192 {
 193         Container::button_press(x, y, btn);
 194         if(!click_focus && btn==1)
 195         {
 196                 if(items_part)
 197                         y += items_part->get_margin().top;
 198
 199                 unsigned i = (geom.h-1-y)/row_height;
 200                 if(i<n_visible && first+i<items.size())
 201                 {
 202                         sel_index = first+i;
 203
 204                         signal_item_selected.emit(sel_index, items[sel_index]);
 205                 }
 206         }
 207 }
 208
 209 void List::on_geometry_change()
 210 {
 211         reposition_slider();
 212
 213         check_view_range();
 214 }
 215
 216 void List::on_style_change()
 217 {
 218         if(!style)
 219         {
 220                 items_part = 0;
 221                 return;
 222         }
 223
 224         reposition_slider();
 225
 226         items_part = style->get_part("items");
 227
 228         const GL::Font &font = *style->get_font();
 229         row_height = static_cast<unsigned>((font.get_ascent()-font.get_descent())*font.get_default_size());
 230
 231         check_view_range();
 232 }
 233
 234 void List::reposition_slider()
 235 {
 236         if(!style)
 237                 return;
 238
 239         if(const Part *slider_part = style->get_part("slider"))
 240         {
 241                 Geometry sgeom = slider_part->get_geometry();
 242                 slider_part->get_alignment().apply(sgeom, geom, slider_part->get_margin());
 243                 slider.set_geometry(sgeom);
 244         }
 245 }
 246
 247 void List::check_view_range()
 248 {
 249         unsigned h = geom.h;
 250         if(items_part)
 251         {
 252                 const Sides &margin = items_part->get_margin();
 253                 h -= margin.top+margin.bottom;
 254         }
 255
 256         n_visible = h/row_height;
 257
 258         if(first+n_visible>items.size())
 259         {
 260                 if(items.size()>n_visible)
 261                         first = items.size()-n_visible;
 262                 else
 263                         first = 0;
 264         }
 265
 266         if(items.size()>n_visible)
 267         {
 268                 slider.set_range(0, items.size()-n_visible);
 269                 slider.set_value(items.size()-n_visible-first);
 270         }
 271         else
 272         {
 273                 slider.set_range(0, 0);
 274                 slider.set_value(0);
 275         }
 276 }
 277
 278 void List::slider_value_changed(double value)
 279 {
 280         if(items.size()>n_visible)
 281                 first = items.size()-n_visible-static_cast<unsigned>(value);
 282 }
 283
 284
 285 List::Loader::Loader(List &l):
 286         Widget::Loader(l)
 287 {
 288         add("item", &Loader::item);
 289 }
 290
 291 void List::Loader::item(const string &v)
 292 {
 293         dynamic_cast<List &>(obj).append(v);
 294 }
 295
 296 } // namespace GLtk
 297 } // namespace Msp