~ubuntu-branches/ubuntu/utopic/mysql-workbench/utopic

  : ViewImpl(self), _row_height(-1), _org_event(0)

  _tree.signal_button_release_event().connect(sigc::mem_fun(this, &TreeNodeViewImpl::on_button_release), false);

 

TreeNodeViewImpl::~TreeNodeViewImpl()

{

  if (_org_event)

    delete _org_event;

}

  if (_org_event)

  {

    delete _org_event;

    _org_event = 0;

  }

  if (_org_event)

  {

    delete _org_event;

    _org_event = 0;

  }

      if (_org_event != 0)

      {

        delete _org_event;

        _org_event = 0;

      }

 

      {

        //Because of problems when Treeview has been set to multiselect,

        //there are some DnD problems, below code is fixing those.

        //We check if users already selected something,

        //if he is trying to drag not selected row,

        //we change selection.

        std::vector<Gtk::TreePath> path_selection;

        path_selection = _tree.get_selection()->get_selected_rows();

 

        Gtk::TreeModel::Path selpath;

        if(_tree.get_path_at_pos(_drag_start_x, _drag_start_y, selpath))

        {

          bool found = false;

          for(std::vector<Gtk::TreePath>::iterator it = path_selection.begin(); it != path_selection.end(); ++it)

          {

            if (selpath == *it)

            {

              found = true;

              break;

            }

          }

          if (!found)

          {

            //Old selection is invalid, we need to create new one

            _tree.get_selection()->unselect_all();

            _tree.get_selection()->select(selpath);

          }

        }

      }

 

 

 

        Gtk::TreeModel::Path path;

        if(_tree.get_path_at_pos(_drag_start_x, _drag_start_y, path))

        {

          Glib::RefPtr<Gdk::Pixmap> row_icon = _tree.create_row_drag_icon(path);

          int ico_w, ico_h;

          row_icon->get_size(ico_w, ico_h);

 

          Glib::RefPtr<Gdk::Pixbuf> pix = Gdk::Pixbuf::create(row_icon->get_image(0, 0, ico_w, ico_h), 0, 0, ico_w, ico_h);

          //sadly we need a cairo_surface

          details.image = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, ico_w, ico_h);

          cairo_t *cr = cairo_create(details.image);

          gdk_cairo_set_source_pixbuf(cr, pix->gobj(), 0, 0);

          cairo_paint(cr);

 

          void *data = NULL;

          std::string format;

          details.location = base::Point(ev->x, ev->y);

          details.allowedOperations = mforms::DragOperationCopy;

          if(!view->get_drag_data(details, &data, format))

 

            format = "STRING";

            std::list<mforms::TreeNodeRef> selection = view->get_selection();

 

            for (std::list<mforms::TreeNodeRef>::const_iterator iterator = selection.begin(); iterator != selection.end(); ++iterator)

            {

                  if (!(*iterator)->get_string(0).empty())

                  {

                    if (text.size() > 0)

                      text.append(", ");

                    text.append((*iterator)->get_string(0));

                  }

            }

 

            if (text.empty())

            {

              cairo_surface_destroy(details.image);

              cairo_destroy(cr);

              return false;

            }

 

            data = &text;

          mforms::DragOperation operation = view->do_drag_drop(details, data, format);

          cairo_surface_destroy(details.image);

          cairo_destroy(cr);

          view->drag_finished(operation);

  //Because of problems when Treeview has been set to multiselect,

  //there are some DnD problems, below code is fixing those.

  //we need this to emit press event again cause we're changing default behavior of it

  if (_org_event != 0)

  {

    gtk_propagate_event((GtkWidget*)_tree.gobj(), (GdkEvent*)_org_event);

    delete _org_event;

    _org_event = 0;

  }

//  _tree.

    if (!color.empty())

    {

      Gdk::Color col(color);

      _tree.get_colormap()->alloc_color(col);

      _tree.modify_base(Gtk::STATE_NORMAL, col);

    }

    if (_org_event == 0)

    {

      _org_event = new GdkEventButton(*event);

      _drag_button = event->button;

      _drag_start_x = event->x;

      _drag_start_y = event->y;

      ret_val = true;

    }

template<typename T>

int column_value_compare(const T &val1, const T &val2)

{

  int result = 0;

  if (val2 < val1) result = -1;

  else if (val2 > val1) result = 1;

  return result;

}

 

template<typename T>

int column_numeric_compare(const Gtk::TreeModel::iterator& it1, const Gtk::TreeModel::iterator& it2, Gtk::TreeModelColumn<T> *col)

{

  return column_value_compare((*it1).get_value(*col), (*it2).get_value(*col));

}

 

int column_string_compare(const Gtk::TreeModel::iterator& it1, const Gtk::TreeModel::iterator& it2, Gtk::TreeModelColumn<Glib::ustring> *col, int type)

