← Back to branch summary

~ubuntu-branches/ubuntu/quantal/mysql-workbench/quantal

« back to all changes in this revision

Viewing changes to plugins/db.mysql.editors/linux/mysql_table_editor_index_page.cpp

  • Committer: Package Import Robot
  • Author(s): Dmitry Smirnov
  • Date: 2012-03-01 21:57:30 UTC
  • Revision ID: package-import@ubuntu.com-20120301215730-o7y8av8y38n162ro
Tags: upstream-5.2.38+dfsg
Import upstream version 5.2.38+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins/db.mysql.editors/linux/mysql_table_editor_index_page.cpp
 
1
#include "mysql_table_editor_fe.h"
 
2
#include "grtdb/db_object_helpers.h"
 
3
#include "treemodel_wrapper.h"
 
4
 
 
5
#include "mysql_table_editor_index_page.h"
 
6
 
 
7
#include <gtkmm/notebook.h>
 
8
#include <gtkmm/treeview.h>
 
9
#include <gtkmm/textview.h>
 
10
#include <gtkmm/comboboxtext.h>
 
11
#include <gtkmm/cellrenderercombo.h>
 
12
 
 
13
//------------------------------------------------------------------------------
 
14
DbMySQLTableEditorIndexPage::DbMySQLTableEditorIndexPage(DbMySQLTableEditor *owner
 
15
                                                          ,MySQLTableEditorBE *be
 
16
                                                          ,Glib::RefPtr<Gtk::Builder>         xml)
 
17
                             : _owner(owner)
 
18
                             , _be(be)
 
19
                             , _xml(xml)
 
20
{
 
21
  _xml->get_widget("indexes", _indexes_tv);
 
22
  _indexes_tv->set_enable_tree_lines(true);
 
23
  _indexes_tv->set_headers_visible(true);
 
24
    
 
25
  switch_be(be);
 
26
 
 
27
  _indexes_tv->signal_cursor_changed().connect(sigc::mem_fun(*this, &DbMySQLTableEditorIndexPage::index_cursor_changed));
 
28
    
 
29
  std::vector<std::string> asc_desc_list;
 
30
  asc_desc_list.push_back("ASC");
 
31
  asc_desc_list.push_back("DESC");
 
32
  _sort_order_model = model_from_string_list(asc_desc_list);
 
33
 
 
34
  _xml->get_widget("index_storage_combo", _index_storage_combo);
 
35
  setup_combo_for_string_list(_index_storage_combo);
 
36
  fill_combo_from_string_list(_index_storage_combo, _be->get_index_storage_types());
 
37
  _index_storage_combo_conn = _index_storage_combo->signal_changed().connect(sigc::mem_fun(this, &DbMySQLTableEditorIndexPage::update_index_storage_type_in_be));
 
38
 
 
39
  _owner->bind_entry_and_be_setter("index_key_block_size", this, &DbMySQLTableEditorIndexPage::set_index_key_block_size);
 
40
  _owner->bind_entry_and_be_setter("index_parser", this, &DbMySQLTableEditorIndexPage::set_index_parser);
 
41
 
 
42
  Gtk::TextView *text(0);
 
43
  _xml->get_widget("index_comment", text);
 
44
  _owner->add_text_change_timer(text, sigc::mem_fun(this, &DbMySQLTableEditorIndexPage::set_index_comment));
 
45
 
 
46
  _order_model = model_from_string_list(std::vector<std::string>());
 
47
}
 
48
 
 
49
//------------------------------------------------------------------------------
 
50
void DbMySQLTableEditorIndexPage::switch_be(MySQLTableEditorBE* be)
 
