//
// 下端へ移動
//
void SelectItemPref::slot_bottom()
{
    Gtk::TreeModel::Children children = m_store_shown->children();
    if( children.empty() ) return;

    // 移動先のイテレータ
    Gtk::TreeIter bottom_it = children.end();

    std::list< Gtk::TreePath > selection_path = m_tree_shown.get_selection()->get_selected_rows();
    std::list< Gtk::TreePath >::reverse_iterator it = selection_path.rbegin();
    while( it != selection_path.rend() )
    {
        Gtk::TreeIter src_it = m_store_shown->get_iter( *it );
        Gtk::TreeIter dst_it = bottom_it;

        // 元と先が同じでない
        if( src_it != dst_it )
        {
            // 参照渡しなので書き換えられてしまう
            m_store_shown->move( src_it, dst_it );
            bottom_it = dst_it;
        }

        // 移動先の位置を上げる
        if( bottom_it != children.begin() ) --bottom_it;

        ++it;
    }

    // フォーカスを移す
    set_focus( m_tree_shown );
}

// Populate the active-at-start column.
void ObjectivesEditor::populateActiveAtStart()
{
	// Construct the list of entities targeted by the worldspawn
	TargetList targets(_worldSpawn);

	// Iterate through each row in the entity list. For each Entity*, get its
	// name and check if the worldspawn entity has a "target" key for this
	// entity name. This indicates that the objective entity will be active at
	// game start.
	Gtk::TreeModel::Children rows = _objectiveEntityList->children();

	for (Gtk::TreeModel::Children::iterator i = rows.begin(); i != rows.end(); ++i)
	{
		std::string name = Glib::ustring((*i)[_objEntityColumns.entityName]);

		ObjectiveEntityPtr obj = _entities[name];

		// Test if the worldspawn is targeting this entity by passing the
		// target list to the objective entity.
		if (obj->isOnTargetList(targets))
		{
			(*i)[_objEntityColumns.startActive] = true;
		}
	}
}

static void ClearStore(RefPtr<ObjectStore> os)
{
    Gtk::TreeModel::Children children = os->children();
    // с конца быстрее - не требуется реиндексация
    while( children.size() )
        DeleteMedia(os, --children.end());
}

void PredicateDialog::onRenamePredicate() {
    Glib::RefPtr < Gtk::TreeView::Selection > ref = mTreePredicateList->
        get_selection();
    if (ref) {
        Gtk::TreeModel::iterator iter = ref->get_selected();
        if (iter) {
            Gtk::TreeModel::Row row = *iter;
            std::string oldName(row.get_value(m_viewscolumnrecord.name));
            savePreviousPredicate(oldName);

            SimpleTypeBox box(("Predicate new name?"), "");
            std::string name = boost::trim_copy(box.run());
            if (box.valid() and checkName(name)) {

                setSensitivePredicate(false);
                m_model->erase(iter);

                Gtk::TreeModel::Children children = m_model->children();
                m_iter = children.begin();

                iter = m_model->append();
                mPredicateNameEntry->set_text(name);
                Gtk::ListStore::Row row = *iter;
                row[m_viewscolumnrecord.name] = name;

                if (mPredicateFunction.find(oldName) !=
                        mPredicateFunction.end()) {
                    mTextViewFunction->get_buffer()->
                            set_text(mPredicateFunction[oldName]);
                    mPredicateFunction[name] = mPredicateFunction[oldName];
                    mPredicateFunction.erase(oldName);
                }

                mPredicateName.push_back(name);
                // Delete the element in the vector
                for (std::vector < std::string > ::iterator it =
                        mPredicateName.begin(); it != mPredicateName.end(); ) {
                    if ( *it == oldName ) {
                        it = mPredicateName.erase(it);
                    }
                    else {
                        ++it;
                    }
                }
                mTreePredicateList->set_cursor(m_model->get_path(iter));
                setSensitivePredicate(true);
            }
            else {
                Gtk::MessageDialog errorDial ("Name error !",
                    false,
                    Gtk::MESSAGE_ERROR,
                    Gtk::BUTTONS_OK,
                    true);
                errorDial.set_title("Error !");
                errorDial.run();
            }
        }
    }
}

