Beispiel #1
0
SettingsDialog::SettingsDialog(Gtk::Window& window) : Gtk::MessageDialog(window, _("Scolily Settings"), false, Gtk::MESSAGE_INFO, Gtk::BUTTONS_OK_CANCEL , true)
{
    set_title(_("Settings"));

    set_secondary_text(_("Scolily can use many plugins to export your partitions, in addition of lilypond built-in abilities."));

    
    ThresholdLabel.set_text(_("Threshold:"));
    OutputPluginLabel.set_text(_("Output plugin:"));
    
    ThresholdInput.set_range(-90,0);
    ThresholdInput.set_width_chars(3);
    ThresholdInput.set_increments(1,5);
    ThresholdInput.set_value(Threshold);
    
    get_vbox()->add(m_hbox1);
    m_hbox1.add(ThresholdLabel);
    m_hbox1.add(ThresholdInput);
    
    get_vbox()->add(m_hbox2);
    m_hbox2.add(OutputPluginLabel);
    m_hbox2.add(ComboBoxOutput);
    
    
    show_all_children(); // On affiche tout, et on laisse l'utilisateur
}
Beispiel #2
0
Gobby::PreferencesDialog::PreferencesDialog(Gtk::Window& parent,
                                            FileChooser& file_chooser,
                                            Preferences& preferences,
	                                    CertificateManager& cert_manager):
	Gtk::Dialog(_("Preferences"), parent), m_preferences(preferences),
	m_page_user(*this, preferences), m_page_editor(preferences),
	m_page_view(preferences), m_page_appearance(preferences),
	m_page_security(*this, file_chooser, preferences, cert_manager)
{
	m_notebook.append_page(m_page_user, _("User"));
	m_notebook.append_page(m_page_editor, _("Editor"));
	m_notebook.append_page(m_page_view, _("View"));
	m_notebook.append_page(m_page_appearance, _("Appearance"));
	m_notebook.append_page(m_page_security, _("Security"));

	m_page_user.show();
	m_page_editor.show();
	m_page_view.show();
	m_page_appearance.show();
	m_page_security.show();

	get_vbox()->set_spacing(6);
	get_vbox()->pack_start(m_notebook, Gtk::PACK_EXPAND_WIDGET);
	m_notebook.show();

	add_button(Gtk::Stock::CLOSE, Gtk::RESPONSE_CLOSE);

	set_border_width(12);
	set_resizable(false);
}
Beispiel #3
0
Gobby::EntryDialog::EntryDialog(Gtk::Window& parent,
                                const Glib::ustring& title,
                                const Glib::ustring& label):
	Gtk::Dialog(title, parent, true, true), m_label(label), m_box(false, 5),
	m_check_valid_entry(false)
{
	m_entry.set_activates_default(true);

	m_box.pack_start(m_label);
	m_box.pack_start(m_entry);

	get_vbox()->set_spacing(5);
	get_vbox()->pack_start(m_box);

	m_entry.signal_changed().connect(
		sigc::mem_fun(*this, &EntryDialog::on_entry_changed)
	);

	add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
	add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);
	set_default_response(Gtk::RESPONSE_OK);

	show_all();
	set_border_width(10);
	set_resizable(false);
}
Beispiel #4
0
/**
 * Constructor
 */ 