51
{
 
52
  _index_node = bec::NodeId();
 
53
 
 
54
  _indexes_columns_model.clear();
 
55
  Gtk::TreeView *tv = 0;
 
56
  _xml->get_widget("index_columns", tv);
 
57
  tv->remove_all_columns();
 
58
  tv->unset_model();
 
59
 
 
60
  _be = be;
 
61
 
 
62
  _be->get_indexes()->select_index(_index_node);
 
63
  // refresh is done from TableEd
 
64
  
 
65
  _indexes_tv->remove_all_columns();
 
66
  
 
67
  _indexes_model = ListModelWrapper::create(_be->get_indexes(), _indexes_tv, "DbMySQLTableEditorIndexPage");
 
68
 
 
69
  _indexes_model->model().append_string_column(0, "Index Name", EDITABLE, NO_ICON);
 
70
  _indexes_model->model().append_combo_column(1, "Type", model_from_string_list(_be->get_index_types()), EDITABLE, true);
 
71
 
 
72
  _indexes_tv->set_model(_indexes_model);
 
73
 
 
74
  Gtk::CellRenderer* rend = _indexes_tv->get_column_cell_renderer(0);
 
75
  rend->signal_editing_started().
 
76
    connect(sigc::mem_fun(this, &DbMySQLTableEditorIndexPage::cell_editing_started));
 
77
}
 
78
 
 
79
//------------------------------------------------------------------------------
 
80
void DbMySQLTableEditorIndexPage::refresh()
 
81
{
 
82
  Gtk::TreeView *tv = 0;
 
83
  _xml->get_widget("index_columns", tv);
 
84
  tv->unset_model();
 
85
  tv->remove_all_columns();
 
86
  
 
87
  _index_node = bec::NodeId();
 
88
  _be->get_indexes()->select_index(_index_node);
 
89
    
 
90
  bec::ListModel* m = _indexes_model->get_be_model();
 
91
  _indexes_model->set_be_model(0);
 
92
 
 
93
  _indexes_tv->unset_model();
 
94
  _indexes_tv->set_model(_indexes_model);
 
95
 
 
96
  _indexes_model->set_be_model(m);
 
97
  _indexes_model->refresh();
 
98
 
 
99
  _indexes_tv->unset_model();
 
100
  _indexes_tv->set_model(_indexes_model);
 
101
 
 
102
  const bool has_columns = _be->get_columns()->count() > 1;
 
103
  tv->set_sensitive(has_columns);
 
104
  _indexes_tv->set_sensitive(has_columns);
 
105
  
 
106
  index_cursor_changed();
 
107
}
 
108
 
 
109
//------------------------------------------------------------------------------
 
110
void DbMySQLTableEditorIndexPage::index_cursor_changed()
 
111
{
 
112
  Gtk::TreeModel::Path   path;
 
113
  Gtk::TreeView::Column *column(0);
 
114
 
 
115
  _indexes_tv->get_cursor(path, column);
 
116
 
 
117
  bec::NodeId node = _indexes_model->get_node_for_path(path);
 
118
 
 
119
  _index_node = node;
 
120
  update_index_details();
 
121
}
 
122
 
 
123
//------------------------------------------------------------------------------
 
124
Glib::RefPtr<Gtk::ListStore> DbMySQLTableEditorIndexPage::recreate_order_model()
 
125
{
 
126
  MySQLTableIndexListBE *indices_be = _be->get_indexes();
 
127
  std::vector<std::string> order_list;
 
128
 
 
129
  if (indices_be->count() > 1)
 
130
  {
 
131
    bec::IndexColumnsListBE *columns_be = indices_be->get_columns();
 
132
 
 
133
    if ( columns_be && indices_be->count() > 1)
 
134
    {
 
135
      const int max_idx_order = columns_be->get_max_order_index();
 
136
      char buf[32];
 
137
    
 
138
      for ( int i = 1; i <= max_idx_order; i++ )
 
139
      {
 
140
        snprintf(buf, sizeof(buf) / sizeof(*buf), "%i", i);
 
141
        order_list.push_back(buf);
 
142
      }
 
143
    }
 
144
  }
 
145
  else
 
146
    order_list.push_back("0");
 
147
 
 
148
  recreate_model_from_string_list(_order_model, order_list);  
 
149
  return _order_model;
 
150
}
 
151
 
 
152
//------------------------------------------------------------------------------
 
153
void DbMySQLTableEditorIndexPage::update_index_details()
 
