コード例 #1
0
ファイル: web_server.cpp プロジェクト: okigan/RobustMVC
    std::shared_ptr<quad_model_image_web_view> process(const std::string & verb,
            const std::string & id,
            const std::string & action,
            const std::string & view)
    {
        if( "GET" == verb ) {
            if( "view" == action ) {
                auto ptr = std::make_shared<quad_model_image_web_view>();
                ptr->set_model(static_cast<quad_model*>(_controler.get_model()));
                return ptr;
            } else if( "incr" == action ) {
                _controler.increase_radius();

                auto ptr = std::make_shared<quad_model_image_web_view>();
                ptr->set_model(static_cast<quad_model*>(_controler.get_model()));
                return ptr;
            } else if( "decr" == action ) {
                _controler.decrease_radius();

                auto ptr = std::make_shared<quad_model_image_web_view>();
                ptr->set_model(static_cast<quad_model*>(_controler.get_model()));
                return ptr;
            }
        }
    }
コード例 #2
0
void
set_object_models(std::vector<object_model_features_t> &obj_models)
{
	object_model_features_t obj_class;

	/* 0) sedan */
	set_model(obj_class, 0, (char *)"car", 1.8, 4.4, 1.4, 1.0, 0.0, 0.8);
	obj_models.push_back(obj_class);

	/* 11) bike/motorbike 1 */
	set_model(obj_class, 11, (char *)"bike", 0.7, 2.2, 1.4, 0.0, 1.0, 1.0);
	obj_models.push_back(obj_class);

	/* 21) small truck */
	set_model(obj_class, 21, (char *)"truck", 2.2, 6.8, 2.6, 0.5, 0.5, 1.0);
	obj_models.push_back(obj_class);

	/* 31) bus (average estimative) */
	set_model(obj_class, 31, (char *)"bus", 2.9, 12.6, 3.5, 1.0, 1.0, 0.0);
	obj_models.push_back(obj_class);

	/* 41) pedestrian 1 */
	set_model(obj_class, 41, (char *)"pedestrian", 0.6, 0.6, 1.7, 0.0, 1.0, 0.0);
	obj_models.push_back(obj_class);

	num_of_models = int(obj_models.size());
}
コード例 #3
0
FontSizeComboBox::FontSizeComboBox(BaseObjectType* cobject, const Glib::RefPtr<Gtk::Builder>& builder) :
	Gtk::ComboBox( cobject )
{
	font_size_tree_model_ = Gtk::ListStore::create(columns_);
	
	font_size_tree_model_->set_sort_column(columns_.font_size, Gtk::SORT_ASCENDING);
	
	set_model(font_size_tree_model_);
	
	Gtk::TreeModel::Row row = *(font_size_tree_model_->append()); row[columns_.font_size] = 6; 
	row = *(font_size_tree_model_->append()); row[columns_.font_size] = 8; 
	row = *(font_size_tree_model_->append()); row[columns_.font_size] = 10; 
	row = *(font_size_tree_model_->append()); row[columns_.font_size] = 11; 
	row = *(font_size_tree_model_->append()); row[columns_.font_size] = 12; 
	row = *(font_size_tree_model_->append()); row[columns_.font_size] = 14; 
	row = *(font_size_tree_model_->append()); row[columns_.font_size] = 16; 
	row = *(font_size_tree_model_->append()); row[columns_.font_size] = 18; 
	row = *(font_size_tree_model_->append()); row[columns_.font_size] = 24; 
	row = *(font_size_tree_model_->append()); row[columns_.font_size] = 32; 
	
	Gtk::CellRendererText* renderer = Gtk::manage (new Gtk::CellRendererText());
	pack_start (*renderer, true);
	
	add_attribute(renderer->property_text(), columns_.font_size);	
}
コード例 #4
0
    void ValueComboBox::setValues(const std::vector<std::string>& iValues)
    {

        // Set up tree model.
        _refTreeModel = Gtk::ListStore::create(_columns);
        set_model(_refTreeModel);

        std::cout << "ABAB1" << std::endl;
        _refTreeModel->clear();
     
        std::cout << "ABAB1" << std::endl;   
        // Fill rows with values.
        for (auto aValue : iValues)
        {
            
            std::cout << "ABAB1" << std::endl;
            Gtk::TreeModel::Row row = *(_refTreeModel->append());
            row[_columns._name] = aValue;
            //set_active(row);
        }
        
        clear();
        pack_start(_columns._name);

    }