AboutBox::AboutBox() : Gtk::Dialog(_("About Inkscape")) {

    // call this first
    initStrings();

    Gtk::Notebook *tabs=new Gtk::Notebook();

    tabs->set_scrollable();

    Gtk::Widget *splash=build_splash_widget();
    if (splash) {
        tabs->append_page(*manage(splash), _("_Splash"), true);
    }

    tabs->append_page(*manage(
        make_scrolled_text(authors_text)), _("_Authors"), true);
    tabs->append_page(*manage(
        make_scrolled_text(translators_text)), _("_Translators"), true);
    tabs->append_page(*manage(
        make_scrolled_text(license_text)), _("_License"), true);

#if WITH_GTKMM_3_0
    get_content_area()->pack_end(*manage(tabs), true, true);
#else
    get_vbox()->pack_end(*manage(tabs), true, true);
#endif

    tabs->show_all();

    add_button(Gtk::Stock::CLOSE, Gtk::RESPONSE_CLOSE);
    set_default_response(Gtk::RESPONSE_CLOSE);

    Gtk::Label *label=new Gtk::Label();
    gchar *label_text = 
        g_strdup_printf("<small>Inkscape %s</small>",
              Inkscape::version_string);
    label->set_markup(label_text);
    label->set_alignment(Gtk::ALIGN_END, Gtk::ALIGN_CENTER);
    label->set_padding(5,0);
    g_free(label_text);
    label->set_selectable(true);
    label->show();

#if WITH_GTKMM_3_0
    get_content_area()->pack_start(*manage(label), false, false);
#else
    get_vbox()->pack_start(*manage(label), false, false);
#endif

    Gtk::Requisition requisition;
#if GTK_CHECK_VERSION(3,0,0)
    gtk_widget_get_preferred_size(reinterpret_cast<GtkWidget*>(gobj()), &requisition, NULL);
#else
    gtk_widget_size_request (reinterpret_cast<GtkWidget*>(gobj()), &requisition);
#endif
    // allow window to shrink
    set_size_request(0, 0);
    set_default_size(requisition.width, requisition.height);
}
MarketBuildOptionsDialog::MarketBuildOptionsDialog(const std::string& CommonBuildOptions, const std::string& BuildOptions, const std::string FuncID)
: Gtk::Dialog(), m_CommonBuildOptions(CommonBuildOptions),m_BuildOptions(BuildOptions),m_FuncID(FuncID)
{

  set_size_request(450,-1);
  set_border_width(6);

  Gtk::Label* InfoLabel = Gtk::manage(new Gtk::Label());
  InfoLabel->set_markup(std::string("<i>")+_("These options control the builds of source packages.\nChanging this is at your own risk.")+std::string("</i>"));
  InfoLabel->set_justify(Gtk::JUSTIFY_CENTER);

  get_vbox()->pack_start(*InfoLabel);

  Gtk::Label* CommonOptsLabel = Gtk::manage(new Gtk::Label());

  if (!FuncID.empty())
    CommonOptsLabel->set_markup(_("<u>Common source build options:</u>\n")
                                +openfluid::tools::ReplaceEmptyString(CommonBuildOptions,_("<i>none</i>")));
  else
    CommonOptsLabel->set_label("");

  CommonOptsLabel->set_alignment(0,0.5);
  get_vbox()->pack_start(*CommonOptsLabel,Gtk::PACK_SHRINK,12);


  Gtk::Label* EditLabel = Gtk::manage(new Gtk::Label());
  if (!FuncID.empty())
  {
    EditLabel->set_label(_("Specific build options for ")+FuncID+_(":"));
  }
  else
  {
    EditLabel->set_label(_("Common source build options:"));
  }
  EditLabel->set_alignment(0,0.5);
  get_vbox()->pack_start(*EditLabel);

  if (FuncID.empty()) m_OptionsEntry.set_text(CommonBuildOptions);
  else m_OptionsEntry.set_text(BuildOptions);
  get_vbox()->pack_start(m_OptionsEntry);

  add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
  add_button(Gtk::Stock::OK, Gtk::RESPONSE_OK);

  if(m_FuncID.empty())
    set_title(_("Common build options for all source packages"));
  else
    set_title(_("Build options for ") + m_FuncID);


  show_all_children();
}
Beispiel #6
0
 pinDialogPriv(pinDialog &,const void *opsysParam) :
     Gtk::Dialog("inputDialog",true), m_label("pin entry")
     {
     m_textInput.set_activates_default(true);
     get_vbox()->pack_start(m_label);
     m_label.set_alignment(0.1,0.5);
     get_vbox()->pack_start(m_textInput);
     m_textInput.set_visibility(false);
     set_has_separator(true);
     add_button(Gtk::Stock::OK,Gtk::RESPONSE_OK);
     add_button(Gtk::Stock::CANCEL ,Gtk::RESPONSE_CANCEL);
     set_default_response(Gtk::RESPONSE_CANCEL);
     show_all_children();
     }