154
{
 
155
  MySQLTableIndexListBE *indices_be = _be->get_indexes();
 
156
  if ( indices_be )
 
157
  {
 
158
    std::string index_name;
 
159
    indices_be->refresh();
 
160
 
 
161
    Gtk::TreeView *tv = 0;
 
162
    _xml->get_widget("index_columns", tv);
 
163
    tv->remove_all_columns();
 
164
    tv->unset_model();
 
165
  
 
166
    const bool got_indices = indices_be->count() > 1;
 
167
    if (_index_node.is_valid() && got_indices && _index_node.back() < indices_be->real_count())
 
168
    {
 
169
      indices_be->get_field(_index_node, 0, index_name);
 
170
      if ( !index_name.empty() )
 
171
      {
 
172
        indices_be->select_index(_index_node);
 
173
        indices_be->refresh();
 
174
      }
 
175
      
 
176
      _indexes_columns_model = ListModelWrapper::create(indices_be->get_columns(), tv, "IndexesColumnsModel");
 
177
      
 
178
      // negative column means value getting/setting is delegated back to us
 
179
      _indexes_columns_model->model().append_check_column(-8, "", EDITABLE);
 
180
      _indexes_columns_model->model().append_string_column(::bec::IndexColumnsListBE::Name, "Column", RO, NO_ICON);
 
181
      _indexes_columns_model->model().append_combo_column(::bec::IndexColumnsListBE::OrderIndex, "#", recreate_order_model(), EDITABLE);
 
182
      _indexes_columns_model->model().append_combo_column(-2, "Order", _sort_order_model, EDITABLE, true);
 
183
      _indexes_columns_model->model().append_int_column(::bec::IndexColumnsListBE::Length, "Length", EDITABLE);
 
184
      
 
185
      _indexes_columns_model->set_fake_column_value_getter(sigc::mem_fun(this, &DbMySQLTableEditorIndexPage::get_value));
 
186
      _indexes_columns_model->set_fake_column_value_setter(sigc::mem_fun(this, &DbMySQLTableEditorIndexPage::set_value));
 
187
      
 
188
      tv->set_model(_indexes_columns_model);
 
189
      
 
190
      std::string text;
 
191
      indices_be->get_field(_index_node, ::MySQLTableIndexListBE::StorageType, text);
 
192
      _index_storage_combo_conn.block();
 
193
      set_selected_combo_item(_index_storage_combo, text);
 
194
      _index_storage_combo_conn.unblock();
 
195
    }
 
196
    else
 
197
    {
 
198
      set_selected_combo_item(_index_storage_combo, "");
 
199
    }
 
200
 
 
201
    Gtk::Entry *entry(0);
 
202
    std::string text;
 
203
 
 
204
    // Update row block size
 
205
    _xml->get_widget("index_key_block_size", entry);
 
206
    indices_be->get_field(_index_node, ::MySQLTableIndexListBE::RowBlockSize, text);
 
207
    entry->set_text(text);
 
208
    
 
209
    // Update index parser
 
210
    _xml->get_widget("index_parser", entry);
 
211
    indices_be->get_field(_index_node, ::MySQLTableIndexListBE::Parser, text);
 
212
    entry->set_text(text);
 
213
    
 
214
    Gtk::TextView* textview(0);    
 
215
    // update index comment
 
216
    _xml->get_widget("index_comment", textview);
 
217
    indices_be->get_field(_index_node, ::MySQLTableIndexListBE::Comment, text);
 
218
    textview->get_buffer()->set_text(text);
 
219
 
 
220
    _xml->get_widget("index_key_block_size", entry);
 
221
    entry->set_sensitive(got_indices && _index_node.is_valid() && _index_node.back() < indices_be->real_count());
 
222
    _xml->get_widget("index_parser", entry);
 
223
    entry->set_sensitive(got_indices && _index_node.is_valid() && _index_node.back() < indices_be->real_count());
 
224
    _xml->get_widget("index_comment", textview);
 
225
    textview->set_sensitive(got_indices && _index_node.is_valid() && _index_node.back() < indices_be->real_count());
 
226
 
 
227
    _index_storage_combo->set_sensitive(got_indices && _index_node.is_valid() && _index_node.back() < indices_be->real_count());
 
228
  }
 
229
}
 
230
 
 
231
//--------------------------------------------------------------------------------
 
232
void DbMySQLTableEditorIndexPage::update_index_storage_type_in_be()
 