コード例 #5
0
ファイル: pltb_frontend.c プロジェクト: stefanorf/pltb
void fprint_eval_row(FILE *f, model_space_t *model_space, pltb_model_stat_t *stat)
{
	set_model(model_space, stat->matrix_index);
	PRINT_BODY_ROW(f, model_space->matrix_repr_short, model_space->K,
	        stat->time_cpu, stat->time_real, stat->likelihood,
			stat->ic[AIC], stat->ic[AICc_C], stat->ic[AICc_RC], stat->ic[BIC_C], stat->ic[BIC_RC]);
}
コード例 #6
0
ファイル: navi.cpp プロジェクト: yborisovstc/fap2-studio-gtk
void NaviModules::SetDesEnv(MEnv* aDesEnv)
{
    if (aDesEnv != iDesEnv) {
	unset_model();
	remove_all_columns();
	Glib::RefPtr<TreeModel> curmdl = get_model();
	curmdl.reset();
	iDesEnv = aDesEnv;
	if (iDesEnv != NULL) {
	    Glib::RefPtr<Gtk::ListStore> mdl = Gtk::ListStore::create(iColRec);
	    GtkTreeModel* model = mdl->Gtk::TreeModel::gobj();
	    set_model(mdl);
	    append_column( "one", iColRec.name);
	    enable_model_drag_source();
	    drag_source_set (Gtk::ArrayHandle_TargetEntry(KModListTargets, 1, Glib::OWNERSHIP_NONE), Gdk::MODIFIER_MASK, Gdk::ACTION_COPY);
	    // Fill out the model
	    // List modules directory
	    struct dirent **entlist;
	    string modpath = iDesEnv->Provider()->ModulesPath();
	    int n = scandir (modpath.c_str(), &entlist, FilterModulesDirEntries, alphasort);
	    // Fill out the model
	    for (int cnt = 0; cnt < n; ++cnt) {
		Gtk::TreeIter it = mdl->append();
		Glib::ustring data = entlist[cnt]->d_name;
		(*it).set_value(iColRec.name, data);
	    }
	}
    }
}
コード例 #7
0
static void
set_property (GObject *object,
    guint param_id,
    const GValue *value,
    GParamSpec *pspec)
{
  EmpathyPersonaView *self = EMPATHY_PERSONA_VIEW (object);

  switch (param_id)
    {
      case PROP_MODEL:
        set_model (self, g_value_get_object (value));
        break;
      case PROP_SHOW_OFFLINE:
        empathy_persona_view_set_show_offline (self,
            g_value_get_boolean (value));
        break;
      case PROP_FEATURES:
        set_features (self, g_value_get_flags (value));
        break;
      default:
        G_OBJECT_WARN_INVALID_PROPERTY_ID (object, param_id, pspec);
        break;
    }
}
コード例 #8
0
ファイル: navi.cpp プロジェクト: yborisovstc/fap2-studio-gtk
void NaviHier::SetDesEnv(MEnv* aDesEnv)
{
    assert(aDesEnv == NULL || aDesEnv != NULL && iDesEnv == NULL);
    if (aDesEnv != iDesEnv) {
	unset_model();
	remove_all_columns();
	/* No need to delete model explicitly, it is deleted at unset_model
	Glib::RefPtr<TreeModel> curmdl = get_model();
	TreeModel* curmdlp = curmdl.operator ->();
	curmdl.reset();
	delete curmdlp;
	*/
	iDesEnv = aDesEnv;
	if (iDesEnv != NULL) {
	    Glib::RefPtr<HierTreeMdl> mdl = HierTreeMdl::create(iDesEnv);
	    HierTreeMdl* hmdl = mdl.operator ->();
	    GtkTreeModel* model = mdl->Gtk::TreeModel::gobj();
	    bool isds = GTK_IS_TREE_DRAG_SOURCE(model);
	    set_model(mdl);
	    append_column( "one", mdl->ColRec().name);
	    enable_model_drag_source();
	    drag_source_set (Gtk::ArrayHandle_TargetEntry(sNaviHierDnDTarg, 1, Glib::OWNERSHIP_NONE), Gdk::MODIFIER_MASK, Gdk::ACTION_COPY | Gdk::ACTION_MOVE);
	    iDesObs->SignalCompDeleted().connect(sigc::mem_fun(*hmdl, &HierTreeMdl::on_comp_deleting));
	    iDesObs->SignalCompAdded().connect(sigc::mem_fun(*hmdl, &HierTreeMdl::on_comp_adding));
	    iDesObs->SignalCompChanged().connect(sigc::mem_fun(*hmdl, &HierTreeMdl::on_comp_changed));
	}
    }
}
コード例 #9
0
ファイル: Optimizer.cpp プロジェクト: drussel/imp
Optimizer::Optimizer(Model *m, std::string name): Object(name)
{
  if (m) set_model(m);
  set_was_used(true);
  min_score_= -std::numeric_limits<double>::max();
  stop_on_good_score_=false;
}
コード例 #10
0
void US_EquilTime::change_model( void )
{
   US_ModelGui* dialog = new US_ModelGui( model );
   connect( dialog, SIGNAL( valueChanged( US_Model ) ), 
                    SLOT  ( set_model   ( US_Model ) ) );
   dialog->exec();
}
コード例 #11
0
ファイル: model_e3.cpp プロジェクト: dimalit/ode-env
E3PetscSolverConfig::E3PetscSolverConfig(){
	set_atol(1e-6);
	set_rtol(1e-6);
	set_init_step(0.01);
	set_solver(E3PetscSolverConfig::rhs);
	set_model("tm");
	set_n_cores(1);
}
コード例 #12
0
ファイル: playlistview.cpp プロジェクト: williamkibira/Player
PlaylistViewer::PlaylistViewer()
{
  //Create the Tree model:
  m_refTreeModel = Gtk::ListStore::create(m_Columns);
  set_model(m_refTreeModel);

 // Fill the TreeView's model
 // Gtk::TreeModel::Row row = *(m_refTreeModel->append());
/*
  row[m_Columns.m_col_trackNum] = 1;
  row[m_Columns.m_col_trackName] = "right-click on this";
  row[m_Columns.m_col_trackPath] = "right-click on this";

  row = *(m_refTreeModel->append());
  row[m_Columns.m_col_trackNum]= 2;
  row[m_Columns.m_col_trackName] = "or this";
  row[m_Columns.m_col_trackPath] = "right-click on this";

  row = *(m_refTreeModel->append());
  row[m_Columns.m_col_trackNum] = 3;
  row[m_Columns.m_col_trackName] = "or this, for a popup context menu";
  row[m_Columns.m_col_trackPath] = "right-click on this";
*/

// master plan is to run through a vector to populate values


 
  //Add the TreeView's view columns:
  append_column("Track", m_Columns.m_col_trackNum);
  append_column("Name", m_Columns.m_col_trackName);
  append_column("Path", m_Columns.m_col_trackPath);

  //Fill popup menu:
  Gtk::MenuItem* item = Gtk::manage(new Gtk::MenuItem("_Play", true));
  item->signal_activate().connect(
    sigc::mem_fun(*this, &PlaylistViewer::on_menu_file_popup_generic) );
  m_Menu_Popup.append(*item);
    
  item = Gtk::manage(new Gtk::MenuItem("_Queue", true));
  item->signal_activate().connect(
    sigc::mem_fun(*this, &PlaylistViewer::on_menu_file_popup_generic) );
  m_Menu_Popup.append(*item);
    
  item = Gtk::manage(new Gtk::MenuItem("_Info", true));
  item->signal_activate().connect(
    sigc::mem_fun(*this, &PlaylistViewer::on_menu_file_popup_generic) );
  m_Menu_Popup.append(*item);

  m_Menu_Popup.accelerate(*this);
  m_Menu_Popup.show_all(); //Show all menu items when the menu pops up

#ifndef GLIBMM_DEFAULT_SIGNAL_HANDLERS_ENABLED
  signal_button_press_event()
    .connect(sigc::mem_fun(*this, &PlaylistViewer::on_button_press_event), false);
#endif
}
コード例 #13
0
IMPCORE_BEGIN_NAMESPACE