Beispiel #7
0
    ErrorDialog::ErrorDialog (const String& main_message) : 
      Gtk::Dialog ("Error", true, false),
      more ("details"),
      icon (Gtk::Stock::DIALOG_ERROR, Gtk::ICON_SIZE_DIALOG)
    {
      set_border_width (5);
      add_button (Gtk::Stock::OK, Gtk::RESPONSE_OK);
      text.set_label (main_message);

      model = Gtk::ListStore::create (columns);
      details.set_model (model);

      details.append_column ("level", columns.icon);
      details.append_column ("message", columns.text);
      details.set_headers_visible (false);

      for (std::list<ErrorMsg>::iterator msg = messages.begin(); msg != messages.end(); ++msg) {
        Gtk::TreeModel::Row row = *(model->append());
        row[columns.icon] = render_icon (( msg->loglevel == 1 ? Gtk::Stock::DIALOG_ERROR : Gtk::Stock::DIALOG_INFO ), Gtk::ICON_SIZE_MENU);
        row[columns.text] = msg->text;
      }

      hbox.set_border_width (10);
      hbox.set_spacing (10);
      hbox.pack_start (icon, Gtk::PACK_SHRINK);
      hbox.pack_start (text);

      details_window.add (details);
      details_window.set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
      details_window.set_shadow_type (Gtk::SHADOW_IN);

      more.add (details_window);

      get_vbox()->pack_start (hbox, Gtk::PACK_SHRINK);
      get_vbox()->pack_start (more);

      show_all();

      if (Window::list_toplevels().size()) {
        int x, y, w, h;
        if (*Window::list_toplevels().begin()) {
          (*Window::list_toplevels().begin())->get_position (x, y);
          (*Window::list_toplevels().begin())->get_size (w, h);
          x = x + (w - get_width())/2;
          y = y + (h - get_height())/2;
          move (x,y);
        }
      }
    }