233
{
 
234
  MySQLTableIndexListBE *indices_be = _be->get_indexes();
 
235
 
 
236
  if ( indices_be && _index_node.is_valid() )
 
237
  {
 
238
    const std::string new_storage_type = get_selected_combo_item(_index_storage_combo);
 
239
    indices_be->set_field(_index_node, ::MySQLTableIndexListBE::StorageType, new_storage_type);
 
240
  }
 
241
}
 
242
 
 
243
//--------------------------------------------------------------------------------
 
244
void DbMySQLTableEditorIndexPage::cell_editing_started(Gtk::CellEditable *cell, const Glib::ustring &path)
 
245
{
 
246
  bec::NodeId node(path);
 
247
  if ( node.is_valid() )
 
248
    _index_node = node;
 
249
}
 
250
 
 
251
//--------------------------------------------------------------------------------
 
252
void DbMySQLTableEditorIndexPage::get_value(const Gtk::TreeModel::iterator& iter, int column, GType type, Glib::ValueBase& value)
 
253
{
 
254
  bec::IndexColumnsListBE *columns_be = _be->get_indexes()->get_columns();
 
255
  bec::NodeId node(_indexes_columns_model->node_for_iter(iter));
 
256
 
 
257
  if ( !node.is_valid() )
 
258
    return;
 
259
  
 
260
  switch ( column )
 
261
  {
 
262
    case -2: // Sort order
 
263
    {
 
264
      int val = 0;
 
265
      columns_be->get_field(node, ::bec::IndexColumnsListBE::Descending, val);
 
266
      set_glib_string(value, val == 0 ? "ASC" : "DESC");
 
267
      break;
 
268
    }
 
269
    case -8: // Set/unset
 
270
    {
 
271
      const bool bv = columns_be->get_column_enabled(node);
 
272
      set_glib_bool(value, bv);
 
273
      break;
 
274
    }
 
275
  }
 
276
}
 
277
 
 
278
//--------------------------------------------------------------------------------
 
279
void DbMySQLTableEditorIndexPage::set_value(const Gtk::TreeModel::iterator& iter, int column, GType type, const Glib::ValueBase& value)
 
280
{
 
281
  bec::IndexColumnsListBE *columns_be = _be->get_indexes()->get_columns();
 
282
  bec::NodeId node(_indexes_columns_model->node_for_iter(iter));
 
283
 
 
284
  if ( node.is_valid() )
 
285
  {
 
286
    switch ( column )
 
287
    {
 
288
      case -2:
 
289
      {
 
290
        Glib::Value<std::string>   v;
 
291
        v.init(value.gobj());
 
292
    
 
293
        columns_be->set_field(node, ::bec::IndexColumnsListBE::Descending, v.get() == "ASC" ? 0 : 1);
 
294
        break;
 
295
      }
 
296
      case -8:
 
297
      {
 
298
        Glib::Value<bool>   v;
 
299
        v.init(value.gobj());
 
300
        columns_be->set_column_enabled(node, v.get());
 
301
        recreate_order_model();
 
302
        break;
 
303
      }
 
304
    }
 
305
  }
 
306
}
 
307
 
 
308
//------------------------------------------------------------------------------
 
309
void DbMySQLTableEditorIndexPage::set_index_key_block_size(const std::string& value)
 
310
{
 
311
  MySQLTableIndexListBE *indices_be = _be->get_indexes();
 
312
  indices_be->set_field(_index_node, ::MySQLTableIndexListBE::RowBlockSize, value);
 
313
}
 
314
 
 
315
//------------------------------------------------------------------------------
 
316
void DbMySQLTableEditorIndexPage::set_index_parser(const std::string& value)
 
317
{
 
318
  MySQLTableIndexListBE *indices_be = _be->get_indexes();
 
319
  indices_be->set_field(_index_node, ::MySQLTableIndexListBE::Parser, value);
 
320
}
 
321
 
 
322
//------------------------------------------------------------------------------
 
323
void DbMySQLTableEditorIndexPage::set_index_comment(const std::string& value)
 
324
{
 
325
  MySQLTableIndexListBE *indices_be = _be->get_indexes();
 
326
  indices_be->set_field(_index_node, ::MySQLTableIndexListBE::Comment, value);
 
327
}
 
328