//! Constructor
SteepestDescent::SteepestDescent(Model *m) :
    step_size_(0.01),
    max_step_size_(std::numeric_limits<double>::max()),
    threshold_(0.)
{
  if (m) set_model(m);
}
コード例 #14
0
ファイル: table_view.cpp プロジェクト: basisbit/neogfx
	table_view::table_view(i_layout& aLayout) :
		item_view(aLayout),
		iLayout(*this),
		iColumnHeader(iLayout, *this),
		iSpacer(iLayout)
	{
		layout().set_margins(neogfx::margins(0.0));
		set_selection_model(std::shared_ptr<i_item_selection_model>(new item_selection_model()));
		set_presentation_model(std::shared_ptr<i_item_presentation_model>(new item_presentation_model()));
		set_model(std::shared_ptr<i_item_model>(new default_item_model()));
	}
コード例 #15
0
ファイル: ImportClassesBox.cpp プロジェクト: GG31/vle
/**
 * ClassesTreeView
 */
ImportClassesBox::ClassesTreeView::ClassesTreeView(
    BaseObjectType* cobject,
    const Glib::RefPtr < Gtk::Builder >& /*refGlade*/) :
    Gtk::TreeView(cobject),
    mClasses(0)
{
    mRefTreeModel = Gtk::ListStore::create(mColumns);
    set_model(mRefTreeModel);
    append_column(_("Class name"), mColumns.m_col_name);
    mRefTreeSelection = get_selection();
}
コード例 #16
0
ファイル: pltb_frontend.c プロジェクト: stefanorf/pltb
void fprint_eval_summary(FILE *f, model_space_t *model_space, pltb_model_stat_t (*stats)[], pltb_result_t *result)
{
	double overall_time_cpu  = 0.0;
	double overall_time_real = 0.0;
	for (unsigned i = 0; i < model_space->matrix_count; i++) {
		overall_time_cpu += (*stats)[i].time_cpu;
		overall_time_real += (*stats)[i].time_real;
	}
	char chosen_models[IC_MAX][MODEL_MATRIX_REPRESENTATION_LENGTH_SHORT];
	for (unsigned i = 0; i < IC_MAX; i++) {
		set_model(model_space, result->matrix_index[i]);
		memcpy(&chosen_models[i], &model_space->matrix_repr_short, MODEL_MATRIX_REPRESENTATION_LENGTH * sizeof(char));
	}
	PRINT_HLINE(f);
	PRINT_SUMMARY(f, overall_time_cpu, overall_time_real, chosen_models);
	PRINT_HLINE(f);
}
コード例 #17
0
ObjectsTreeView::ObjectsTreeView(std::shared_ptr<CG::World> world) :
_world(world) {
  _refObjectsTreeModel = Gtk::ListStore::create(_objectsModelColumns);
  set_model(_refObjectsTreeModel);

  append_column("Name", _objectsModelColumns.colName);
  append_column("Type", _objectsModelColumns.colType);

  // _refObjectsTreeModel->set_sort_column(0, Gtk::SORT_ASCENDING);

  //Make all the columns reorderable
  for(guint i = 0; i < 2; i++) {
    Gtk::TreeView::Column* pColumn = get_column(i);
    pColumn->set_reorderable();
  }

  init_popup_menu();
}
コード例 #18
0
ファイル: navi.cpp プロジェクト: yborisovstc/fap2-studio-gtk
void NaviNatN::SetDesEnv(MEnv* aDesEnv)
{
    if (aDesEnv != iDesEnv) {
	unset_model();
	remove_all_columns();
	Glib::RefPtr<TreeModel> curmdl = get_model();
	curmdl.reset();
	iDesEnv = aDesEnv;
	if (iDesEnv != NULL) {
	    Glib::RefPtr<NatnTreeMdl> mdl = NatnTreeMdl::create(iDesEnv->Provider());
	    GtkTreeModel* model = mdl->Gtk::TreeModel::gobj();
	    bool isds = GTK_IS_TREE_DRAG_SOURCE(model);
	    set_model(mdl);
	    append_column( "one", mdl->ColRec().name);
	    enable_model_drag_source();
	    drag_source_set (Gtk::ArrayHandle_TargetEntry(targetentries));
	}
    }
}
コード例 #19
0
ファイル: tree.cpp プロジェクト: bhesh/Programs
Tree::Tree() {

	// Initializing everything
	char DIR[256] = "/home/brian/Programs/classcatcher";
	
	sprintf( course_file, "%s/etc/.courses", DIR );
	sprintf( course_temp, "%s/etc/.courses.tmp", DIR );

	m_refTreeModel = Gtk::ListStore::create( m_Columns );
	set_model( m_refTreeModel );
	
	append_column( "CRN", m_Columns.m_col_crn );
	append_column( "Term", m_Columns.m_col_term );
	append_column( "Year", m_Columns.m_col_year );
	append_column( "Subject", m_Columns.m_col_subj );
	append_column( "CRSE", m_Columns.m_col_crse );
	
	loadfromfile();
}
コード例 #20
0
control::control(imodel* const Model, k3d::istate_recorder* const StateRecorder) :
	m_implementation(new implementation(Model, StateRecorder))
{
	if(Model)
	{
		Model->connect_changed(sigc::mem_fun(*this, &control::on_data_changed));
		Model->connect_enumeration_values_changed(sigc::mem_fun(*this, &control::on_enumeration_values_changed));
	}

	set_model(m_implementation->m_list_model);

	Gtk::CellRendererText* const cell_renderer = new Gtk::CellRendererText();
	pack_start(*manage(cell_renderer), true);
	add_attribute(cell_renderer->property_text(), m_implementation->m_columns.label);

	on_enumeration_values_changed();
	on_data_changed(0);

	signal_changed().connect(sigc::mem_fun(*this, &control::on_list_changed));
}
コード例 #21
0
GtkTorrentSideBar::GtkTorrentSideBar(GtkTreeView *tree, const Glib::RefPtr<Gtk::Builder> rbuilder)
  : Gtk::TreeView(tree), m_builder(rbuilder)
{
	rbuilder->get_widget_derived("GtkMainWindow", m_parent);
	rbuilder->get_widget_derived("rssDialog", m_rss);
	m_rss->set_transient_for(*m_parent);

	m_liststore = Gtk::TreeStore::create(m_cols);

	set_model(m_liststore);

	set_headers_visible(false);
	set_show_expanders(true);
	set_activate_on_single_click();
	expand_all(); // Shouldn't this go after setupColumns()?

	signal_row_activated().connect([this](const Gtk::TreeModel::Path& Path, Gtk::TreeViewColumn *col){ this->onRowClicked(*m_liststore->get_iter(Path)); });

	setupColumns();
}
コード例 #22
0
ファイル: Chooser.cpp プロジェクト: m2osw/turnwatcher
Chooser::Chooser()
{
	f_store		= Gtk::ListStore::create    ( f_columns );
	f_sortStore	= Gtk::TreeModelSort::create( f_store   );

	set_model( f_sortStore );
	set_rules_hint();
	set_headers_visible( false );
	set_headers_clickable( false );
	set_enable_search( false );

	// Create the first visible column (icon + name)
	//
	f_nameColumn	= addTextColumn( gettext("Name"), f_columns.name );

	f_sortStore->set_sort_column( f_columns.name, Gtk::SORT_ASCENDING );

	f_selection = get_selection();
	f_selection->set_mode( Gtk::SELECTION_SINGLE );
	f_selection->signal_changed().connect( sigc::mem_fun( *this, &Chooser::onSelectionChanged ) );
}
コード例 #23
0
TreeViewGoods::TreeViewGoods()
{
    /* Create tree */
    treeRecords = Gtk::ListStore::create( treeColumns );
    set_model( treeRecords );

    /* Create columns */
    append_column( "Код", treeColumns.id );
    append_column( "Наименование", treeColumns.name );
    append_column( "Цена", treeColumns.price );
    append_column( "Ед.Изм.", treeColumns.item );

    /* Create popup menu */
    Gtk::MenuItem* item = Gtk::manage( new Gtk::MenuItem( "Подробнее" ) );
    item->signal_activate().connect( sigc::mem_fun( *this, &TreeViewGoods::on_menu_file_popup_generic ) );
    menuPopup.append( *item );
    menuPopup.accelerate( *this );
    menuPopup.show_all();

    /* Connect press event signal (mouse clicks) */
    signal_button_press_event().connect( sigc::mem_fun( *this, &TreeViewGoods::on_button_press_event ), false );
}
コード例 #24
0
ファイル: info_dvdcd.c プロジェクト: adrianomelo/ldc-desktop
ldc_info_t * info (int log) {
	hd_data_t * hd_data = new_hd_data_t();
	hd_t *hd;

	hd = hd_list(hd_data, hw_cdrom, 1, NULL);

	ldc_info_t * head = NULL;
	ldc_info_t * tail = NULL;

	char buffer[500];

	for(; hd; hd = hd->next) {
		if (! head) {
			head = new_ldc_info_t("dvdcd");
			tail = head;
		} else {
			tail->next = new_ldc_info_t("dvdcd");
			tail = tail->next;
		}

		set_vendor(tail, "vendor", hd->vendor.name, hd->vendor.id, "Vendor");
		set_model(tail, "model", hd->device.name, hd->device.id, "Model");

		add_info_tuple(tail, "device", hd->unix_dev_names->str, -1, "Device file");
		add_info_tuple(tail, "drivers", format_drivers(hd, buffer), -1, "Drivers");
		add_info_tuple(tail, "medias", format_medias(hd, buffer), -1, "Supported media types");

		tail->return_status = 1;
	}

	if (log){
		insert_info_log(head);
	}

	free_hd_structs (hd_data, hd);

	return head;
}
コード例 #25
0
MainTreeView::MainTreeView(std::vector<Player>& players_list) :
  players_list(players_list)
{
  //Create the Tree model:
  m_refTreeModel = Gtk::ListStore::create(m_Columns);
  set_model(m_refTreeModel);

  //Fill the TreeView's model
  updateTreeView();

  //Add the TreeView's view columns:
  append_column("Rank", m_Columns.m_col_rank);
  append_column("ID", m_Columns.m_col_id);
  append_column("Name", m_Columns.m_col_name);
  append_column("Elo", m_Columns.m_col_elo);
  append_column("K Coefficient", m_Columns.m_col_kcoeff);

  //Fill popup menu:
  auto item = Gtk::manage(new Gtk::MenuItem("_Edit", true));
  item->signal_activate().connect(
    sigc::mem_fun(*this, &MainTreeView::on_menu_file_popup_edit_player) );
  m_Menu_Popup.append(*item);

  item = Gtk::manage(new Gtk::MenuItem("_Add a Result", true));
  item->signal_activate().connect(
    sigc::mem_fun(*this, &MainTreeView::on_menu_file_popup_add_result) );
  m_Menu_Popup.append(*item);

  item = Gtk::manage(new Gtk::MenuItem("_Remove", true));
  item->signal_activate().connect(
    sigc::mem_fun(*this, &MainTreeView::on_menu_file_popup_remove_player) );
  m_Menu_Popup.append(*item);

  m_Menu_Popup.accelerate(*this);
  m_Menu_Popup.show_all(); //Show all menu items when the menu pops up
}
コード例 #26
0
ファイル: cktsgen.c プロジェクト: Anastien/ngspice
int
sgen_next(sgen **xsg)
{
	sgen	*sg = *xsg;
	int	good, done;
	int	i;

	done = 0;
	i = sg->dev;

	do {
		if (sg->instance) {
			if (sg->ptable) {
				do {
					sg->param += 1;
				} while (sg->param < sg->max_param
					&& !set_param(sg));
			} else {
				sg->max_param = -1;
			}

			if (sg->param < sg->max_param) {
				done = 1;
			} else if (!sg->is_instparam) {
				/* Try instance parameters now */
				sg->is_instparam = 1;
				sg->param = -1;
				sg->max_param =
					*DEVices[i]->DEVpublic.numInstanceParms;
				sg->ptable =
					DEVices[i]->DEVpublic.instanceParms;
			} else {
				sg->is_principle = 0;
				sg->instance->GENnextInstance =
					sg->next_instance;
				sg->instance->GENstate = sg->istate;
				sg->instance = NULL;
			}

		} else if (sg->model) {

			/* Find the first/next good instance for this model */
			for (good = 0; !good && sg->next_instance;
				good = set_inst(sg))
			{
				sg->instance = sg->next_instance;
				sg->next_instance =
					sg->instance->GENnextInstance;
			}


			if (good) {
				sg->is_principle = 0;
				sg->istate = sg->instance->GENstate;
				sg->instance->GENnextInstance = NULL;
				sg->model->GENinstances = sg->instance;
				if (DEVices[i]->DEVpublic.modelParms) {
					sg->max_param =
						*DEVices[i]->DEVpublic.
						numModelParms;
					sg->ptable =
						DEVices[i]->DEVpublic.
						modelParms;
				} else {
					sg->ptable = NULL;
				}
				sg->param = -1;
				sg->is_instparam = 0;
			} else {
				/* No good instances of this model */
				sg->model->GENinstances = sg->first_instance;
				sg->model->GENnextModel = sg->next_model;
				sg->model = NULL;
			}

		} else if (i >= 0) {

			/* Find the first/next good model for this device */
			for (good = 0; !good && sg->next_model;
				good = set_model(sg))
			{
				sg->model = sg->next_model;
				sg->next_model = sg->model->GENnextModel;
			}

			if (good) {
				sg->model->GENnextModel = NULL;
				sg->devlist[i] = sg->model;
				if (DEVices[i]->DEVpublic.modelParms) {
					sg->max_param =
						*DEVices[i]->DEVpublic.
						numModelParms;
					sg->ptable =
						DEVices[i]->DEVpublic.
						modelParms;
				} else {
					sg->ptable = NULL;
				}
				sg->next_instance = sg->first_instance
					= sg->model->GENinstances;
			} else {
				/* No more good models for this device */
				sg->devlist[i] = sg->first_model;
				i = -1; /* Try the next good device */
			}

		} else if (i < DEVmaxnum && sg->dev < DEVmaxnum) {

			/* Find the next good device in this circuit */

			do
				sg->dev++;
			while (sg->dev < DEVmaxnum && sg->devlist[sg->dev]
				&& !set_dev(sg));

			i = sg->dev;

			if (i >= DEVmaxnum) /* PN: Segafult if not = */
				done = 1;
			sg->first_model = sg->next_model = (i<DEVmaxnum) ? sg->devlist[i] : NULL;

		} else {
			done = 1;
		}

	} while (!done);

	if (sg->dev >= DEVmaxnum) {
		FREE(sg);
		*xsg = NULL;
	}
	return 1;
}
コード例 #27
0
ファイル: ComboboxString.hpp プロジェクト: GG31/vle
 /**
  * Create new ComboBoxString with an empty list.
  *
  */
 ComboBoxString() {
     mListStore = Gtk::ListStore::create(mColumn);
     set_model(mListStore);
     pack_start(mColumn.mString);
 }