Beispiel #8
0
DlgDownload::DlgDownload(){
  add_button (Gtk::Stock::OK,     Gtk::RESPONSE_OK);
  add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
  signal_response().connect(
      sigc::hide(sigc::mem_fun(this, &DlgDownload::hide_all)));

  cb_w   = manage(new Gtk::CheckButton("Waypoints"));
  cb_a   = manage(new Gtk::CheckButton("Active log"));
  cb_o   = manage(new Gtk::CheckButton("Saved tracks"));
  Gtk::VButtonBox * bbox =  manage(new Gtk::VButtonBox);
  bbox->add(*cb_w);
  bbox->add(*cb_a);
  bbox->add(*cb_o);
  Gtk::Frame * frame =
    manage(new Gtk::Frame("Select data to be downloaded:"));
  frame->add(*bbox);

  Gtk::Label * l_dev =
    manage(new Gtk::Label("GPS device:", Gtk::ALIGN_RIGHT));
  e_dev = manage(new Gtk::Entry);

  cb_off = manage(new Gtk::CheckButton("Turn off device after download"));

  Gtk::Table * table = manage(new Gtk::Table(2,3));
  table->attach(*frame,  0,2, 0,1, Gtk::FILL, Gtk::SHRINK, 3,3);
  table->attach(*l_dev,  0,1, 1,2, Gtk::SHRINK, Gtk::SHRINK, 3,3);
  table->attach(*e_dev,  1,2, 1,2, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK, 3,3);
  table->attach(*cb_off, 0,2, 2,3, Gtk::FILL, Gtk::SHRINK, 3,3);

  get_vbox()->add(*table);
}
void
ExpireDialog::init()
{
    _spinner.set_numeric (true);
    _spinner.set_digits (1);
    _spinner.set_range (0, 30);
    _spinner.set_snap_to_ticks();
    _spinner.set_adjustment (_adj);
    _spinner.set_value (AppContext::get().get_expire());

    Gtk::VBox *vbox = get_vbox();
    vbox->pack_start (_label1, Gtk::PACK_SHRINK, 10);
    _box.add (*new Gtk::HBox);
    _box.pack_start (_spinner, Gtk::PACK_SHRINK, 10);
    _box.pack_start (_label2, Gtk::PACK_SHRINK, 0);
    _box.add (*new Gtk::HBox);
    vbox->pack_start (_box, Gtk::PACK_EXPAND_PADDING, 10);

    add_button (_("Do expire"), 1);
    add_button (Gtk::Stock::CANCEL, 0);

    /// Move focus to Do button
    cwidget_list_t list = get_action_area()->get_children();
    for (cwidget_list_t::iterator it = list.begin(); it != list.end(); ++it)
        if (get_response_for_widget (**it) == 1)
        { const_cast<Widget&>(**it).grab_focus(); break; }
    
    _changed_connection = _adj.signal_value_changed().connect (
            sigc::mem_fun (*this, &ExpireDialog::on_value_changed));
    
    show_all();
}
JoystickListWidget::JoystickListWidget()
  : Gtk::Dialog("Joystick Preferences"),
    label("Below is a list of available joysticks on the system. Press Refresh to "
          "update the list, press Properties to get a separate device dialog. The "
          "devices listed are only joystick devices, not evdev devices or SDL "
          "devices, you can view the other ones via the top tab.")
    //frame("Device List"),
{
  set_has_separator(false);
  set_default_size(450, 310);

  label.set_line_wrap();

  scrolled.set_border_width(5);
  scrolled.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_ALWAYS);
  scrolled.add(treeview);
  get_vbox()->add(scrolled);

  add_button(Gtk::Stock::REFRESH, 2);
  add_button(Gtk::Stock::PROPERTIES, 1);
  add_button(Gtk::Stock::CLOSE, 0);

  signal_response().connect(sigc::mem_fun(this, &JoystickListWidget::on_response));

  // Set model
  device_list = Gtk::ListStore::create(DeviceListColumns::instance());
  treeview.set_model(device_list);
  treeview.set_headers_visible(false);
  treeview.append_column("Icon", DeviceListColumns::instance().icon);
  treeview.append_column("Name", DeviceListColumns::instance().name);

  treeview.signal_row_activated().connect(sigc::mem_fun(this, &JoystickListWidget::on_row_activated));

  on_refresh();
}
Beispiel #11
0
ParamsDialog::ParamsDialog(MainWindow *_mw) : Gtk::Dialog("Parameters", *_mw, true),
	mw(_mw)
{
	add_button(Gtk::Stock::CANCEL, Gtk::ResponseType::RESPONSE_CANCEL);
	add_button(Gtk::Stock::OK, Gtk::ResponseType::RESPONSE_OK);

	Gtk::Box* box = get_vbox();
	Gtk::Table *tbl = Gtk::manage(new Gtk::Table(3,2));

	f_c_re = Gtk::manage(new Util::HandyEntry<Fractal::Value>());
	f_c_re->set_activates_default(true);
	f_c_im = Gtk::manage(new Util::HandyEntry<Fractal::Value>());
	f_c_im->set_activates_default(true);

	zc = Gtk::manage(new ZoomControl(mw));

	Gtk::Label* label;

	label = Gtk::manage(new Gtk::Label("Centre Real (x) "));
	label->set_alignment(1, 0.5);
	tbl->attach(*label, 0, 1, 0, 1);
	tbl->attach(*f_c_re, 1, 2, 0, 1);

	label = Gtk::manage(new Gtk::Label("Centre Imaginary (y) "));
	label->set_alignment(1, 0.5);
	tbl->attach(*label, 0, 1, 1, 2);
	tbl->attach(*f_c_im, 1, 2, 1, 2);

	tbl->attach(*zc, 0, 2, 2, 3);

	box->pack_start(*tbl);
	set_default_response(Gtk::ResponseType::RESPONSE_OK);
}
Beispiel #12
0
void
SpinnerDialog::configure(const Glib::ustring & title,
                         const Glib::ustring & text) throw()
{
    set_title(title);
    set_border_width(12);
    set_default_size(408, 108);
    set_has_separator(false);

    Gtk::VBox * const dialog_vbox = get_vbox();
    dialog_vbox->set_spacing(18);
    dialog_vbox->pack_start(hBox_, Gtk::PACK_EXPAND_WIDGET, 0);

    spinner_.set_size(Gtk::ICON_SIZE_DIALOG);
    hBox_.pack_start(spinner_, Gtk::PACK_SHRINK, 0);

    primaryLabel_.set_markup(text);
    primaryLabel_.set_use_markup(true);
    hBox_.pack_start(primaryLabel_, Gtk::PACK_EXPAND_WIDGET, 0);

    add_button(Gtk::Stock::CLOSE, Gtk::RESPONSE_CLOSE);
    set_default_response(Gtk::RESPONSE_CLOSE);

    show_all_children();
}
Beispiel #13
0
void SimpleTypeBox::makeDialog()
{
    mEntry = new Gtk::Entry();
    mEntry->set_editable(true);
    mEntry->set_activates_default(true);
    if (mBase) {
        if (mBase->getType() == value::Value::TUPLE) {
            std::string buffer;
            value::Tuple* tuple =
                        dynamic_cast < value::Tuple* >(mBase);

            for (value::Tuple::size_type i = 0; i < tuple->size(); ++i) {
                buffer += (fmt("%1% ") %
                          utils::toScientificString((*tuple)[i],true)).str();
            }
            mEntry->set_text(buffer);
        } else if (mBase->getType() == value::Value::DOUBLE) {
            value::Double* v = dynamic_cast < value::Double* >(mBase);
            mEntry->set_text(utils::toScientificString(v->value(),true));
        } else {
            mEntry->set_text(mBase->writeToString());
        }
    }
    get_vbox()->pack_start(*mEntry);
}
Beispiel #14
0
options::options (Gtk::Window & parent, perform * a_p):
    Gtk::Dialog ("Options", parent, true, true),
    m_perf(a_p)
{
#if GTK_MINOR_VERSION < 12
    m_tooltips = manage(new Tooltips());
#endif

    HBox *hbox = manage (new HBox ());
    get_vbox ()->pack_start (*hbox, false, false);

    get_action_area ()->set_border_width (2);
    hbox->set_border_width (6);

    m_button_ok = manage (new Button(Gtk::Stock::OK));
    get_action_area ()->pack_end (*m_button_ok, false, false);
    m_button_ok->signal_clicked ().connect (mem_fun (*this, &options::hide));

    m_notebook = manage (new Notebook ());
    hbox->pack_start (*m_notebook);

    add_midi_clock_page();
    add_midi_input_page();
    add_keyboard_page();
    add_mouse_page();
    add_jack_sync_page();
}
Beispiel #15
0
PopupConfirmation::PopupConfirmation(std::string title, Gtk::Window* parent, std::string msg) 
: Gtk::Dialog(title, *parent), boiteV(get_vbox()), label(msg)
{
	boiteV->pack_start(label);

	add_button("YES", Gtk::RESPONSE_OK);
	add_button("NO", Gtk::RESPONSE_CANCEL);
	show_all();
}
Beispiel #16
0
 ProgressDialog::ProgressDialog(std::string const &title, Gtk::Window &parent)
   : Gtk::Dialog(title, parent, true),
     m_cancel(false),
     mp_progress_bar(Gtk::manage(new Gtk::ProgressBar()))
 {
   set_resizable(false);
   set_has_separator(false);
   
   get_vbox()->set_border_width(Layout::BORDER_WIDTH);
   get_vbox()->pack_start(*mp_progress_bar, Gtk::PACK_SHRINK);
   
   Gtk::Button * const p_cancel_button = Gtk::manage(new Gtk::Button(Gtk::Stock::CANCEL));
   add_action_widget(*p_cancel_button, Gtk::RESPONSE_CANCEL);
   
   p_cancel_button->signal_clicked().connect(
     sigc::mem_fun(*this, &ProgressDialog::cancel_button_clicked));
   
   show_all_children();
 }