void VistaCrearVideo::on_button_Descargar(){
	std::stringstream ss;
	ss << m_FPSEntry.get_text().c_str();
	double f=0.0;
	ss >> f;

	std::cerr << "FPS: " << f << std::endl;
	if (f<0.5)
		return this->ventanaError("Ingresa las FPS!\n\n\n--mayor o igual a 0.5--", "Error");
	if (f>50)
		return this->ventanaError("Imposible tantos FPS!", "Error");

	/*Abro el dialogo para elegir nombre de archivo, la extencion sera mp4*/
	Gtk::FileChooserDialog dialog("Elige donde y con que nombre guardar el video",
			Gtk::FILE_CHOOSER_ACTION_SAVE);

	//Add response buttons the the dialog:
	dialog.add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	dialog.add_button("Select", Gtk::RESPONSE_OK);

	int result = dialog.run();
	std::string nombre;
	//Handle the response:
	switch(result){
	case(Gtk::RESPONSE_OK):{
		std::cerr << "Select clicked." << std::endl;
		std::cerr << "Folder selected: " << dialog.get_filename()
		        				<< std::endl;

		nombre = (dialog.get_filename().c_str());
		nombre+=".mp4";

		break;
	}
	case(Gtk::RESPONSE_CANCEL):{
		std::cerr << "Cancel clicked." << std::endl;
		return;
	}
	default:{
		std::cerr << "Unexpected button clicked." << std::endl;
		return;
	}
	}

	Gtk::TreeModel::Children children = m_refImagenesListStore->children();
	Gtk::TreeModel::Children::iterator it;

	std::vector<std::string> rutaFrames;

	for(it=children.begin(); it != children.end(); ++it){
		Gtk::TreeModel::Row row = *it;
		Glib::ustring s = row[m_ImagenesList.m_Columns.m_col_ruta];
		std::string strin(s.c_str());
		rutaFrames.push_back(strin);
	}

	common::Video::guardarAPartirDeImagenes(nombre,rutaFrames,f);
}

Gtk::TreeModel::iterator MemberList::getListIter(Gtk::TreeModel::
                Children children,
                const Glib::ustring & id)
{
        /*查找好友列表项 */
        return find_if(children.begin(),
                       children.end(),
                       bind2nd(CompareMember(columns), id));
}

std::string ListBoxImpl::get_string_value_from_index (ListBox *self, size_t index) 
{
  ListBoxImpl* sel= self->get_data<ListBoxImpl>();
  Gtk::TreeModel::Children children = sel->_store->children();
  std::string result;
  if (children.size() > index)
    children[index]->get_value<std::string>(0, result);
  return result;
}

void ParentChooser::setID(int ID)
{
	Gtk::TreeIter iter;
	Gtk::TreeModel::Children children = model->children();
	iter = findRow(ID);
	if (iter != children.end())
	{
		model->erase(iter);
	}
}

 /**
  * Select (highlight it) string from ComboBoxString if exist.
  *
  * @param str string to select from ComboBoxString.
  */
 void select_string(const Glib::ustring& str) {
     Gtk::TreeModel::Children children = mListStore->children();
     Gtk::TreeModel::Children::iterator it = children.begin();
     while (it != children.end()) {
         Gtk::TreeModel::Row row = (*it);
         if (row and row[mColumn.mString] == str) {
             set_active(it);
         }
         ++it;
     }
 }

void VistaCrearVideo::actualizarFramesReproductor(){
	Gtk::TreeModel::Children children = m_refImagenesListStore->children();
	Gtk::TreeModel::Children::iterator it;

	std::vector< Gtk::Image* > frames;

	for(it=children.begin(); it != children.end(); ++it){
		Gtk::TreeModel::Row row = *it;
		frames.push_back((row[m_ImagenesList.m_Columns.m_col_imgGrande]));
	}
	reproductor.setearFrames(frames);
}

void MemberList::clearMember()
{
        Gtk::TreeModel::Children children = refListStore->children();
        Gtk::TreeModel::iterator iter = children.begin();

        while ( iter != children.end()) {
                //Glib::ustring name = (*iter)[columns.name];
                //std::cout<<"erase ============"<<name<<std::endl;
                iter = refListStore->erase(iter);
        }

        m_number = 0;
}

void CheatListDialog::vOnCheatMarkAll()
{
    Gtk::TreeModel::Children cListEntries = m_poCheatListStore->children();

    for (Gtk::TreeModel::iterator iter = cListEntries.begin(); iter; iter++) {
        Gtk::TreeModel::Row row = *iter;

        row[m_oRecordModel.bEnabled] = bMark;

        vToggleCheat(row[m_oRecordModel.iIndex], row[m_oRecordModel.bEnabled]);
    }

    bMark = !bMark;
}

void SimulOutSetsAdapterModelImpl::setSelectedSetName(std::string SetName)
{
  Gtk::TreeModel::Children Children = mref_ListStore->children();

  for (Gtk::TreeModel::Children::iterator it = Children.begin(); it
      != Children.end(); ++it)
  {
    if (it->get_value(m_Columns.m_Name) == SetName)
    {
      m_SelectedRowRef = mref_ListStore->createRowRefFromIter(it);
      return;
    }
  }
}