{

  int result = 0;

  

  switch (type)

  {

    case StringColumnType:

    case StringLTColumnType:

    case IconColumnType:

    {

      std::string val1 = (*it1).get_value(*col).c_str();

      std::string val2 = (*it2).get_value(*col).c_str();

      result = base::string_compare(val2, val1, false);

      break;

    }

    case IntegerColumnType:

    case LongIntegerColumnType:

    {

      std::istringstream ss_val1((*it1).get_value(*col).c_str());

      std::istringstream ss_val2((*it2).get_value(*col).c_str());

      int64_t val1 = 0;

      int64_t val2 = 0;

      ss_val1 >> val1;

      ss_val2 >> val2;

      result = column_value_compare(val1, val2);

      break;

    }

    case FloatColumnType:

    case NumberWithUnitColumnType:

    {

      double val1 = mforms::TreeNodeView::parse_string_with_unit((*it1).get_value(*col).c_str());

      double val2 = mforms::TreeNodeView::parse_string_with_unit((*it2).get_value(*col).c_str());

      result = column_value_compare(val1, val2);

      break;

    }

  }

  

  return result;

  

  if (flag == false || !_tree_store)

    return;

    

  if (!_sort_model)

    _sort_model = Gtk::TreeModelSort::create(_tree_store);

 

  for (std::size_t i = 0; i < _tree.get_columns().size(); ++i)

    Gtk::TreeViewColumn* col = _tree.get_column(i);

    Gtk::TreeModelColumnBase *mcol = _columns.columns[index_for_column(i)];

    

    if (col == NULL || mcol == NULL)

    {

      log_warning("Invalid column pointer[col:%s][mcol:%s]\n", col == NULL ? "NULL" : "NOT NULL", mcol == NULL ? "NULL" : "NOT NULL");

      continue;

    }

 

    col->signal_clicked().connect(sigc::bind(sigc::mem_fun(this, &TreeNodeViewImpl::header_clicked),mcol,col));

    

    //  Align columns text depending on the visualization type

    float align = 0.0f;

    

    switch(get_owner()->get_column_type(i))

    {

      case StringColumnType:

      case StringLTColumnType:

      case IconColumnType:

        align = 0.0f;

        break;

      case IntegerColumnType:

      case LongIntegerColumnType:

      case FloatColumnType:

      case NumberWithUnitColumnType:

        align = 1.0f;

        break;

      case CheckColumnType:

      case TriCheckColumnType:

        align = 0.5f;

        break;

    }      

    

    Glib::ListHandle<Gtk::CellRenderer*> renderers = col->get_cell_renderers();

    

    for (Glib::ListHandle<Gtk::CellRenderer*>::const_iterator iter = renderers.begin(); iter != renderers.end(); ++iter)

      (*iter)->set_alignment(align, 0);

    

    //  Set the proper compare method to the sorting functions depending on the storage type

    switch (mcol->type())

    {

      case G_TYPE_INT:

        _sort_model->set_sort_func(*mcol, sigc::bind(sigc::ptr_fun(column_numeric_compare<int>), (Gtk::TreeModelColumn<int>*)mcol));

        break;

      case G_TYPE_LONG:

        _sort_model->set_sort_func(*mcol, sigc::bind(sigc::ptr_fun(column_numeric_compare<long>), (Gtk::TreeModelColumn<long>*)mcol));

        break;

      case G_TYPE_INT64:

        _sort_model->set_sort_func(*mcol, sigc::bind(sigc::ptr_fun(column_numeric_compare<int64_t>), (Gtk::TreeModelColumn<int64_t>*)mcol));

        break;

      case G_TYPE_UINT:

        _sort_model->set_sort_func(*mcol, sigc::bind(sigc::ptr_fun(column_numeric_compare<unsigned int>), (Gtk::TreeModelColumn<unsigned int>*)mcol));

        break;

      case G_TYPE_ULONG:

        _sort_model->set_sort_func(*mcol, sigc::bind(sigc::ptr_fun(column_numeric_compare<unsigned long>), (Gtk::TreeModelColumn<unsigned long>*)mcol));

        break;

      case G_TYPE_UINT64:

        _sort_model->set_sort_func(*mcol, sigc::bind(sigc::ptr_fun(column_numeric_compare<uint64_t>), (Gtk::TreeModelColumn<uint64_t>*)mcol));

        break;

      case G_TYPE_FLOAT:

      case G_TYPE_DOUBLE:

        _sort_model->set_sort_func(*mcol, sigc::bind(sigc::ptr_fun(column_numeric_compare<double>), (Gtk::TreeModelColumn<double>*)mcol));

        break;

      case G_TYPE_STRING:

        _sort_model->set_sort_func(*mcol, sigc::bind(sigc::ptr_fun(column_string_compare), (Gtk::TreeModelColumn<Glib::ustring>*)mcol, get_owner()->get_column_type(i)));

        break;

      default:

        log_warning("Unknown column storage type");

        break;

    }

 

  // temporarily disable selection change signal, gtk emits it when setting model

  _conn.disconnect();

  _tree.set_model(_sort_model);

  _conn = _tree.get_selection()->signal_changed().connect(sigc::mem_fun(dynamic_cast<TreeNodeView*>(owner), &TreeNodeView::changed));