VistaSeleccioneIntervaloSegundos::VistaSeleccioneIntervaloSegundos() {
	set_title("Ha seleccionado un video, cada cuantos segundos se enviaran los frames?");
	set_size_request(550,100);
	vbox = get_vbox();
	vbox->add(segs);
	vbox->add(ok);

	ok.set_label("OK");
	ok.signal_clicked().connect( sigc::mem_fun(*this, &VistaSeleccioneIntervaloSegundos::on_button_OK) );
}
NewFromTemplate::NewFromTemplate()
    : _create_template_button(_("Create from template"))
{
    set_title(_("New From Template"));
    resize(400, 400);
    
    get_vbox()->pack_start(_main_widget);
   
    Gtk::Alignment *align;
    align = Gtk::manage(new Gtk::Alignment(Gtk::ALIGN_END, Gtk::ALIGN_CENTER, 0.0, 0.0));
    get_vbox()->pack_end(*align, Gtk::PACK_SHRINK);
    align->set_padding(0, 0, 0, 15);
    align->add(_create_template_button);
    
    _create_template_button.signal_clicked().connect(
    sigc::mem_fun(*this, &NewFromTemplate::_createFromTemplate));
   
    show_all();
}
Beispiel #19
0
DamageWindow::DamageWindow( Glib::ustring title, Gtk::Window& parent ) :
	Gtk::Dialog( title, parent, true, true ),
	f_value(0)
{
	Gtk::Label* label = new Gtk::Label(" ", Gtk::ALIGN_LEFT);
	label->set_justify( Gtk::JUSTIFY_LEFT );
	f_table.AddItem( Name, gettext("Character Name"), false, label, NULL );
	//
	label = new Gtk::Label(" ", Gtk::ALIGN_LEFT);
	label->set_justify( Gtk::JUSTIFY_LEFT );
	label->set_use_markup( true );
	f_table.AddItem( HitPoints, gettext("Current Hit Points"), false, label, NULL );
	//
	label = new Gtk::Label(" ", Gtk::ALIGN_LEFT);
	label->set_justify( Gtk::JUSTIFY_LEFT );
	label->set_use_markup( true );
	f_table.AddItem( TempHP, gettext("Temporary Hit Points"), false, label, NULL );
	//
	Gtk::Adjustment* adj = Gtk::manage( new Gtk::Adjustment(0.0, 0.0, 10000.0) );
	f_spinButton  = new Gtk::SpinButton;
	f_spinButton->configure( *adj, 0.0, 0 );
	f_spinButton->set_numeric( true );
	f_table.AddItem( DamageHealth, gettext("Enter new damage/health"), false, f_spinButton, NULL );

	// Pack children into a vbox and add buttons
	//
	Gtk::VBox* vbox = get_vbox();
	vbox->pack_start( f_table );
	//
	// Respect system-dependent alternative button order (defined
	// in gtk+ theme).
	//
	const bool alternative_order = alternative_button_order( Glib::RefPtr<const Gdk::Screen>(0) );
	//
	if( !alternative_order )
	{
		add_button( Gtk::Stock::CANCEL,		Gtk::RESPONSE_CANCEL );
	}
	//
	add_button( gettext("Bring to _Full"),	RESPONSE_FULLHEATH   );
	add_button( gettext("Add _Health"),	RESPONSE_HEALTH      );
	add_button( gettext("Add _Damage"),	Gtk::RESPONSE_OK     );
	//
	if( alternative_order )
	{
		add_button( Gtk::Stock::CANCEL,		Gtk::RESPONSE_CANCEL );
	}

	// Dialog stuff
	//
	set_default_response( Gtk::RESPONSE_OK );
	activate_default();
	show_all_children();
}
Beispiel #20
0
SettingsManager::SettingsManager():on_change_settings(this, CBT_CHANGE_SETTINGS) {
	set_title("Settings manager");
	menu.set_size_request(160, 200);

	pFixed.add(props);
	pFixed.signal_size_allocate().connect(sigc::mem_fun(*this, &SettingsManager::props_on_size_allocate));
	pFixed.signal_button_press_event().connect(sigc::mem_fun(props, &PropEditor::on_button_press_event));
	pFixed.signal_button_release_event().connect(sigc::mem_fun(props, &PropEditor::on_button_release_event));
	pFixed.signal_motion_notify_event().connect(sigc::mem_fun(props, &PropEditor::on_motion_notify_event));
	pScroll.set_policy(POLICY_AUTOMATIC, POLICY_AUTOMATIC);
	pScroll.add(pFixed);
//	pScroll.set_size_request(300, 200);

	info.set_size_request(100, 40);
	info.set_editable(false);
	info.set_wrap_mode(WRAP_WORD);

	hpaned.pack1(menu, false, false);
	hpaned.pack2(vpaned, true, true);
	vpaned.pack1(pScroll, true, true);
	vpaned.pack2(info, false, false);

	hpaned.show_all();
	get_vbox()->pack_start(hpaned, true, true);

	menuStore = Gtk::ListStore::create(menuColumns);
	menu.set_model(menuStore);
	menu.append_column("icon", menuColumns.icon);
	menu.append_column("name", menuColumns.name);
	menu.set_headers_visible(false);
	menu.signal_cursor_changed().connect(sigc::mem_fun(*this, &SettingsManager::on_show_ep_row_activated));

	add_button(Gtk::Stock::ADD, 4);
	add_button(Gtk::Stock::OPEN, 3);
	add_button(Gtk::Stock::SAVE, 2);
	add_button(Gtk::Stock::OK, 1);

	set_icon_from_file(dataDir + ICONS_PATH + "tools.png");

	void *id = mdb.begin_read_settings(0);
	ParamInfo param;
	while(mdb.read_settings(id, param)) {
		Gtk::TreeRow row = *(menuStore->append());
		row[menuColumns.name] = param.title;
		row[menuColumns.info] = param.info;
		row[menuColumns.icon] = Gdk::Pixbuf::create_from_file(dataDir + ICONS_PATH + param.list + ".png");
		row[menuColumns.id] = param.id;
	}
	mdb.end_read(id);

	props.on_change_property += this;
	props.on_select_property += this;
}
Beispiel #21
0
url_chooser::url_chooser(std::string& i, std::string& u, std::string& d) :
    ip_s(i),
    url_s(u),
    delim_s(d),
    advanced_opts("Advanced Options"),
    ip_l("Camera IP Address: "),
    url_l("MJPEG Stream Path: "),
    delim_l("MJPEG Frame Delimiter: ")
{
    //setup entries
    ip.set_text(ip_s);
    url.set_text(url_s);
    delim.set_text(delim_s);
    //signal handlers
    ip.signal_focus_out_event().connect(sigc::mem_fun(*this, &url_chooser::ip_changed));
    url.signal_focus_out_event().connect(sigc::mem_fun(*this, &url_chooser::url_changed));
    delim.signal_focus_out_event().connect(sigc::mem_fun(*this, &url_chooser::delim_changed));
#ifndef USE_DEPRECATED_GTKMM_API
    //setup frame for advanced options
    //attach url entry
    advanced_grid.attach(url_l, 0, 0, 1, 1);
    advanced_grid.attach(url, 1, 0, 1, 1);
    //attach delim entry
    advanced_grid.attach(delim_l, 0, 1, 1, 1);
    advanced_grid.attach(delim, 1, 1, 1, 1);
    //put grid in expander
    advanced_opts.add(advanced_grid);
    //setup main grid
    //attach ip address entry
    content.attach(ip_l, 0, 0, 1, 1);
    content.attach(ip, 1, 0, 1, 1);
    //attach advanced frame
    content.attach(advanced_opts, 0, 1, 2, 1);
    //add content
    get_content_area()->add(content);
#else
    ip_box.add(ip_l);
    ip_box.add(ip);
    url_box.add(url_l);
    url_box.add(url);
    delim_box.add(delim_l);
    delim_box.add(delim);
    advanced_box.add(url_box);
    advanced_box.add(delim_box);
    advanced_opts.add(advanced_box);
    content.add(ip_box);
    content.add(advanced_opts);
    get_vbox()->add(content);
#endif
    //add button
    add_button("OK", 0);
    show_all_children();
}
Beispiel #22
0
YesNoDialog::YesNoDialog(Glib::ustring const & title)
: Gtk::Dialog(title, true)
, myLabel    (title)
, myYesButton("Yes")
, myNoButton ("No")
{
	myControlLayout.pack_end(myYesButton, false, false);
	myControlLayout.pack_end(myNoButton,  false, false);

	get_vbox()->pack_start(myLabel);
	get_vbox()->pack_end  (myControlLayout);

	myYesButton.signal_clicked().connect(sigc::mem_fun(*this,
							   &YesNoDialog::on_yes_button_clicked
							   ));
	myNoButton.signal_clicked().connect (sigc::mem_fun(*this,
							   &YesNoDialog::on_no_button_clicked
							   ));

	myControlLayout.show_all_children();
	show_all_children();
}
Beispiel #23
0
EndWindow::EndWindow(void)
{
  //setting components
  question.set_label("What do you want to do next?");
  add_button("Start transmission again", TRANSMISSION);
  add_button("Start again from device recognition part", DEVICE);
  add_button("Start again from screen recognition part", SCREEN);
  add_button("Start again from begining", START);
  add_button("Exit", END);

  //setting view
  get_vbox()->pack_start(question);
  get_vbox()->pack_end(hbox);

 /* hbox.pack_start(from_start);
  hbox.pack_start(from_screen);
  hbox.pack_start(from_device);
  hbox.pack_end(end);*/

  //showing
  get_vbox()->show_all_children(true);
}
DownloadWindow::DownloadWindow() {
    // Self cofigure
    set_title ( "Reading data from device" );
    set_resizable ( false );
    set_deletable ( false );
    set_border_width ( 20 );
    // Widgets
    Gtk::VBox *box = get_vbox();
    progressBar.set_size_request ( 300, -1 );
    box->add ( progressBar );
    // Finally
    show_all_children();
}
Beispiel #25
0
ValueBox::ValueBox(value::Set* set) :
    Gtk::Dialog("Set", true, true),
    mTreeView(0),
    mValue(set)
{
    mBackup = set->clone();

    mTreeView = new TreeViewValue();
    mTreeView->makeTreeView(*set);
    set_default_size(200, 200);
    get_vbox()->pack_start(*mTreeView);
    makeDialog();
    show_all();
}
Beispiel #26
0
ValueBox::ValueBox(value::Map* map) :
    Gtk::Dialog("Map", true, true),
    mTreeView(0),
    mValue(map)
{
    mBackup = map->clone();

    mTreeView = new TreeViewValue();
    mTreeView->makeTreeView(*map);
    set_default_size(200, 200);
    get_vbox()->pack_start(*mTreeView);
    makeDialog();
    show_all();
}
WarningListDialog::WarningListDialog()
{
  set_title(_("Warning"));

  g_assert(get_vbox());
  get_vbox()->pack_start(scrolled);

  scrolled.set_border_width(LENGTH_BORDER_WIDTH);

  scrolled.add(warnings);
  scrolled.set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_ALWAYS);

  warnings.set_border_width(LENGTH_SMALLSPACE);

  try
  {
    warning_icon  = Gdk::Pixbuf::create_from_file(apply_filename_macros("$(exe-share)/icons/scalable/dialog-warning.svg"), 22, 22);
  }CATCH_ALL("**WarningListDialog::WarningListDialog**", NOTHING_MACRO);

  set_default_size(320, 480);

  show_all_children();
}
Beispiel #28
0
InputDialog::InputDialog(Glib::ustring const & title)
: Gtk::Dialog   (title, true)
, myLabel       (title)
, myOkButton    ("Ok")
, myCancelButton("Cancel")
{
	myOkButton.signal_clicked().connect    (sigc::mem_fun(*this,
						&InputDialog::on_ok_button_clicked
						));
	myCancelButton.signal_clicked().connect(sigc::mem_fun(*this,
						&InputDialog::on_cancel_button_clicked
						));

	myControlLayout.pack_end(myOkButton,     false, false);
	myControlLayout.pack_end(myCancelButton, false, false);

	get_vbox()->pack_start(myLabel,         false, true);
	get_vbox()->pack_end  (myControlLayout, false, true);
	get_vbox()->pack_end  (myEntry,         false, true);

	myControlLayout.show_all_children();
	show_all_children();
}
Beispiel #29
0
AboutDialog::AboutDialog () : OK("OK"), canvas() {
  set_title ("About EOGI");
  set_usize (400, 200);
  // don't allow resizing
  set_policy ( false, false, false );

  get_vbox()->add( &canvas );
  get_action_area()->add( &OK );

  connect_to_method ( OK.clicked, this, &AboutDialog::ok_clicked );
	
  OK.show();
  canvas.show();
}
Beispiel #30
0
void XmlTypeBox::makeBox()
{
    add_button(Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
    add_button(Gtk::Stock::OK, Gtk::RESPONSE_APPLY);

    mScrolledWindow.set_policy(Gtk::POLICY_AUTOMATIC,
        Gtk::POLICY_AUTOMATIC);

    mView = new Gtk::TextView();
    mBuff = mView->get_buffer();

    mScrolledWindow.add(*mView);
    get_vbox()->pack_start(mScrolledWindow);
}