void ConfigurationDialog::on_remove_button_clicked()
{
  Glib::RefPtr<Gtk::TreeSelection> refTreeSelection = m_treeView.get_selection();
  Gtk::TreeModel::iterator it = refTreeSelection->get_selected();
  if(!it) return;
  m_toolkit->removeSynapseDefinition((*it)[m_indexColumn]);
  m_refTreeModel2->erase(it);
  Gtk::TreeModel::Children rows = m_refTreeModel2->children();
  m_scIndex = 0;
  for(Gtk::TreeModel::Children::iterator jt = rows.begin(); jt != rows.end(); jt++){
    (*jt)[m_indexColumn] = m_scIndex;
    m_scIndex++;
  }
}

//
// 全ての有効な項目を文字列で取得
//
std::string SelectItemPref::get_items()
{
    std::string items;

    const Gtk::TreeModel::Children children = m_store_shown->children();
    Gtk::TreeModel::iterator it = children.begin();
    while( it != children.end() )
    {
        Gtk::TreeModel::Row row = *it;
        items.append( row[ m_columns_shown.m_column_text ] + " " );
        ++it;
    }

    return items;
}

void EntityChooser::importFromString(const std::string& str)
{
	Gtk::TreeModel::Children children = _entityStore->children();

	for (Gtk::TreeModel::Children::iterator i = children.begin(); i != children.end(); ++i)
	{
		Gtk::TreeModel::Row row = *i;

		if (row[_listColumns.name] == str)
		{
			_selection->select(i);
			break;
		}
	}
}

Gtk::TreeModel::iterator ParentChooser::findRow(int id)
{
	Gtk::TreeIter iter;
	Gtk::TreeModel::Children children = model->children();

	for (iter = children.begin(); iter != children.end(); iter++)
	{
		Gtk::TreeModel::Row row = *iter;
		if (row[Columns.col_id] == id)
		{
			break;
		}
	}
	return iter;
}

//------------------------------------------------------------------------------
void ListBoxImpl::set_index(::mforms::ListBox *self, ssize_t index)
{
  ListBoxImpl* sel= self->get_data<ListBoxImpl>();

  if ( sel )
  {
    Glib::RefPtr<Gtk::TreeView::Selection> selection = sel->_lbox.get_selection();
    Gtk::TreeModel::Children children = sel->_store->children();
    if ( children.size() > (unsigned int)index && index >= 0 )
    {
      Gtk::TreeModel::Row row = children[index];
      if ( row )
        selection->select(row);
    }
  }
}

void setup_model(){
	{
		//treeview
		treemodel = Gtk::ListStore::create(columns);	
		treeview1->set_model(treemodel);
		treeview1->append_column("Filename", columns.Filename);
		treeview1->append_column("Url", columns.url);
		treeview1->append_column("Size", columns.size);
		treeview1->append_column("%", columns.percentage_complete);
		treeview1->append_column("Time Left", columns.time_left);
		treeview1->append_column("Action", columns.action);

		//make all columns resizeable and set width
		std::vector<Gtk::TreeViewColumn*> tv_columns = treeview1->get_columns();	
		std::vector<Gtk::TreeViewColumn*>::iterator iter = tv_columns.begin();
		int count = 0;
		for (; iter!=tv_columns.end(); iter++, count++){
			Gtk::TreeViewColumn* col = *iter;
			col->set_resizable(true);
			col->set_fixed_width(column_widths[count]);
		}
		Gtk::TreeModel::Row row = *(treemodel->append());
		row[columns.Filename] = "33";
		row[columns.url] = "SFDSD";

		Gtk::TreeModel::Children children = treemodel->children();
		for(Gtk::TreeModel::Children::iterator iter = children.begin(); iter != children.end(); ++iter){
			Gtk::TreeModel::Row row = *iter;
			row->set_value(0, (Glib::ustring)"asdfaksdhfakshdfklasjdfhklsafdhlaskjdhflksajdhfasdfads");
			row->set_value(4, (Glib::ustring)"asdfads");
		}
	}
	{
		comboboxmodel = Gtk::ListStore::create(combo_columns);	
		combobox_size->set_model(comboboxmodel);
		Gtk::TreeModel::Row row = *(comboboxmodel->append());
		combobox_size->set_id_column(0);
		Gtk::CellRendererText *cell = new Gtk::CellRendererText(); 
		combobox_size->pack_start(*cell);
		combobox_size->add_attribute(*cell, "text", combo_columns.size); 
		row[combo_columns.size] = "kB";
		(*(comboboxmodel->append()))[combo_columns.size] = "MB";
		combobox_size->set_active(0);
	}
}

void ParentChooser::setParentID(int parentID)
{
	if (parentID >= 0)
	{
		this->parentID = parentID;
	}
	else
	{
		this->parentID = 0;
	}
	Gtk::TreeIter iter;
	Gtk::TreeModel::Children children = model->children();
	iter = findRow(parentID);
	if (iter != children.end())
	{
		set_active(iter);
	}
}