コード例 #28
0
ファイル: ui_fileview.cpp プロジェクト: pinecrew/pinefm
ListView::ListView() : Gtk::TreeView()
{
    // поиграемся с TreeView
    // создаём модель
    m_refTreeModel = Gtk::ListStore::create( m_Columns );
    set_model( m_refTreeModel );
    // Теперь добавляем столбцы для отображения
    append_column( "Name", m_Columns.m_col_name );
    append_column( "Size", m_Columns.m_col_size );
    append_column( "User/Group", m_Columns.m_col_users );
    append_column( "Permission", m_Columns.m_col_permission );
    append_column( "Type", m_Columns.m_col_type );
    append_column( "Modified", m_Columns.m_col_modified );

    //Set the sort column of the Tree model:
    m_refTreeModel->set_sort_column(0, Gtk::SORT_ASCENDING);

    Gtk::TreeView::Column* pColumn;
    pColumn = get_column(0);
    if( pColumn )
        pColumn->set_sort_column( m_Columns.m_col_name );
    pColumn = get_column(1);
    if( pColumn )
        pColumn->set_sort_column( m_Columns.m_col_size );
    pColumn = get_column(2);
    if( pColumn )
        pColumn->set_sort_column( m_Columns.m_col_users );
    pColumn = get_column(3);
    if( pColumn )
        pColumn->set_sort_column( m_Columns.m_col_permission );
    pColumn = get_column(4);
    if( pColumn )
        pColumn->set_sort_column( m_Columns.m_col_type );
    pColumn = get_column(5);
    if( pColumn )
        pColumn->set_sort_column( m_Columns.m_col_modified );
    //Fill popup menu:
      Gtk::MenuItem* item = Gtk::manage(new Gtk::MenuItem("_Open", true));
      item->signal_activate().connect(
        sigc::mem_fun(*this, &ListView::on_menu_file_popup_generic) );
      m_Menu_Popup.append(*item);

      item = Gtk::manage(new Gtk::MenuItem("_Open with…", true));
      item->signal_activate().connect(
        sigc::mem_fun(*this, &ListView::on_menu_file_popup_generic) );
      m_Menu_Popup.append(*item);

      item = Gtk::manage(new Gtk::MenuItem("_Properties", true));
      item->signal_activate().connect(
        sigc::mem_fun(*this, &ListView::on_menu_file_popup_generic) );
      m_Menu_Popup.append(*item);

      m_Menu_Popup.accelerate(*this);
      m_Menu_Popup.show_all(); //Show all menu items when the menu pops up

      signal_button_press_event()
        .connect(sigc::mem_fun(*this, &ListView::on_button_press_event), false);

    Navigator nvg;
    show_file_list( nvg.get_file_list() );
}
コード例 #29
0
ldc_info_t * info (int log) {
	ldc_info_t * head = NULL;
	ldc_info_t * tail = NULL;

	hd_data_t * hd_data = new_hd_data_t();
	hd_t *hd;
	hd_res_t *res;

	hd = hd_list(hd_data, hw_usb, 1, NULL);

	for(; hd; hd = hd->next) {
		if (hd->hw_class){
			if (hd->hw_class == hw_disk){ //apenas os discos usb
				if (hd->device.name && (strstr(hd->device.name, "Card") == NULL && strstr(hd->device.name, "card") == NULL )){
					if (! head) {
						head = new_ldc_info_t("pendrive");
						tail = head;
					} else {
						tail->next = new_ldc_info_t("pendrive");
						tail = tail->next;
					}

					if(hd->vendor.name){
						set_vendor (tail, "vendor", hd->vendor.name, -1, "Vendor");
					} else {
						set_vendor (tail, "vendor", "Unknown", -1, "Vendor");
					}
					if (hd->device.name){
						set_model (tail, "device", hd->device.name, -1, "Model");
					} else {
						set_model (tail, "device", "Unknown", -1, "Model");
					}

					if(hd->drivers) {
						char *s = hd_join("; ", hd->drivers);
						add_info_tuple(tail, "driver", s, -1, "Driver");
						free(s);
					} else {
						add_info_tuple(tail, "driver", "Unknown", -1, "Driver");
					}
					if (hd->unix_dev_name){
						add_info_tuple(tail, "device_file", hd->unix_dev_name, -1, "Device File");
						partitions_info(hd->unix_dev_name, tail);
					} else {
						add_info_tuple(tail, "device_file", "Unknown", -1, "Device File");
					}
					int speed = -1;
					int size = -1;
					for(res = hd->res; res; res = res->next) {
						switch(res->any.type) {
							case res_baud:
								//convertendo para Mbps (divisão por 10^6)
								speed = res->baud.speed/1000000;
								break;
							case res_size:
								if(res->size.unit == size_unit_sectors){
									//FIXME: adicionado 1 e feito floor => usar ceil
									size = ((res->size.val1*res->size.val2)/1073741824.0) + 1; //byte => GB
								}
								break;
							default:
								break;
						}
					}
					add_info_tuple(tail, "speed", NULL, speed, "Speed (in Mbps)");
					add_info_tuple(tail, "Size", NULL, size, "Size (in GB)");
				}
			}
		}
	}

	if (tail) {
		tail->return_status = 1;
	} else {
		//printf("Não foi detectado nenhum pen drive!!\n");

		//FIXME: deve ser padronizado o retorno
		//head = new_ldc_info_t("pendrive");
	}

	free_hd_structs (hd_data, hd);

	if (log){
		insert_info_log(head);
	}

	return head;
}
コード例 #30
0
item_refcount::item_refcount(model_multipart *m)
{
	set_model(m);
}