aboutDialog::aboutDialog()
{
Gtk::Dialog *ad = this;
Gtk::Button *okbutton = Gtk::manage(new class Gtk::Button("ok"));
Gtk::Label *aboutLabel = Gtk::manage(new class Gtk::Label( "About " + GPD->sGUI_CLIENT() + " " + GPD->sVERSION() + ", build " + GPD->sBUILD() ));
Gtk::TextView *textview = Gtk::manage(new class Gtk::TextView());
Gtk::ScrolledWindow *scrolledwindow = Gtk::manage(new class Gtk::ScrolledWindow());
Gtk::VBox *vbox = Gtk::manage(new class Gtk::VBox(false, 0));
okbutton->set_flags(Gtk::CAN_FOCUS);
okbutton->set_relief(Gtk::RELIEF_NORMAL);
ad->get_action_area()->property_layout_style().set_value(Gtk::BUTTONBOX_END);
ad->set_default_size(300, 200);
aboutLabel->set_alignment(0.5,0.5);
aboutLabel->set_padding(0,0);
aboutLabel->set_justify(Gtk::JUSTIFY_LEFT);
aboutLabel->set_line_wrap(false);
aboutLabel->set_use_markup(false);
aboutLabel->set_selectable(false);
textview->set_flags(Gtk::CAN_FOCUS);
textview->set_editable(true);
textview->set_cursor_visible(true);
textview->set_pixels_above_lines(0);
textview->set_pixels_below_lines(0);
textview->set_pixels_inside_wrap(0);
textview->set_left_margin(0);
textview->set_right_margin(0);
textview->set_indent(0);
textview->set_wrap_mode(Gtk::WRAP_NONE);
textview->set_justification(Gtk::JUSTIFY_LEFT);
using namespace std;
string text;
text += "btg Copyright (C) 2005 Michael Wojciechowski.";
text += GPD->sNEWLINE();
text += "This program is free software; you can redistribute it and/or modify";
text += GPD->sNEWLINE();
text += "it under the terms of the GNU General Public License as published by ";
text += GPD->sNEWLINE();
text += "the Free Software Foundation; either version 2 of the License, or ";
text += GPD->sNEWLINE();
text += "(at your option) any later version.";
text += GPD->sNEWLINE();
text += "This program is distributed in the hope that it will be useful, ";
text += GPD->sNEWLINE();
text += "but WITHOUT ANY WARRANTY; without even the implied warranty of ";
text += GPD->sNEWLINE();
text += "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ";
text += GPD->sNEWLINE();
text += "GNU General Public License for more details.";
text += GPD->sNEWLINE();
text += "You should have received a copy of the GNU General Public License ";
text += GPD->sNEWLINE();
text += "along with this program; if not, write to the Free Software ";
text += GPD->sNEWLINE();
text += "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA";
text += GPD->sNEWLINE();
textview->get_buffer()->set_text(text);
scrolledwindow->set_flags(Gtk::CAN_FOCUS);
scrolledwindow->set_shadow_type(Gtk::SHADOW_IN);
scrolledwindow->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
scrolledwindow->property_window_placement().set_value(Gtk::CORNER_TOP_LEFT);
scrolledwindow->add(*textview);
vbox->pack_start(*aboutLabel, Gtk::PACK_SHRINK, 0);
vbox->pack_start(*scrolledwindow);
ad->get_vbox()->set_homogeneous(false);
ad->get_vbox()->set_spacing(0);
ad->get_vbox()->pack_start(*vbox);
//ad->set_title( "About " + GPD->sGUI_CLIENT() + " " + GPD->sVERSION() );
ad->set_title( GPD->sGUI_CLIENT() + " " + GPD->sVERSION() + " / About" );
ad->set_modal(true);
ad->property_window_position().set_value(Gtk::WIN_POS_CENTER);
ad->set_resizable(true);
ad->property_destroy_with_parent().set_value(false);
ad->set_has_separator(true);
ad->add_action_widget(*okbutton, -5);
okbutton->show();
aboutLabel->show();
textview->show();
scrolledwindow->show();
vbox->show();
okbutton->signal_clicked().connect(sigc::mem_fun(*this, &aboutDialog::on_ok_clicked));
// ad->show();
}
Window() : canvas(), checkbutton1("Plot 1"),
checkbutton2("Plot 2"), checkbutton3("Plot 3"),
label_x("X:"),
label_y("Y:") {
set_default_size(720, 580);
Gdk::Geometry geometry;
geometry.min_aspect = geometry.max_aspect = double(720)/double(580);
set_geometry_hints(*this, geometry, Gdk::HINT_ASPECT);
set_title("Gtkmm-PLplot test4");
canvas.set_hexpand(true);
canvas.set_vexpand(true);
canvas.set_background_color(Gdk::RGBA("Light Gray"));
grid.set_column_homogeneous(true);
checkbutton1.set_vexpand(false);
checkbutton1.set_hexpand(false);
checkbutton1.set_halign(Gtk::ALIGN_CENTER);
checkbutton2.set_vexpand(false);
checkbutton2.set_hexpand(false);
checkbutton2.set_halign(Gtk::ALIGN_CENTER);
checkbutton3.set_vexpand(false);
checkbutton3.set_hexpand(false);
checkbutton3.set_halign(Gtk::ALIGN_CENTER);
std::valarray<double> x_va = Gtk::PLplot::indgen_va(1000)/50.0 - 10.0;
std::valarray<double> y_va1 = sinh(x_va);
std::valarray<double> y_va2 = cosh(x_va);
std::valarray<double> y_va3 = tanh(x_va);
//generate the data, the plot, add them to the canvas and use the return value to pass it to the checkbutton
Gtk::PLplot::Plot2D *plot1 = Gtk::manage(
new Gtk::PLplot::Plot2D(
*Gtk::manage(
new Gtk::PLplot::PlotData2D(
x_va,
y_va1,
Gdk::RGBA("blue"),
Gtk::PLplot::LineStyle::CONTINUOUS,
3.0
)
),
"X-axis",
"Y-axis",
"Hyperbolic sine",
0.5,
0.5,
0.0,
0.0
)
);
canvas.add_plot(*plot1);
checkbutton1.connect_plot(plot1);
Gtk::PLplot::Plot2D *plot2 = Gtk::manage(
new Gtk::PLplot::Plot2D(
*Gtk::manage(
new Gtk::PLplot::PlotData2D(
x_va,
y_va2,
Gdk::RGBA("red"),
Gtk::PLplot::LineStyle::CONTINUOUS,
3.0
)
),
"X-axis",
"Y-axis",
"Hyperbolic cosine",
0.5,
0.5,
0.5,
0.0
)
);
canvas.add_plot(*plot2);
checkbutton2.connect_plot(plot2);
Gtk::PLplot::Plot2D *plot3 = Gtk::manage(
new Gtk::PLplot::Plot2D(
*Gtk::manage(
new Gtk::PLplot::PlotData2D(
x_va,
y_va3,
Gdk::RGBA("green"),
Gtk::PLplot::LineStyle::CONTINUOUS,
3.0
)
),
"X-axis",
"Y-axis",
"Hyperbolic tangent",
0.4,
0.4,
0.2,
0.55
)
);
canvas.add_plot(*plot3);
checkbutton3.connect_plot(plot3);
checkbutton1.set_active();
checkbutton2.set_active(false);
checkbutton3.set_active();
//let's make the first plot unpannable
plot1->set_region_pannable(false);
//let's override the background color of the second plot and hide it to make the surprise complete!!
plot2->set_background_color(Gdk::RGBA("Yellow Green"));
plot2->hide();
//also let's disable the region selection, for no reason whatsoever!
plot2->set_region_selectable(false);
//let's override the default region of this plot, this is NOT influenced by set_region_selectable()!!!
plot2->set_region(-10, 10, -10, 10);
//we can also change some other colors
plot2->set_axes_color(Gdk::RGBA("Blue"));
plot2->set_titles_color(Gdk::RGBA("Purple"));
plot2->set_box_style(Gtk::PLplot::BOX_TICKS_TICK_LABELS_MAIN_AXES_MAJOR_MINOR_TICK_GRID);
//lets'give the third plot a nice opaque background color
plot3->set_background_color(Gdk::RGBA("White"));
//but disable zooming by scrolling
plot3->set_region_zoomable(false);
//and give it an unusual selection box
plot3->set_region_selection_color(Gdk::RGBA("Purple"));
plot3->set_region_selection_width(4.0);
//hook up signal_cursor_motion to the entries
unsigned int plotnr = 0;
while (1) {
try {
Gtk::PLplot::Plot2D *plot = dynamic_cast<Gtk::PLplot::Plot2D *>(canvas.get_plot(plotnr++));
plot->signal_cursor_motion().connect([this](double x, double y){
entry_x.set_text(Glib::Ascii::dtostr(x));
entry_y.set_text(Glib::Ascii::dtostr(y));
});
}
catch (Gtk::PLplot::Exception &e) {
break;
}
}
grid.attach(checkbutton1, 0, 0, 1, 1);
grid.attach(checkbutton2, 1, 0, 1, 1);
grid.attach(checkbutton3, 2, 0, 1, 1);
grid.attach(canvas, 0, 1, 3, 1);
coordinates_grid.set_column_homogeneous(false);
coordinates_grid.attach(label_x, 0, 0, 1, 1);
coordinates_grid.attach(entry_x, 1, 0, 1, 1);
coordinates_grid.attach(label_y, 2, 0, 1, 1);
coordinates_grid.attach(entry_y, 3, 0, 1, 1);
label_x.set_vexpand(false);
label_x.set_hexpand(true);
label_x.set_halign(Gtk::ALIGN_END);
label_y.set_vexpand(false);
label_y.set_hexpand(false);
label_y.set_halign(Gtk::ALIGN_CENTER);
entry_x.set_vexpand(false);
entry_x.set_hexpand(false);
entry_x.set_halign(Gtk::ALIGN_END);
entry_y.set_vexpand(false);
entry_y.set_hexpand(true);
entry_y.set_halign(Gtk::ALIGN_START);
coordinates_grid.set_column_spacing(5);
grid.attach(coordinates_grid, 0, 2, 3, 1);
grid.set_row_spacing(5);
add(grid);
set_border_width(10);
grid.show_all();
}
//dialog_previewoptions stuff
Dialog_PreviewOptions::Dialog_PreviewOptions()
:Dialog(_("Preview Options")),
adj_zoom(Gtk::Adjustment::create(0.5,0.1,5.0,0.1,0.2)),
adj_fps(Gtk::Adjustment::create(12,1,120,1,5)),
check_overbegin(_("_Begin time"),false),
check_overend(_("_End time"),false),
settings(this,"prevoptions")
{
//framerate = 15.0f;
//zoom = 0.2f;
//set the fps of the time widgets
Gtk::Alignment *dialogPadding = manage(new Gtk::Alignment(0, 0, 1, 1));
dialogPadding->set_padding(12, 12, 12, 12);
get_vbox()->add(*dialogPadding);
Gtk::VBox *dialogBox = manage(new Gtk::VBox(false, 12));
dialogPadding->add(*dialogBox);
Gtk::Frame *generalFrame = manage(new Gtk::Frame(_("General settings")));
generalFrame->set_shadow_type(Gtk::SHADOW_NONE);
((Gtk::Label *) generalFrame->get_label_widget())->set_markup(_("<b>General settings</b>"));
dialogBox->pack_start(*generalFrame, false, false, 0);
Gtk::Alignment *generalPadding = manage(new Gtk::Alignment(0, 0, 1, 1));
generalPadding->set_padding(6, 0, 24, 0);
generalFrame->add(*generalPadding);
Gtk::Table *generalTable = manage(new Gtk::Table(2, 2, false));
generalTable->set_row_spacings(6);
generalTable->set_col_spacings(12);
generalPadding->add(*generalTable);
Gtk::Label *zoomLabel = manage(new Gtk::Label(_("_Quality")));
zoomLabel->set_alignment(0, 0.5);
zoomLabel->set_use_underline(TRUE);
Gtk::SpinButton *zoomSpinner = manage(new Gtk::SpinButton(adj_zoom, 0.1, 2));
zoomLabel->set_mnemonic_widget(*zoomSpinner);
zoomSpinner->set_alignment(1);
generalTable->attach(*zoomLabel, 0, 1, 0, 1, Gtk::SHRINK | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
generalTable->attach(*zoomSpinner, 1, 2, 0, 1, Gtk::EXPAND | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
Gtk::Label *fpsLabel = manage(new Gtk::Label(_("_FPS")));
fpsLabel->set_alignment(0, 0.5);
fpsLabel->set_use_underline(TRUE);
Gtk::SpinButton *fpsSpinner = manage(new Gtk::SpinButton(adj_fps, 1, 1));
fpsLabel->set_mnemonic_widget(*fpsSpinner);
fpsSpinner->set_alignment(1);
generalTable->attach(*fpsLabel, 0, 1, 1, 2, Gtk::SHRINK | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
generalTable->attach(*fpsSpinner, 1, 2, 1, 2, Gtk::EXPAND | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
Gtk::Frame *timeFrame = manage(new Gtk::Frame(_("Time settings")));
timeFrame->set_shadow_type(Gtk::SHADOW_NONE);
((Gtk::Label *) timeFrame->get_label_widget())->set_markup(_("<b>Time settings</b>"));
dialogBox->pack_start(*timeFrame, false, false, 0);
Gtk::Alignment *timePadding = manage(new Gtk::Alignment(0, 0, 1, 1));
timePadding->set_padding(6, 0, 24, 0);
timeFrame->add(*timePadding);
Gtk::Table *timeTable = manage(new Gtk::Table(2, 2, false));
timeTable->set_row_spacings(6);
timeTable->set_col_spacings(12);
timePadding->add(*timeTable);
check_overbegin.set_alignment(0, 0.5);
check_overbegin.set_use_underline(TRUE);
check_overend.set_alignment(0, 0.5);
check_overend.set_use_underline(TRUE);
time_begin.set_alignment(1);
time_end.set_alignment(1);
timeTable->attach(check_overbegin, 0, 1, 0, 1, Gtk::SHRINK | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
timeTable->attach(time_begin, 1, 2, 0, 1, Gtk::EXPAND | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
timeTable->attach(check_overend, 0, 1, 1, 2, Gtk::SHRINK | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
timeTable->attach(time_end, 1, 2, 1, 2, Gtk::EXPAND | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
check_overbegin.signal_toggled().connect(sigc::mem_fun(*this,&Dialog_PreviewOptions::on_overbegin_toggle));
check_overend.signal_toggled().connect(sigc::mem_fun(*this,&Dialog_PreviewOptions::on_overend_toggle));
Gtk::Button *cancelButton = manage(new Gtk::Button(Gtk::StockID("gtk-cancel")));
cancelButton->signal_clicked().connect(sigc::mem_fun(*this, &Dialog_PreviewOptions::on_cancel_pressed));
add_action_widget(*cancelButton, 1);
cancelButton->show();
Gtk::Button *okbutton = manage(new Gtk::Button(Gtk::StockID("gtk-go-forward")));
okbutton->set_label(_("Preview"));
okbutton->signal_clicked().connect(sigc::mem_fun(*this,&Dialog_PreviewOptions::on_ok_pressed));
add_action_widget(*okbutton, 0);
okbutton->show();
time_begin.set_sensitive(false);
time_end.set_sensitive(false);
show_all();
}
Gtk::Widget *
Widget_RendDesc::create_image_tab()
{
Gtk::Alignment *paddedPanel = manage(new Gtk::Alignment(0, 0, 1, 1));
paddedPanel->set_padding(12, 12, 12, 12);
Gtk::Box *panelBox = manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL, 12));
panelBox->set_homogeneous(false);
paddedPanel->add(*panelBox);
Gtk::Frame *imageSizeFrame = manage(new Gtk::Frame(_("Image Size")));
imageSizeFrame->set_shadow_type(Gtk::SHADOW_NONE);
((Gtk::Label *) imageSizeFrame->get_label_widget())->set_markup(_("<b>Image Size</b>"));
// panelBox->pack_start(*imageSizeFrame, false, false, 0);
panelBox->pack_start(*imageSizeFrame, Gtk::PACK_SHRINK);
Gtk::Alignment *tableSizePadding = manage(new Gtk::Alignment(0, 0, 1, 1));
tableSizePadding->set_padding(6, 0, 24, 0);
Gtk::Grid *imageSizeGrid = manage(new Gtk::Grid());
tableSizePadding->add(*imageSizeGrid);
imageSizeFrame->add(*tableSizePadding);
Gtk::Label *size_width_label = manage(new Gtk::Label(_("_Width"), 0, 0.5, true));
size_width_label->set_mnemonic_widget(*entry_width);
Gtk::Label *size_height_label = manage(new Gtk::Label(_("_Height"), 0, 0.5, true));
size_height_label->set_mnemonic_widget(*entry_height);
Gtk::Label *size_xres_label = manage(new Gtk::Label(_("_XRes"), 0, 0.5, true));
size_xres_label->set_mnemonic_widget(*entry_xres);
Gtk::Label *size_yres_label = manage(new Gtk::Label(_("_YRes"), 0, 0.5, true));
size_yres_label->set_mnemonic_widget(*entry_yres);
Gtk::Label *size_physwidth_label = manage(new Gtk::Label(_("_Physical Width"), 0, 0.5, true));
size_physwidth_label->set_mnemonic_widget(*entry_phy_width);
Gtk::Label *size_physheight_label = manage(new Gtk::Label(_("Phy_sical Height"), 0, 0.5, true));
size_physheight_label->set_mnemonic_widget(*entry_phy_height);
imageSizeGrid->set_row_spacing(6);
imageSizeGrid->attach(*size_width_label, 0, 0, 1, 1);
imageSizeGrid->attach(*size_height_label, 0, 1, 1, 1);
entry_width->set_hexpand(true);
entry_height->set_hexpand(true);
imageSizeGrid->attach(*entry_width, 1, 0, 1, 1);
imageSizeGrid->attach(*entry_height, 1, 1, 1, 1);
toggle_wh_ratio->set_margin_right(6);
imageSizeGrid->attach(*toggle_wh_ratio, 2, 0, 1, 2);
imageSizeGrid->attach(*size_xres_label, 3, 0, 1, 1);
imageSizeGrid->attach(*size_yres_label, 3, 1, 1, 1);
entry_xres->set_hexpand(true);
entry_yres->set_hexpand(true);
imageSizeGrid->attach(*entry_xres, 4, 0, 1, 1);
imageSizeGrid->attach(*entry_yres, 4, 1, 1, 1);
toggle_res_ratio->set_margin_right(6);
imageSizeGrid->attach(*toggle_res_ratio, 5, 0, 1, 2);
imageSizeGrid->attach(*size_physwidth_label, 6, 0, 1, 1);
imageSizeGrid->attach(*size_physheight_label, 6, 1, 1, 1);
entry_phy_width->set_hexpand(true);
entry_phy_height->set_hexpand(true);
imageSizeGrid->attach(*entry_phy_width, 7, 0, 1, 1);
imageSizeGrid->attach(*entry_phy_height, 7, 1, 1, 1);
imageSizeGrid->attach(*pixel_ratio_label, 0, 3, 3, 1);
Gtk::Frame *imageAreaFrame = manage(new Gtk::Frame(_("Image Area")));
imageAreaFrame->set_shadow_type(Gtk::SHADOW_NONE);
((Gtk::Label *) imageAreaFrame->get_label_widget())->set_markup(_("<b>Image Area</b>"));
//panelBox->pack_start(*imageAreaFrame, false, false, 0);
panelBox->pack_start(*imageAreaFrame, Gtk::PACK_SHRINK);
Gtk::Alignment *imageAreaPadding = manage(new Gtk::Alignment(0, 0, 1, 1));
imageAreaPadding->set_padding(6, 0, 24, 0);
imageAreaFrame->add(*imageAreaPadding);
Gtk::Box *imageAreaBox = manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL,12));
Gtk::Box *imageAreaTlbrLabelBox = Gtk::manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL,6));
Gtk::Box *imageAreaTlbrBox = manage(new Gtk::Box(Gtk::ORIENTATION_VERTICAL,6));
Gtk::Box *imageAreaSpanBox = manage(new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL,6));
imageAreaPadding->add(*imageAreaBox);
Gtk::Label *imageAreaTopLeftLabel = manage(new Gtk::Label(_("_Top Left"), 0, 0.5, true));
imageAreaTopLeftLabel->set_mnemonic_widget(*entry_tl);
Gtk::Label *imageAreaBottomRightLabel = manage(new Gtk::Label(_("_Bottom Right"), 0, 0.5, true));
imageAreaBottomRightLabel->set_mnemonic_widget(*entry_br);
Gtk::Label *size_span = manage(new Gtk::Label(_("I_mage Span"), 0, 0.5, true));
size_span->set_mnemonic_widget(*entry_span);
imageAreaTlbrLabelBox->pack_start(*imageAreaTopLeftLabel);
imageAreaTlbrLabelBox->pack_start(*imageAreaBottomRightLabel);
imageAreaTlbrBox->pack_start(*entry_tl);
imageAreaTlbrBox->pack_start(*entry_br);
imageAreaSpanBox->pack_start(*size_span);
imageAreaSpanBox->pack_start(*entry_span);
imageAreaBox->pack_start(*imageAreaTlbrLabelBox);
imageAreaBox->pack_start(*imageAreaTlbrBox);
imageAreaBox->pack_start(*imageAreaSpanBox);
paddedPanel->show_all();
return paddedPanel;
}
void BugzillaPreferences::add_clicked()
{
Gtk::FileChooserDialog dialog(_("Select an icon..."),
Gtk::FILE_CHOOSER_ACTION_OPEN);
dialog.add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
dialog.add_button (Gtk::Stock::OPEN, Gtk::RESPONSE_OK);
dialog.set_default_response(Gtk::RESPONSE_OK);
dialog.set_local_only(true);
dialog.set_current_folder (last_opened_dir);
Glib::RefPtr<Gtk::FileFilter> filter = Gtk::FileFilter::create();
filter->add_pixbuf_formats ();
dialog.add_filter(filter);
// Extra Widget
Gtk::Label *l = manage(new Gtk::Label (_("_Host name:"), true));
Gtk::Entry *host_entry = manage(new Gtk::Entry ());
l->set_mnemonic_widget(*host_entry);
Gtk::HBox *hbox = manage(new Gtk::HBox (false, 6));
hbox->pack_start (*l, false, false, 0);
hbox->pack_start (*host_entry, true, true, 0);
hbox->show_all ();
dialog.set_extra_widget(*hbox);
int response;
std::string icon_file;
std::string host;
while(1) {
response = dialog.run ();
icon_file = dialog.get_filename();
host = sharp::string_trim(host_entry->get_text());
if (response == (int) Gtk::RESPONSE_OK) {
bool valid = sanitize_hostname(host);
if(valid && !host.empty()) {
break;
}
// Let the user know that they
// have to specify a host name.
gnote::utils::HIGMessageDialog warn(
NULL, GTK_DIALOG_DESTROY_WITH_PARENT,
Gtk::MESSAGE_WARNING, Gtk::BUTTONS_OK,
_("Host name invalid"),
_("You must specify a valid Bugzilla "
"host name to use with this icon."));
warn.run ();
host_entry->grab_focus ();
}
else if (response != (int) Gtk::RESPONSE_OK) {
return;
}
}
// Keep track of the last directory the user had open
last_opened_dir = dialog.get_current_folder();
// Copy the file to the BugzillaIcons directory
std::string err_msg;
if (!copy_to_bugzilla_icons_dir (icon_file, host, err_msg)) {
gnote::utils::HIGMessageDialog err(NULL, GTK_DIALOG_DESTROY_WITH_PARENT,
Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK,
_("Error saving icon"),
std::string(_("Could not save the icon file.")) +
" " + err_msg);
err.run();
}
update_icon_store();
}
MEShowNodesWindow::MEShowNodesWindow(MEMapArea* mapArea)
: m_selectedRow( NULL ), m_mapArea(mapArea)
{
set_title("Show nodes");
set_size_request(300, 400);
// Create the main-box where the frames are added.
Gtk::Box* mainbox = manage(new Gtk::VBox());
Gtk::Frame* frame = NULL;
//Gtk::Adjustment* adj = NULL;
Gtk::Label* label = NULL;
Gtk::Button* btn = NULL;
m_fileSelector = manage(new Gtk::FileSelection("Select turn desc. file"));
m_fileSelector->get_ok_button()->signal_clicked().connect(
sigc::mem_fun(*this, &MEShowNodesWindow::on_fileSelOK));
m_fileSelector->get_cancel_button()->signal_clicked().connect(
sigc::mem_fun(*this, &MEShowNodesWindow::on_fileSelCancel));
m_fileSelector->hide_fileop_buttons();
// Frame where to load file
frame = manage(new Gtk::Frame("File"));
Gtk::Box* box = manage(new Gtk::HBox());
m_fileNameEntry = manage(new Gtk::Entry());
box->pack_start(*m_fileNameEntry);
btn = manage(new Gtk::Button("..."));
btn->signal_clicked().connect(
sigc::mem_fun(*this, &MEShowNodesWindow::on_selectFile));
box->pack_start(*btn, false, false);
btn = manage(new Gtk::Button("Load"));
btn->signal_clicked().connect(
sigc::mem_fun(*this, &MEShowNodesWindow::on_loadFile));
box->pack_start(*btn, false, false);
frame->add(*box);
mainbox->pack_start(*frame, false, false);
// Create ListStore and add to TreeView
m_listStore = Gtk::ListStore::create(m_columns);
m_treeView.set_model(m_listStore);
m_treeView.append_column("From", m_columns.m_from);
m_treeView.append_column("To", m_columns.m_to);
m_treeView.append_column("Old turn", m_columns.m_oldTurn);
m_treeView.append_column("Old CK", m_columns.m_oldCK);
// Create selection object to handle selections
m_selection = m_treeView.get_selection();
if( m_selection )
{
m_selection->signal_changed().connect(
sigc::mem_fun(*this, &MEShowNodesWindow::on_showNode));
} else {
// If this doesn't work we're in trouble.
mc2log << error << "No selection object created for corresponding "
<< "TreeView" << endl;
MC2_ASSERT(false);
}
// Set column size- and resize properties.
Gtk::TreeViewColumn* tmpCol;
tmpCol = m_treeView.get_column( 0 );
tmpCol->set_sizing( Gtk::TREE_VIEW_COLUMN_FIXED );
tmpCol->set_fixed_width( 90 );
tmpCol->set_resizable( true );
tmpCol = m_treeView.get_column( 1 );
tmpCol->set_sizing( Gtk::TREE_VIEW_COLUMN_FIXED );
tmpCol->set_fixed_width( 90 );
tmpCol->set_resizable( true );
tmpCol = m_treeView.get_column( 2 );
tmpCol->set_sizing( Gtk::TREE_VIEW_COLUMN_FIXED );
tmpCol->set_fixed_width( 70 );
tmpCol->set_resizable( true );
tmpCol = m_treeView.get_column( 3 );
tmpCol->set_sizing( Gtk::TREE_VIEW_COLUMN_FIXED );
tmpCol->set_fixed_width( 70 );
tmpCol->set_resizable( true );
Gtk::ScrolledWindow* scrolledWin = manage(new Gtk::ScrolledWindow());
scrolledWin->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
scrolledWin->add(m_treeView);
mainbox->pack_start( *scrolledWin, true, true );
// Next and previous turn
box = manage(new Gtk::HBox());
btn = manage(new Gtk::Button("Prev"));
btn->signal_clicked().connect(
sigc::mem_fun(*this, &MEShowNodesWindow::on_clickPrev));
box->pack_start(*btn);
btn = manage(new Gtk::Button("All"));
btn->signal_clicked().connect(
sigc::mem_fun(*this, &MEShowNodesWindow::on_clickShowAll));
box->pack_start(*btn);
btn = manage(new Gtk::Button("Next"));
btn->signal_clicked().connect(
sigc::mem_fun(*this, &MEShowNodesWindow::on_clickNext));
box->pack_start(*btn);
mainbox->pack_start(*box, false, false);
// Frame with information about the selected crossing/connection
frame = manage(new Gtk::Frame("Selected crossing"));
Gtk::HBox* hbox = manage(new Gtk::HBox());
box = manage(new Gtk::VBox());
label = manage(new Gtk::Label("Current values"));
label->set_pattern( "______________");
box->pack_start(*label);
m_curTurnDesc = manage(new Gtk::Label(""));
box->pack_start(*m_curTurnDesc);
m_curCrossingKind = manage(new Gtk::Label(""));
box->pack_start(*m_curCrossingKind);
hbox->pack_start(*box);
box = manage(new Gtk::VBox());
label = manage(new Gtk::Label("Old values"));
label->set_pattern( "__________");
box->pack_start(*label);
m_oldTurnDesc = manage(new Gtk::Label(""));
box->pack_start(*m_oldTurnDesc);
m_oldCrossingKind = manage(new Gtk::Label(""));
box->pack_start(*m_oldCrossingKind);
hbox->pack_start(*box);
frame->add(*hbox);
mainbox->pack_start(*frame, false, false);
add(*mainbox);
show_all();
}
Example_ScrolledViewport::Example_ScrolledViewport()
{
Gtk::HBox* hbox;
Gtk::VBox* vbox;
set_title("ScrolledViewport Example");
Papyrus::Gtk::Viewport& viewport = m_ScrolledViewport.viewport();
m_Zoomer = Papyrus::Zoomer::create( );
viewport.add_controller( m_Zoomer );
viewport.set_size_request( 300, 200 );
// Create some shapes to add to the group
Papyrus::Group::pointer g = Papyrus::example_group( );
viewport.canvas()->add( g );
m_Zoomer->add( g );
vbox = Gtk::manage( new Gtk::VBox() );
vbox->pack_start( m_ScrolledViewport );
vbox->pack_start( *Gtk::manage( new Gtk::HSeparator() ) );
Gtk::RadioButton* rb;
Gtk::VBox* vbox2;
Gtk::Frame* frame;
Gtk::Label* label;
label = Gtk::manage( new Gtk::Label("Use the mouse wheel to zoom in and out.\n\nThe scrollbars are set to automatic in this example so you will need to zoom in before they show up.") );
label->set_use_markup();
label->set_line_wrap();
vbox->pack_start(*label, Gtk::PACK_SHRINK, 10);
vbox->pack_start( *Gtk::manage( new Gtk::HSeparator() ) );
vbox2 = Gtk::manage( new Gtk::VBox() );
frame = Gtk::manage( new Gtk::Frame("Viewport Scroll Placement") );
frame->add(*vbox2);
vbox->pack_start(*frame, Gtk::PACK_SHRINK, 10);
label = Gtk::manage( new Gtk::Label("<i>Placement refers to the corner where the viewport will be placed</i>") );
label->set_use_markup();
label->set_line_wrap();
vbox2->pack_start(*label, Gtk::PACK_SHRINK);
Gtk::RadioButtonGroup scroll_placement_group;
rb = Gtk::manage( new Gtk::RadioButton( scroll_placement_group, "Top Left" ) );
rb->signal_toggled().connect( sigc::bind(sigc::mem_fun(*this, &Example_ScrolledViewport::on_scroll_placement_changed), Gtk::CORNER_TOP_LEFT) );
vbox2->pack_start( *rb );
rb = Gtk::manage( new Gtk::RadioButton( scroll_placement_group, "Bottom Left" ) );
rb->signal_toggled().connect( sigc::bind(sigc::mem_fun(*this, &Example_ScrolledViewport::on_scroll_placement_changed), Gtk::CORNER_BOTTOM_LEFT) );
vbox2->pack_start( *rb );
rb = Gtk::manage( new Gtk::RadioButton( scroll_placement_group, "Top Right" ) );
rb->signal_toggled().connect( sigc::bind(sigc::mem_fun(*this, &Example_ScrolledViewport::on_scroll_placement_changed), Gtk::CORNER_TOP_RIGHT) );
vbox2->pack_start( *rb );
rb = Gtk::manage( new Gtk::RadioButton( scroll_placement_group, "Bottom Right" ) );
rb->signal_toggled().connect( sigc::bind(sigc::mem_fun(*this, &Example_ScrolledViewport::on_scroll_placement_changed), Gtk::CORNER_BOTTOM_RIGHT) );
vbox2->pack_start( *rb );
this->add( *vbox );
show_all();
}
Widget_Waypoint::Widget_Waypoint(etl::handle<synfig::Canvas> canvas):
Gtk::Alignment(0, 0, 1, 1),
waypoint(synfig::ValueBase(),0),
adj_tension(Gtk::Adjustment::create(0.0,-20,20,0.1,1)),
adj_continuity(Gtk::Adjustment::create(0.0,-20,20,0.1,1)),
adj_bias(Gtk::Adjustment::create(0.0,-20,20,0.1,1)),
adj_temporal_tension(Gtk::Adjustment::create(0.0,-20,20,0.1,1))
{
value_widget=manage(new Widget_ValueBase());
value_widget->set_canvas(canvas);
value_widget->show();
value_node_label=manage(new Gtk::Label(_("(Non-static value)")));
time_widget=manage(new Widget_Time());
time_widget->set_fps(canvas->rend_desc().get_frame_rate());
before_options=manage(new class Widget_Enum());
before_options->show();
before_options->set_param_desc(
ParamDesc("interpolation")
.set_hint("enum")
.add_enum_value(INTERPOLATION_CLAMPED,"clamped",_("Clamped"))
.add_enum_value(INTERPOLATION_TCB,"auto",_("TCB"))
.add_enum_value(INTERPOLATION_CONSTANT,"constant",_("Constant"))
.add_enum_value(INTERPOLATION_HALT,"ease",_("Ease In/Out"))
.add_enum_value(INTERPOLATION_LINEAR,"linear",_("Linear"))
);
before_options->set_icon(0, Gtk::Button().render_icon_pixbuf(Gtk::StockID("synfig-interpolation_type_clamped"),Gtk::ICON_SIZE_MENU));
before_options->set_icon(1, Gtk::Button().render_icon_pixbuf(Gtk::StockID("synfig-interpolation_type_tcb"),Gtk::ICON_SIZE_MENU));
before_options->set_icon(2, Gtk::Button().render_icon_pixbuf(Gtk::StockID("synfig-interpolation_type_const"),Gtk::ICON_SIZE_MENU));
before_options->set_icon(3, Gtk::Button().render_icon_pixbuf(Gtk::StockID("synfig-interpolation_type_ease"),Gtk::ICON_SIZE_MENU));
before_options->set_icon(4, Gtk::Button().render_icon_pixbuf(Gtk::StockID("synfig-interpolation_type_linear"),Gtk::ICON_SIZE_MENU));
after_options=manage(new class Widget_Enum());
after_options->show();
after_options->set_param_desc(
ParamDesc("interpolation")
.set_hint("enum")
.add_enum_value(INTERPOLATION_CLAMPED,"clamped",_("Clamped"))
.add_enum_value(INTERPOLATION_TCB,"auto",_("TCB"))
.add_enum_value(INTERPOLATION_CONSTANT,"constant",_("Constant"))
.add_enum_value(INTERPOLATION_HALT,"ease",_("Ease In/Out"))
.add_enum_value(INTERPOLATION_LINEAR,"linear",_("Linear"))
);
after_options->set_icon(0, Gtk::Button().render_icon_pixbuf(Gtk::StockID("synfig-interpolation_type_clamped"),Gtk::ICON_SIZE_MENU));
after_options->set_icon(1, Gtk::Button().render_icon_pixbuf(Gtk::StockID("synfig-interpolation_type_tcb"),Gtk::ICON_SIZE_MENU));
after_options->set_icon(2, Gtk::Button().render_icon_pixbuf(Gtk::StockID("synfig-interpolation_type_const"),Gtk::ICON_SIZE_MENU));
after_options->set_icon(3, Gtk::Button().render_icon_pixbuf(Gtk::StockID("synfig-interpolation_type_ease"),Gtk::ICON_SIZE_MENU));
after_options->set_icon(4, Gtk::Button().render_icon_pixbuf(Gtk::StockID("synfig-interpolation_type_linear"),Gtk::ICON_SIZE_MENU));
spin_tension=manage(new class Gtk::SpinButton(adj_tension,0.1,3));
spin_tension->show();
spin_continuity=manage(new class Gtk::SpinButton(adj_continuity,0.1,3));
spin_continuity->show();
spin_bias=manage(new class Gtk::SpinButton(adj_bias,0.1,3));
spin_bias->show();
spin_temporal_tension=manage(new class Gtk::SpinButton(adj_temporal_tension,0.1,3));
spin_temporal_tension->show();
set_padding(12, 12, 12, 12);
Gtk::VBox *widgetBox = manage(new Gtk::VBox(false, 12));
add(*widgetBox);
Gtk::Frame *waypointFrame = manage(new Gtk::Frame(_("Waypoint")));
waypointFrame->set_shadow_type(Gtk::SHADOW_NONE);
((Gtk::Label *) waypointFrame->get_label_widget())->set_markup(_("<b>Waypoint</b>"));
widgetBox->pack_start(*waypointFrame, false, false, 0);
Gtk::Alignment *waypointPadding = manage(new Gtk::Alignment(0, 0, 1, 1));
waypointPadding->set_padding(6, 0, 24, 0);
waypointFrame->add(*waypointPadding);
Gtk::Table *waypointTable = manage(new Gtk::Table(2, 2, false));
waypointTable->set_row_spacings(6);
waypointTable->set_col_spacings(12);
waypointPadding->add(*waypointTable);
Gtk::Label *waypointValueLabel = manage(new Gtk::Label(_("_Value"), true));
waypointValueLabel->set_alignment(0, 0.5);
waypointValueLabel->set_mnemonic_widget(*value_widget);
waypointTable->attach(*waypointValueLabel, 0, 1, 0, 1, Gtk::SHRINK | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
waypointTable->attach(*value_widget, 1, 2, 0, 1, Gtk::EXPAND | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
waypointTable->attach(*value_node_label, 1, 2, 0, 1, Gtk::EXPAND | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
Gtk::Label *waypointTimeLabel = manage(new Gtk::Label(_("_Time"), true));
waypointTimeLabel->set_alignment(0, 0.5);
waypointTimeLabel->set_mnemonic_widget(*time_widget);
waypointTable->attach(*waypointTimeLabel, 0, 1, 1, 2, Gtk::SHRINK | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
waypointTable->attach(*time_widget, 1, 2, 1, 2, Gtk::EXPAND | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
Gtk::Frame *interpolationFrame = manage(new Gtk::Frame(_("Interpolation")));
interpolationFrame->set_shadow_type(Gtk::SHADOW_NONE);
((Gtk::Label *) interpolationFrame->get_label_widget())->set_markup(_("<b>Interpolation</b>"));
widgetBox->pack_start(*interpolationFrame, false, false, 0);
Gtk::Alignment *interpolationPadding = manage(new Gtk::Alignment(0, 0, 1, 1));
interpolationPadding->set_padding(6, 0, 24, 0);
interpolationFrame->add(*interpolationPadding);
Gtk::Table *interpolationTable = manage(new Gtk::Table(2, 2, false));
interpolationTable->set_row_spacings(6);
interpolationTable->set_col_spacings(12);
interpolationPadding->add(*interpolationTable);
Gtk::Label *interpolationInLabel = manage(new Gtk::Label(_("_In Interpolation"), true));
interpolationInLabel->set_alignment(0, 0.5);
interpolationInLabel->set_mnemonic_widget(*before_options);
interpolationTable->attach(*interpolationInLabel, 0, 1, 0, 1, Gtk::SHRINK | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
interpolationTable->attach(*before_options, 1, 2, 0, 1, Gtk::EXPAND | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
Gtk::Label *interpolationOutLabel = manage(new Gtk::Label(_("_Out Interpolation"), true));
interpolationOutLabel->set_alignment(0, 0.5);
interpolationOutLabel->set_mnemonic_widget(*after_options);
interpolationTable->attach(*interpolationOutLabel, 0, 1, 1, 2, Gtk::SHRINK | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
interpolationTable->attach(*after_options, 1, 2, 1, 2, Gtk::SHRINK | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
Gtk::Frame *tcbFrame = manage(new Gtk::Frame(_("TCB Parameters")));
tcbFrame->set_shadow_type(Gtk::SHADOW_NONE);
((Gtk::Label *) tcbFrame->get_label_widget())->set_markup(_("<b>TCB Parameter</b>"));
widgetBox->pack_start(*tcbFrame, false, false, 0);
Gtk::Alignment *tcbPadding = manage(new Gtk::Alignment(0, 0, 1, 1));
tcbPadding->set_padding(6, 0, 24, 0);
tcbFrame->add(*tcbPadding);
Gtk::Table *tcbTable = manage(new Gtk::Table(4, 2, false));
tcbTable->set_row_spacings(6);
tcbTable->set_col_spacings(12);
tcbPadding->add(*tcbTable);
Gtk::Label *tensionLabel = manage(new Gtk::Label(_("T_ension"), true));
tensionLabel->set_alignment(0, 0.5);
tensionLabel->set_mnemonic_widget(*spin_tension);
spin_tension->set_alignment(1);
tcbTable->attach(*tensionLabel, 0, 1, 0, 1, Gtk::SHRINK | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
tcbTable->attach(*spin_tension, 1, 2, 0, 1, Gtk::EXPAND | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
Gtk::Label *continuityLabel = manage(new Gtk::Label(_("_Continuity"), true));
continuityLabel->set_alignment(0, 0.5);
continuityLabel->set_mnemonic_widget(*spin_continuity);
spin_continuity->set_alignment(1);
tcbTable->attach(*continuityLabel, 0, 1, 1, 2, Gtk::SHRINK | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
tcbTable->attach(*spin_continuity, 1, 2, 1, 2, Gtk::EXPAND | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
Gtk::Label *biasLabel = manage(new Gtk::Label(_("_Bias"), true));
biasLabel->set_alignment(0, 0.5);
biasLabel->set_mnemonic_widget(*spin_bias);
spin_bias->set_alignment(1);
tcbTable->attach(*biasLabel, 0, 1, 2, 3, Gtk::SHRINK | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
tcbTable->attach(*spin_bias, 1, 2, 2, 3, Gtk::EXPAND | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
Gtk::Label *temporalTensionLabel = manage(new Gtk::Label(_("Te_mporal Tension"), true));
temporalTensionLabel->set_alignment(0, 0.5);
temporalTensionLabel->set_mnemonic_widget(*spin_temporal_tension);
spin_temporal_tension->set_alignment(1);
tcbTable->attach(*temporalTensionLabel, 0, 1, 3, 4, Gtk::SHRINK | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
tcbTable->attach(*spin_temporal_tension, 1, 2, 3, 4, Gtk::EXPAND | Gtk::FILL, Gtk::EXPAND | Gtk::FILL, 0, 0);
show_all();
hide();
set_canvas(canvas);
}
void setValueText(Glib::ustring ValueText)
{
mp_Value->set_text(ValueText);
}
limitDialog::limitDialog()
: limit_interval(5),
limit_selected(false),
selected_upload_disable(false),
selected_download_disable(false),
selected_seed_percent_disable(false),
selected_seed_timer_disable(false),
uploadCombo(0),
downloadCombo(0),
seedPercentSpin(0),
seedTimeSpin(0),
selected_upload_limit(-1),
selected_download_limit(-1)
{
Gtk::Label *uploadLabel = Gtk::manage(new class Gtk::Label("Upload"));
Gtk::Label *downloadLabel = Gtk::manage(new class Gtk::Label("Download"));
uploadCombo = Gtk::manage(new class Gtk::ComboBoxText());
downloadCombo = Gtk::manage(new class Gtk::ComboBoxText());
Gtk::Label *seedPercentLabel = Gtk::manage(new class Gtk::Label("Seed %"));
Gtk::Label *seedTimeLabel = Gtk::manage(new class Gtk::Label("Seed Time"));
Gtk::Adjustment *seedPercentAdjustment = Gtk::manage(new class Gtk::Adjustment(1, 0, 100, 1, 10, 10));
seedPercentSpin = Gtk::manage(new class Gtk::SpinButton(*seedPercentAdjustment, 1, 0));
Gtk::Adjustment *seedTimeAdjustment = Gtk::manage(new class Gtk::Adjustment(1, 0, 100, 1, 10, 10));
seedTimeSpin = Gtk::manage(new class Gtk::SpinButton(*seedTimeAdjustment, 1, 0));
Gtk::Table *settingsTable = Gtk::manage(new class Gtk::Table(4, 2, false));
Gtk::VBox *limitVbox = Gtk::manage(new class Gtk::VBox(false, 10));
uploadLabel->set_alignment(0,0.5);
uploadLabel->set_padding(5,0);
uploadLabel->set_justify(Gtk::JUSTIFY_LEFT);
uploadLabel->set_line_wrap(false);
uploadLabel->set_use_markup(false);
uploadLabel->set_selectable(false);
downloadLabel->set_alignment(0,0.5);
downloadLabel->set_padding(5,0);
downloadLabel->set_justify(Gtk::JUSTIFY_LEFT);
downloadLabel->set_line_wrap(false);
downloadLabel->set_use_markup(false);
downloadLabel->set_selectable(false);
seedPercentLabel->set_alignment(0,0.5);
seedPercentLabel->set_padding(5,0);
seedPercentLabel->set_justify(Gtk::JUSTIFY_LEFT);
seedPercentLabel->set_line_wrap(false);
seedPercentLabel->set_use_markup(false);
seedPercentLabel->set_selectable(false);
seedTimeLabel->set_alignment(0,0.5);
seedTimeLabel->set_padding(5,0);
seedTimeLabel->set_justify(Gtk::JUSTIFY_LEFT);
seedTimeLabel->set_line_wrap(false);
seedTimeLabel->set_use_markup(false);
seedTimeLabel->set_selectable(false);
seedPercentSpin->set_flags(Gtk::CAN_FOCUS);
seedPercentSpin->set_update_policy(Gtk::UPDATE_ALWAYS);
seedPercentSpin->set_numeric(false);
seedPercentSpin->set_digits(0);
seedPercentSpin->set_wrap(false);
seedPercentSpin->set_range(0, MaxSeedProcent);
seedTimeSpin->set_flags(Gtk::CAN_FOCUS);
seedTimeSpin->set_update_policy(Gtk::UPDATE_ALWAYS);
seedTimeSpin->set_numeric(false);
seedTimeSpin->set_digits(0);
seedTimeSpin->set_wrap(false);
seedTimeSpin->set_range(0, MaxSeedTimeout);
uploadCombo->append_text("disable");
downloadCombo->append_text("disable");
for (t_int i=limit_interval; i<=200; i=i+limit_interval)
{
using namespace std;
using namespace btg::core;
string s = convertToString<int>(i) + " KiB/sec";
uploadCombo->append_text(s);
downloadCombo->append_text(s);
}
uploadCombo->set_active(0);
downloadCombo->set_active(0);
settingsTable->set_border_width(10);
settingsTable->set_row_spacings(20);
settingsTable->set_col_spacings(5);
/* */
settingsTable->attach(*uploadLabel, 0, 1, 0, 1, Gtk::FILL, Gtk::AttachOptions(), 0, 0);
settingsTable->attach(*downloadLabel, 0, 1, 1, 2, Gtk::FILL, Gtk::AttachOptions(), 0, 0);
settingsTable->attach(*seedPercentLabel, 0, 1, 2, 3, Gtk::FILL, Gtk::AttachOptions(), 0, 0);
settingsTable->attach(*seedTimeLabel, 0, 1, 3, 4, Gtk::FILL, Gtk::AttachOptions(), 0, 0);
settingsTable->attach(*seedPercentSpin, 1, 2, 2, 3, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0);
settingsTable->attach(*seedTimeSpin, 1, 2, 3, 4, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0);
settingsTable->attach(*uploadCombo, 1, 2, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0);
settingsTable->attach(*downloadCombo, 1, 2, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0);
limitVbox->pack_start(*settingsTable, Gtk::PACK_SHRINK, 0);
set_title( GPD->sGUI_CLIENT() + " " + GPD->sVERSION() + " / Limit" );
set_modal(true);
property_window_position().set_value(Gtk::WIN_POS_CENTER);
set_resizable(true);
property_destroy_with_parent().set_value(false);
set_has_separator(true);
get_vbox()->pack_start(*limitVbox);
set_default_size(300, 200);
uploadLabel->show();
downloadLabel->show();
seedPercentLabel->show();
seedTimeLabel->show();
uploadCombo->show();
downloadCombo ->show();
seedPercentSpin->show();
seedTimeSpin->show();
settingsTable->show();
limitVbox->show();
// Create buttons and connect their signals.
add_button("Set", 1);
add_button("Cancel", 2);
signal_response().connect(sigc::mem_fun(*this, &limitDialog::on_button_pressed));
get_vbox()->show();
show();
}
Gobby::StatusBar::MessageHandle
Gobby::StatusBar::add_message(Gobby::StatusBar::MessageType type,
const Glib::ustring& message,
const Glib::ustring& dialog_message,
unsigned int timeout)
{
if(m_visible_messages >= 12)
{
for(MessageHandle iter = m_list.begin();
iter != m_list.end();
++iter)
{
if(*iter)
{
if((*iter)->is_error())
remove_message(iter);
else
// only hide message because whoever
// installed it is expecting to be
// able to call remove_message on it
hide_message(iter);
break;
}
}
}
Gtk::Grid* grid = Gtk::manage(new Gtk::Grid());
grid->set_column_spacing(6);
grid->set_margin_start(2);
grid->set_margin_end(2);
Gtk::Image* image = Gtk::manage(new Gtk::Image);
image->set_from_icon_name(message_type_to_icon_name(type),
Gtk::ICON_SIZE_MENU);
grid->attach(*image, 0, 0, 1, 1);
image->show();
Gtk::Label* label = Gtk::manage(
new Gtk::Label(message, Gtk::ALIGN_START));
label->set_ellipsize(Pango::ELLIPSIZE_END);
// If we set halign instead, the label will not behave correctly
// when ellipsized, because then it has always all space around it
// allocated, and the alignment "jumps" around whin resizing the
// window due to new characters appearing or disappearing as a result
// of the ellipsization.
#if GTK_CHECK_VERSION(3, 16, 0)
gtk_label_set_xalign(label->gobj(), 0.0);
#else
label->set_alignment(0.0, 0.0);
#endif
label->show();
grid->attach(*label, 1, 0, 1, 1);
Gtk::Frame* frame = Gtk::manage(new Gtk::Frame);
m_list.push_back(0);
Gobby::StatusBar::MessageHandle iter(--m_list.end());
sigc::connection timeout_conn;
if(timeout)
{
timeout_conn = Glib::signal_timeout().connect_seconds(
sigc::bind(
sigc::bind_return(
sigc::mem_fun(
*this,
&StatusBar::remove_message),
false),
iter),
timeout);
}
*iter = new Message(frame, message, dialog_message, timeout_conn);
++m_visible_messages;
if(dialog_message.empty())
{
frame->add(*grid);
}
else
{
Gtk::EventBox *eventbox = Gtk::manage(new Gtk::EventBox);
frame->add(*eventbox);
eventbox->add(*grid);
eventbox->signal_button_press_event().connect(
sigc::bind_return(sigc::bind(
sigc::mem_fun(
*this,
&StatusBar::on_message_clicked),
iter), false));
eventbox->show();
}
grid->show();
// Insert at front
gtk_grid_attach_next_to(
gobj(), GTK_WIDGET(frame->gobj()),
NULL, GTK_POS_LEFT, 1, 1);
frame->set_halign(Gtk::ALIGN_START);
frame->set_hexpand(false);
frame->set_shadow_type(Gtk::SHADOW_NONE);
frame->show();
return iter;
}
/**
\brief Creates a combobox widget for an enumeration parameter
*/
Gtk::Widget *
ParamRadioButton::get_widget (SPDocument * doc, Inkscape::XML::Node * node, sigc::signal<void> * changeSignal)
{
if (_gui_hidden) return NULL;
Gtk::HBox * hbox = Gtk::manage(new Gtk::HBox(false, 4));
Gtk::VBox * vbox = Gtk::manage(new Gtk::VBox(false, 0));
Gtk::Label * label = Gtk::manage(new Gtk::Label(_(_text), Gtk::ALIGN_LEFT, Gtk::ALIGN_TOP));
label->show();
hbox->pack_start(*label, false, false);
Gtk::ComboBoxText* cbt = 0;
bool comboSet = false;
if (_mode == MINIMAL) {
cbt = Gtk::manage(new ComboWdg(this, doc, node));
cbt->show();
vbox->pack_start(*cbt, false, false);
}
// add choice strings as radiobuttons
// and select last selected option (_value)
Gtk::RadioButtonGroup group;
for (GSList * list = choices; list != NULL; list = g_slist_next(list)) {
optionentry * entr = reinterpret_cast<optionentry *>(list->data);
Glib::ustring * text = entr->guitext;
switch ( _mode ) {
case MINIMAL:
{
cbt->append_text(*text);
if (!entr->value->compare(_value)) {
cbt->set_active_text(*text);
comboSet = true;
}
}
break;
case COMPACT:
case FULL:
{
ParamRadioButtonWdg * radio = Gtk::manage(new ParamRadioButtonWdg(group, *text, this, doc, node, changeSignal));
radio->show();
vbox->pack_start(*radio, true, true);
if (!entr->value->compare(_value)) {
radio->set_active();
}
}
break;
}
}
if ( (_mode == MINIMAL) && !comboSet) {
cbt->set_active(0);
}
vbox->show();
hbox->pack_end(*vbox, false, false);
hbox->show();
return dynamic_cast<Gtk::Widget *>(hbox);
}
HIGMessageDialog::HIGMessageDialog(Gtk::Window *parent,
GtkDialogFlags flags, Gtk::MessageType msg_type,
Gtk::ButtonsType btn_type, const Glib::ustring & header,
const Glib::ustring & msg)
: Gtk::Dialog()
, m_extra_widget(NULL)
{
set_border_width(5);
set_resizable(false);
set_title("");
get_vbox()->set_spacing(12);
get_action_area()->set_layout(Gtk::BUTTONBOX_END);
m_accel_group = Glib::RefPtr<Gtk::AccelGroup>(Gtk::AccelGroup::create());
add_accel_group(m_accel_group);
Gtk::HBox *hbox = manage(new Gtk::HBox (false, 12));
hbox->set_border_width(5);
hbox->show();
get_vbox()->pack_start(*hbox, false, false, 0);
switch (msg_type) {
case Gtk::MESSAGE_ERROR:
m_image = new Gtk::Image (Gtk::Stock::DIALOG_ERROR,
Gtk::ICON_SIZE_DIALOG);
break;
case Gtk::MESSAGE_QUESTION:
m_image = new Gtk::Image (Gtk::Stock::DIALOG_QUESTION,
Gtk::ICON_SIZE_DIALOG);
break;
case Gtk::MESSAGE_INFO:
m_image = new Gtk::Image (Gtk::Stock::DIALOG_INFO,
Gtk::ICON_SIZE_DIALOG);
break;
case Gtk::MESSAGE_WARNING:
m_image = new Gtk::Image (Gtk::Stock::DIALOG_WARNING,
Gtk::ICON_SIZE_DIALOG);
break;
default:
m_image = new Gtk::Image ();
break;
}
if (m_image) {
Gtk::manage(m_image);
m_image->show();
m_image->property_yalign().set_value(0);
hbox->pack_start(*m_image, false, false, 0);
}
Gtk::VBox *label_vbox = manage(new Gtk::VBox (false, 0));
label_vbox->show();
hbox->pack_start(*label_vbox, true, true, 0);
std::string title = str(boost::format("<span weight='bold' size='larger'>%1%"
"</span>\n") % header.c_str());
Gtk::Label *label;
label = manage(new Gtk::Label (title));
label->set_use_markup(true);
label->set_justify(Gtk::JUSTIFY_LEFT);
label->set_line_wrap(true);
label->set_alignment (0.0f, 0.5f);
label->show();
label_vbox->pack_start(*label, false, false, 0);
label = manage(new Gtk::Label(msg));
label->set_use_markup(true);
label->set_justify(Gtk::JUSTIFY_LEFT);
label->set_line_wrap(true);
label->set_alignment (0.0f, 0.5f);
label->show();
label_vbox->pack_start(*label, false, false, 0);
m_extra_widget_vbox = manage(new Gtk::VBox (false, 0));
m_extra_widget_vbox->show();
label_vbox->pack_start(*m_extra_widget_vbox, true, true, 12);
switch (btn_type) {
case Gtk::BUTTONS_NONE:
break;
case Gtk::BUTTONS_OK:
add_button (Gtk::Stock::OK, Gtk::RESPONSE_OK, true);
break;
case Gtk::BUTTONS_CLOSE:
add_button (Gtk::Stock::CLOSE, Gtk::RESPONSE_CLOSE, true);
break;
case Gtk::BUTTONS_CANCEL:
add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL, true);
break;
case Gtk::BUTTONS_YES_NO:
add_button (Gtk::Stock::NO, Gtk::RESPONSE_NO, false);
add_button (Gtk::Stock::YES, Gtk::RESPONSE_YES, true);
break;
case Gtk::BUTTONS_OK_CANCEL:
add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL, false);
add_button (Gtk::Stock::OK, Gtk::RESPONSE_OK, true);
break;
}
if (parent){
set_transient_for(*parent);
}
if ((flags & GTK_DIALOG_MODAL) != 0) {
set_modal(true);
}
if ((flags & GTK_DIALOG_DESTROY_WITH_PARENT) != 0) {
property_destroy_with_parent().set_value(true);
}
}
limitDialog::limitDialog(const char * _szUploadLabel,
const char * _szDownloadLabel,
const char * _szParam3Label,
const char * _szParam4Label)
: Gtk::Dialog(btg::core::projectDefaults::sGUI_CLIENT() + " " + btg::core::projectDefaults::sFULLVERSION() + " / Limit",
true /* modal */,
true /* use_separator aka set_has_separator() */ ),
limit_selected(false),
selected_upload_disable(false),
selected_download_disable(false),
selected_param3_disable(false),
selected_param4_disable(false),
uploadCombo(0),
downloadCombo(0),
param3Spin(0),
param4Spin(0),
selected_upload_limit(-1),
selected_download_limit(-1),
limits()
{
Gtk::Label* uploadLabel = Gtk::manage(new class Gtk::Label( _szUploadLabel ? _szUploadLabel : "Upload" ));
Gtk::Label* downloadLabel = Gtk::manage(new class Gtk::Label( _szDownloadLabel ? _szDownloadLabel : "Download" ));
uploadCombo = Gtk::manage(new class Gtk::ComboBoxText());
downloadCombo = Gtk::manage(new class Gtk::ComboBoxText());
Gtk::Label* seedPercentLabel = Gtk::manage(new class Gtk::Label( _szParam3Label ? _szParam3Label : "Seed %" ));
Gtk::Label* seedTimeLabel = Gtk::manage(new class Gtk::Label( _szParam4Label ? _szParam4Label : "Seed Time" ));
Gtk::Adjustment* seedPercentAdjustment = Gtk::manage(new class Gtk::Adjustment(1, 0, 100, 1, 10, 10));
param3Spin = Gtk::manage(new class Gtk::SpinButton(*seedPercentAdjustment, 1, 0));
Gtk::Adjustment *seedTimeAdjustment = Gtk::manage(new class Gtk::Adjustment(1, 0, 100, 1, 10, 10));
param4Spin = Gtk::manage(new class Gtk::SpinButton(*seedTimeAdjustment, 1, 0));
Gtk::Table* settingsTable = Gtk::manage(new class Gtk::Table(4, 2, false));
Gtk::VBox* limitVbox = Gtk::manage(new class Gtk::VBox(false, 10));
uploadLabel->set_alignment(0,0.5);
uploadLabel->set_padding(5,0);
uploadLabel->set_justify(Gtk::JUSTIFY_LEFT);
uploadLabel->set_line_wrap(false);
uploadLabel->set_use_markup(false);
uploadLabel->set_selectable(false);
downloadLabel->set_alignment(0,0.5);
downloadLabel->set_padding(5,0);
downloadLabel->set_justify(Gtk::JUSTIFY_LEFT);
downloadLabel->set_line_wrap(false);
downloadLabel->set_use_markup(false);
downloadLabel->set_selectable(false);
seedPercentLabel->set_alignment(0,0.5);
seedPercentLabel->set_padding(5,0);
seedPercentLabel->set_justify(Gtk::JUSTIFY_LEFT);
seedPercentLabel->set_line_wrap(false);
seedPercentLabel->set_use_markup(false);
seedPercentLabel->set_selectable(false);
seedTimeLabel->set_alignment(0,0.5);
seedTimeLabel->set_padding(5,0);
seedTimeLabel->set_justify(Gtk::JUSTIFY_LEFT);
seedTimeLabel->set_line_wrap(false);
seedTimeLabel->set_use_markup(false);
seedTimeLabel->set_selectable(false);
param3Spin->set_flags(Gtk::CAN_FOCUS);
param3Spin->set_update_policy(Gtk::UPDATE_ALWAYS);
param3Spin->set_numeric(false);
param3Spin->set_digits(0);
param3Spin->set_wrap(false);
param3Spin->set_range(0, MaxParam3Value);
param4Spin->set_flags(Gtk::CAN_FOCUS);
param4Spin->set_update_policy(Gtk::UPDATE_ALWAYS);
param4Spin->set_numeric(false);
param4Spin->set_digits(0);
param4Spin->set_wrap(false);
param4Spin->set_range(0, MaxParam4Value);
uploadCombo->append_text("disable");
downloadCombo->append_text("disable");
for (t_uint i=1024; i<=maxRateInBytes; i*=2)
{
using namespace btg::core;
humanReadableRate h = humanReadableRate::convert(i);
std::string s = h.toString();
uploadCombo->append_text(s);
downloadCombo->append_text(s);
limits.push_back(i);
}
uploadCombo->set_active(0);
downloadCombo->set_active(0);
settingsTable->set_border_width(10);
settingsTable->set_row_spacings(20);
settingsTable->set_col_spacings(5);
/* */
settingsTable->attach(*uploadLabel, 0, 1, 0, 1, Gtk::FILL, Gtk::AttachOptions(), 0, 0);
settingsTable->attach(*downloadLabel, 0, 1, 1, 2, Gtk::FILL, Gtk::AttachOptions(), 0, 0);
settingsTable->attach(*seedPercentLabel, 0, 1, 2, 3, Gtk::FILL, Gtk::AttachOptions(), 0, 0);
settingsTable->attach(*seedTimeLabel, 0, 1, 3, 4, Gtk::FILL, Gtk::AttachOptions(), 0, 0);
settingsTable->attach(*param3Spin, 1, 2, 2, 3, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0);
settingsTable->attach(*param4Spin, 1, 2, 3, 4, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0);
settingsTable->attach(*uploadCombo, 1, 2, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0);
settingsTable->attach(*downloadCombo, 1, 2, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::AttachOptions(), 0, 0);
limitVbox->pack_start(*settingsTable, Gtk::PACK_SHRINK, 0);
property_window_position().set_value(Gtk::WIN_POS_CENTER);
set_resizable(true);
property_destroy_with_parent().set_value(false);
get_vbox()->pack_start(*limitVbox);
set_default_size(300, 200);
// Create buttons and connect their signals.
add_button("Set", 1);
add_button("Cancel", 2);
signal_response().connect(sigc::mem_fun(*this, &limitDialog::on_button_pressed));
show_all(); // flag all inner elements as visible
hide(); // hide toplevel window
}
//------------------------------------------------------------------------------
void mforms::gtk::ToolBarImpl::set_item_text(mforms::ToolBarItem *item, const std::string &label) {
const mforms::ToolBarItemType type = item->get_type();
switch (type) {
case mforms::TextActionItem:
case mforms::ActionItem:
case mforms::SegmentedToggleItem:
case mforms::ToggleItem:
case mforms::SwitcherItem: {
Gtk::Button *btn = cast<Gtk::Button *>(item->get_data_ptr());
if (type == mforms::SwitcherItem) {
btn->set_label(label);
btn->get_style_context()->add_class("SwitcherItem");
} else
btn->add_label(label);
btn->set_name(label);
break;
}
case mforms::TitleItem:
case mforms::LabelItem: {
Gtk::Label *lbl = cast<Gtk::Label *>(item->get_data_ptr());
if (lbl) {
lbl->set_markup("<small>" + label + "</small>");
lbl->set_name(label);
}
break;
}
case mforms::FlatSelectorItem:
case mforms::SelectorItem: {
Gtk::ComboBoxText *ct = cast<Gtk::ComboBoxText *>(item->get_data_ptr());
if (ct)
ct->set_active_text(label);
break;
}
case mforms::ColorSelectorItem: {
Gtk::ComboBox *combo = cast<Gtk::ComboBox *>(item->get_data_ptr());
if (combo) {
Glib::RefPtr<Gtk::TreeModel> model = combo->get_model();
if (model) {
const Gtk::TreeModel::Children children = model->children();
const Gtk::TreeIter last = children.end();
Gtk::TreeRow row;
for (Gtk::TreeIter it = children.begin(); it != last; ++it) {
row = *it;
if (row.get_value(color_combo_columns->color) == label) {
combo->set_active(it);
break;
}
}
}
}
break;
}
case mforms::SearchFieldItem:
case mforms::TextEntryItem: {
Gtk::Entry *e = cast<Gtk::Entry *>(item->get_data_ptr());
if (e)
e->set_text(label);
break;
}
case mforms::SeparatorItem:
case mforms::ExpanderItem:
case mforms::ImageBoxItem:
break;
}
}
Glib::ustring getValueText()
{
return mp_Value->get_text();
}
void FindAndReplaceShader::populateWindow()
{
Gtk::VBox* dialogVBox = Gtk::manage(new Gtk::VBox(false, 6));
add(*dialogVBox);
Gtk::HBox* findHBox = Gtk::manage(new Gtk::HBox(false, 0));
Gtk::HBox* replaceHBox = Gtk::manage(new Gtk::HBox(false, 0));
// Pack these hboxes into an alignment so that they are indented
Gtk::Alignment* alignment = Gtk::manage(new gtkutil::LeftAlignment(*findHBox, 18, 1.0f));
Gtk::Alignment* alignment2 = Gtk::manage(new gtkutil::LeftAlignment(*replaceHBox, 18, 1.0f));
dialogVBox->pack_start(*alignment, true, true, 0);
dialogVBox->pack_start(*alignment2, true, true, 0);
// Create the labels and pack them in the hbox
Gtk::Label* findLabel = Gtk::manage(new gtkutil::LeftAlignedLabel(_(LABEL_FIND)));
Gtk::Label* replaceLabel = Gtk::manage(new gtkutil::LeftAlignedLabel(_(LABEL_REPLACE)));
findLabel->set_size_request(60, -1);
replaceLabel->set_size_request(60, -1);
findHBox->pack_start(*findLabel, false, false, 0);
replaceHBox->pack_start(*replaceLabel, false, false, 0);
_findEntry = Gtk::manage(new Gtk::Entry);
_replaceEntry = Gtk::manage(new Gtk::Entry);
_findEntry->signal_changed().connect(sigc::mem_fun(*this, &FindAndReplaceShader::onFindChanged));
_replaceEntry->signal_changed().connect(sigc::mem_fun(*this, &FindAndReplaceShader::onReplaceChanged));
findHBox->pack_start(*_findEntry, true, true, 6);
replaceHBox->pack_start(*_replaceEntry, true, true, 6);
// Create the icon buttons to open the ShaderChooser and override the size request
_findSelectButton = Gtk::manage(
new gtkutil::IconTextButton("", GlobalUIManager().getLocalPixbuf(FOLDER_ICON))
);
_findSelectButton->set_size_request(-1, -1);
_findSelectButton->signal_clicked().connect(sigc::mem_fun(*this, &FindAndReplaceShader::onChooseFind));
_replaceSelectButton = Gtk::manage(
new gtkutil::IconTextButton("", GlobalUIManager().getLocalPixbuf(FOLDER_ICON))
);
_replaceSelectButton->set_size_request(-1, -1);
_replaceSelectButton->signal_clicked().connect(sigc::mem_fun(*this, &FindAndReplaceShader::onChooseReplace));
findHBox->pack_start(*_findSelectButton, false, false, 0);
replaceHBox->pack_start(*_replaceSelectButton, false, false, 0);
Gtk::Alignment* spacer = Gtk::manage(new Gtk::Alignment(0,0,0,0));
spacer->set_size_request(10, 2);
dialogVBox->pack_start(*spacer, false, false, 0);
// The checkbox for "search selected only"
_selectedOnly = Gtk::manage(new Gtk::CheckButton(_(LABEL_SELECTED_ONLY), true));
Gtk::Alignment* alignment3 = Gtk::manage(new gtkutil::LeftAlignment(*_selectedOnly, 18, 1.0f));
dialogVBox->pack_start(*alignment3, false, false, 0);
// Finally, add the buttons
dialogVBox->pack_start(createButtons(), false, false, 0);
}
void DocumentProperties::setupFields (Glib::ustring const &docType)
{
Gtk::VBox *metadataBox;
xml_->get_widget ("MetadataBox", metadataBox);
if (metadataBox->children().size()) {
metadataBox->children().erase(metadataBox->children().begin());
}
DocumentType type = typeManager_.getType (docType);
int const nRows = type.requiredFields_.size() + type.optionalFields_.size();
Gtk::Table *metadataTable = new Gtk::Table (nRows, 4, false);
metadataTable->set_col_spacings (6);
metadataTable->set_row_spacings (6);
fieldEntries_.clear ();
Gtk::Label *typeLabel = Gtk::manage (new Gtk::Label (_("_Type:"), Gtk::ALIGN_LEFT, Gtk::ALIGN_CENTER, true));
if (typecombochanged_)
typecombochanged_.disconnect();
typeCombo_ = Gtk::manage (new Gtk::ComboBox);
typeCombo_->set_model(typecombostore_);
typeCombo_->pack_start(typelabelcol_, true);
typeCombo_->pack_start(typebibtexnamecol_, false);
typeLabel->set_mnemonic_widget (*typeCombo_);
metadataTable->attach (*typeLabel, 0, 1, 0, 1, Gtk::FILL, Gtk::SHRINK | Gtk::FILL, 0, 0);
metadataTable->attach (*typeCombo_, 1, 4, 0, 1, Gtk::FILL, Gtk::SHRINK | Gtk::FILL, 0, 0);
typecombostore_->clear();
for (DocumentTypeManager::TypesMap::iterator it = typeManager_.getTypes().begin();
it != typeManager_.getTypes().end();
++it) {
Gtk::TreeModel::Row row = *(typecombostore_->append());
row[typelabelcol_] = (*it).second.displayName_;
row[typebibtexnamecol_] = (*it).second.bibtexName_;
}
typecombochanged_ = typeCombo_->signal_changed().connect (
sigc::mem_fun (*this, &DocumentProperties::onTypeChanged));
int row = 1;
for (
std::vector<DocumentField>::iterator it = type.requiredFields_.begin();
it != type.requiredFields_.end();
++it) {
if (it->shortField_)
continue;
Gtk::Label *label = Gtk::manage (new Gtk::Label (it->displayName_ + ":", Gtk::ALIGN_LEFT, Gtk::ALIGN_CENTER, false));
Gtk::Entry *entry = Gtk::manage (new Gtk::Entry ());
/* [bert] Minor change to actually implement and register
* a callback for changes to the DOI field. This is a bit
* ugly here since it assumes we know whether DOI is
* required or not.
*/
if (it->internalName_ == "doi") {
entry->signal_changed().connect(sigc::mem_fun(*this, &DocumentProperties::onDoiEntryChanged));
}
fieldEntries_[it->internalName_] = entry;
metadataTable->attach (*label, 0, 1, row, row + 1, Gtk::FILL | Gtk::EXPAND, Gtk::SHRINK | Gtk::FILL, 0, 0);
metadataTable->attach (*entry, 1, 4, row, row + 1, Gtk::EXPAND | Gtk::FILL, Gtk::SHRINK | Gtk::FILL, 0, 0);
++row;
}
for (
std::vector<DocumentField>::iterator it = type.optionalFields_.begin();
it != type.optionalFields_.end();
++it) {
if (it->shortField_)
continue;
Gtk::Label *label = Gtk::manage (new Gtk::Label (it->displayName_ + ":", Gtk::ALIGN_LEFT, Gtk::ALIGN_CENTER, false));
Gtk::Entry *entry = Gtk::manage (new Gtk::Entry ());
fieldEntries_[it->internalName_] = entry;
metadataTable->attach (*label, 0, 1, row, row + 1, Gtk::FILL | Gtk::EXPAND, Gtk::SHRINK | Gtk::FILL, 0, 0);
metadataTable->attach (*entry, 1, 4, row, row + 1, Gtk::EXPAND | Gtk::FILL, Gtk::SHRINK | Gtk::FILL, 0, 0);
++row;
}
int col = 0;
for (
std::vector<DocumentField>::iterator it = type.requiredFields_.begin();
it != type.requiredFields_.end();
++it) {
if (!it->shortField_)
continue;
Gtk::Label *label = Gtk::manage (new Gtk::Label (it->displayName_ + ":", Gtk::ALIGN_LEFT, Gtk::ALIGN_CENTER, false));
Gtk::Entry *entry = Gtk::manage (new Gtk::Entry ());
fieldEntries_[it->internalName_] = entry;
metadataTable->attach (*label, 0 + col * 2, 1 + col * 2, row, row + 1, Gtk::FILL | Gtk::EXPAND, Gtk::SHRINK | Gtk::FILL, 0, 0);
metadataTable->attach (*entry, 1 + col * 2, 2 + col * 2, row, row + 1, Gtk::EXPAND | Gtk::FILL, Gtk::SHRINK | Gtk::FILL, 0, 0);
++col;
if (col > 1) {
++row;
col = 0;
}
}
for (
std::vector<DocumentField>::iterator it = type.optionalFields_.begin();
it != type.optionalFields_.end();
++it) {
if (!it->shortField_)
continue;
Gtk::Label *label = Gtk::manage (new Gtk::Label (it->displayName_ + ":", Gtk::ALIGN_LEFT, Gtk::ALIGN_CENTER, false));
Gtk::Entry *entry = Gtk::manage (new Gtk::Entry ());
fieldEntries_[it->internalName_] = entry;
metadataTable->attach (*label, 0 + col * 2, 1 + col * 2, row, row + 1, Gtk::FILL | Gtk::EXPAND, Gtk::SHRINK | Gtk::FILL, 0, 0);
metadataTable->attach (*entry, 1 + col * 2, 2 + col * 2, row, row + 1, Gtk::EXPAND | Gtk::FILL, Gtk::SHRINK | Gtk::FILL, 0, 0);
++col;
if (col > 1) {
++row;
col = 0;
}
}
metadataBox->pack_start (*metadataTable);
metadataBox->show_all ();
}
PluginDisplay::PluginDisplay(gx_engine::GxMachineBase& machine_, Glib::RefPtr<Gdk::Pixbuf> icon, sigc::slot<void, bool, bool> finished_callback_)
: machine(machine_), pluginlist(), current_plugin(0), old_state(0), bld(), change_count(0),
actiongroup(Gtk::ActionGroup::create("ladspa_window")), uimanager(),
enum_liststore(new EnumListStore), port_liststore(new PortListStore),
plugin_liststore(new PluginListStore), masteridx_liststore(new MasterIdxListStore),
on_reordered_conn(), display_type_list(), display_type_list_sr(), output_type_list(),
finished_callback(finished_callback_)
{
std::vector<std::string> old_not_found;
machine.load_ladspalist(old_not_found, pluginlist);
bld = gx_gui::GxBuilder::create_from_file(machine.get_options().get_builder_filepath("ladspaliste.glade"));
bld->get_toplevel("window1", window);
bld->find_widget("treeview1", treeview1);
bld->find_widget("treeview2", treeview2);
bld->find_widget("treeview3", treeview3);
bld->find_widget("ladspa_category", ladspa_category);
bld->find_widget("ladspa_maker", ladspa_maker);
bld->find_widget("ladspa_uniqueid", ladspa_uniqueid);
bld->find_widget("search_entry", search_entry);
bld->find_widget("combobox_mono_stereo", combobox_mono_stereo);
bld->find_widget("selected_only", selected_only);
bld->find_widget("changed_only", changed_only);
bld->find_widget("ladspa_only", ladspa_only);
bld->find_widget("lv2_only", lv2_only);
bld->find_widget("show_all", show_all);
bld->find_widget("details_box", details_box);
bld->find_widget("plugin_name", plugin_name);
bld->find_widget("plugin_category", plugin_category);
bld->find_widget("plugin_quirks", plugin_quirks);
bld->find_widget("master_slider_idx", master_slider_idx);
bld->find_widget("master_slider_name", master_slider_name);
bld->find_widget("cellrenderer_master", cellrenderer_master);
bld->find_widget("cellrenderer_newrow", cellrenderer_newrow);
bld->find_widget("cellrenderer_caption", cellrenderer_caption);
bld->find_widget("cellrenderer_active", cellrenderer_active);
bld->find_widget("cellrenderer_category", cellrenderer_category);
bld->find_widget("cellrenderer_quirks", cellrenderer_quirks);
set_title();
actiongroup->add(Gtk::Action::create("FileMenuAction",_("_File")));
save_action = Gtk::Action::create("SaveAction", _("_Ok"));
actiongroup->add(save_action, sigc::mem_fun(this, &PluginDisplay::on_save));
apply_action = Gtk::Action::create("ApplyAction", _("_Apply"));
actiongroup->add(apply_action, sigc::mem_fun(this, &PluginDisplay::on_apply));
quit_action = Gtk::Action::create("QuitAction", _("_Quit"));
actiongroup->add(quit_action, sigc::mem_fun(this, &PluginDisplay::on_quit));
select_all_action = Gtk::Action::create("SelectAllAction", _("_Select All"));
actiongroup->add(select_all_action, sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_select_all), true));
select_none_action = Gtk::Action::create("SelectNoneAction", _("Select _None"));
actiongroup->add(select_none_action, sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_select_all), false));
actiongroup->add(Gtk::Action::create("ViewMenuAction", _("_View")));
Glib::RefPtr<Gtk::Action> act = Gtk::Action::create("FindAction", _("_Find"));
actiongroup->add(act, sigc::mem_fun(this, &PluginDisplay::on_find));
uimanager = Gtk::UIManager::create();
uimanager->insert_action_group(actiongroup, 0);
uimanager->add_ui_from_string(menudef);
//uimanager->get_widget("/ladspalist");
//Gtk::HBox *ww; bld->find_widget("menubox", ww); ww->pack_start(*uimanager->get_widget("/ladspalist"));
window->add_accel_group(uimanager->get_accel_group());
window->signal_delete_event().connect(sigc::mem_fun(this, &PluginDisplay::on_delete_event));
bld->find_widget("show_details", show_details);
show_details->signal_clicked().connect(sigc::mem_fun(this, &PluginDisplay::on_show_details));
treeview3->get_selection()->set_mode(Gtk::SELECTION_BROWSE);
treeview3->set_model(enum_liststore);
Gtk::CellRendererText *r;
bld->find_widget("cellrenderer_label", r);
r->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_label_edited));
Gtk::TreeViewColumn *c;
bld->find_widget("treeviewcolumn_label", c);
c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_label));
bld->find_widget("dry_wet_button", dry_wet_button);
dry_wet_button->signal_clicked().connect(sigc::mem_fun(this, &PluginDisplay::on_add_dry_wet_controller));
// dry_wet_button->set_active(current_plugin->add_wet_dry);
Glib::RefPtr<Gtk::TreeSelection> sel = treeview2->get_selection();
sel->set_mode(Gtk::SELECTION_BROWSE);
sel->signal_changed().connect(sigc::mem_fun(this, &PluginDisplay::on_parameter_selection_changed));
on_reordered_conn = port_liststore->signal_row_deleted().connect(sigc::mem_fun(this, &PluginDisplay::on_reordered));
treeview2->set_model(port_liststore);
CellRendererComboDerived *rd;
bld->find_widget_derived("cellrenderer_type", rd, sigc::ptr_fun(CellRendererComboDerived::create_from_builder));
rd->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_type_edited));
bld->find_widget("treeviewcolumn_type", c);
c->set_cell_data_func(*rd, sigc::mem_fun(this, &PluginDisplay::display_type));
bld->find_widget_derived("cellrenderer_step", rd, sigc::ptr_fun(CellRendererComboDerived::create_from_builder));
rd->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_step_edited));
bld->find_widget("treeviewcolumn_step", c);
c->set_cell_data_func(*rd, sigc::mem_fun(this, &PluginDisplay::display_step));
cellrenderer_newrow->signal_toggled().connect(sigc::mem_fun(this, &PluginDisplay::on_newrow_toggled));
Gtk::Label *label = new Gtk::Label("N");
label->set_tooltip_text(_("start a new row of controls in the rackbox unit"));
label->show();
bld->find_widget("treeviewcolumn_newrow", c);
c->set_widget(*manage(label));
c->set_cell_data_func(*cellrenderer_newrow, sigc::mem_fun(this, &PluginDisplay::display_newrow));
cellrenderer_caption->signal_toggled().connect(sigc::mem_fun(this, &PluginDisplay::on_caption_toggled));
label = new Gtk::Label("C");
label->set_tooltip_text(_("display the name as caption above the control"));
label->show();
bld->find_widget("treeviewcolumn_caption", c);
c->set_widget(*manage(label));
c->set_cell_data_func(*cellrenderer_caption, sigc::mem_fun(this, &PluginDisplay::display_caption));
bld->find_widget("cellrenderer_name", r);
r->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_name_edited));
bld->find_widget("treeviewcolumn_name", c);
c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_name));
bld->find_widget("cellrenderer_dflt", r);
r->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_dflt_edited));
bld->find_widget("treeviewcolumn_dflt", c);
c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_default));
bld->find_widget("cellrenderer_low", r);
r->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_low_edited));
bld->find_widget("treeviewcolumn_low", c);
c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_lower));
bld->find_widget("cellrenderer_up", r);
r->signal_edited().connect(sigc::mem_fun(this, &PluginDisplay::on_up_edited));
bld->find_widget("treeviewcolumn_up", c);
c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_upper));
bld->find_widget("cellrenderer_idx", r);
bld->find_widget("treeviewcolumn_idx", c);
c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_idx));
bld->find_widget("treeviewcolumn_SR", c);
label = new Gtk::Label("SR");
label->set_tooltip_text(_("marked rows: range depends on samplerate; using 44100 as fixed value"));
label->show();
c->set_widget(*manage(label));
Gtk::CellRendererToggle *t;
bld->find_widget("cellrenderer_SR", t);
c->set_cell_data_func(*t, sigc::mem_fun(this, &PluginDisplay::display_SR));
Gtk::TreeModelColumnRecord recdef;
Gtk::TreeModelColumn<Glib::ustring> strcol;
Gtk::TreeModelColumn<DisplayType> intcol;
recdef.add(strcol);
recdef.add(intcol);
display_type_list = Gtk::ListStore::create(recdef);
append_displaytype(display_type_list, tp_scale);
append_displaytype(display_type_list, tp_scale_log);
append_displaytype(display_type_list, tp_toggle);
append_displaytype(display_type_list, tp_int);
append_displaytype(display_type_list, tp_enum);
append_displaytype(display_type_list, tp_none);
display_type_list_sr = Gtk::ListStore::create(recdef);
append_displaytype(display_type_list_sr, tp_scale);
append_displaytype(display_type_list_sr, tp_scale_log);
append_displaytype(display_type_list_sr, tp_none);
output_type_list = Gtk::ListStore::create(recdef);
append_displaytype(output_type_list, tp_display);
append_displaytype(output_type_list, tp_display_toggle);
append_displaytype(output_type_list, tp_none);
treeview1->signal_row_activated().connect(sigc::mem_fun(this, &PluginDisplay::on_row_activated));
treeview1->set_search_equal_func(sigc::mem_fun(this,&PluginDisplay::search_equal));
Gtk::Entry *e;
bld->find_widget("search_entry", e);
e->signal_activate().connect(sigc::mem_fun(this, &PluginDisplay::on_search_entry_activate));
treeview1->set_search_entry(*e);
sel = treeview1->get_selection();
sel->set_mode(Gtk::SELECTION_BROWSE);
sel->signal_changed().connect(sigc::mem_fun(this, &PluginDisplay::selection_changed));
treeview1->set_model(plugin_liststore);
cellrenderer_active->signal_toggled().connect(sigc::mem_fun(this, &PluginDisplay::on_active_toggled));
bld->find_widget("cellrenderer_ladspa", r);
bld->find_widget("treeviewcolumn_ladspa", c);
c->set_cell_data_func(*r, sigc::mem_fun(this, &PluginDisplay::display_ladspa));
Gtk::ComboBox *cb;
bld->find_widget("plugin_category", cb);
cb->set_cell_data_func(*cellrenderer_category, sigc::mem_fun(this, &PluginDisplay::display_category));
bld->find_widget("plugin_quirks", cb);
cb->set_cell_data_func(*cellrenderer_quirks, sigc::mem_fun(this, &PluginDisplay::display_quirks));
master_slider_idx->set_cell_data_func(*cellrenderer_master, sigc::mem_fun(this, &PluginDisplay::display_master_idx));
master_slider_idx->signal_changed().connect(sigc::mem_fun(this, &PluginDisplay::set_master_text));
selected_only->signal_toggled().connect(sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_view_changed), selected_only));
changed_only->signal_toggled().connect(sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_view_changed), changed_only));
ladspa_only->signal_toggled().connect(sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_view_changed), ladspa_only));
lv2_only->signal_toggled().connect(sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_view_changed), lv2_only));
show_all->signal_toggled().connect(sigc::bind(sigc::mem_fun(this, &PluginDisplay::on_view_changed), show_all));
bld->find_widget("combobox_mono_stereo", cb);
cb->signal_changed().connect(sigc::mem_fun(this, &PluginDisplay::on_mono_stereo_changed));
cb->set_active(0);
Gtk::Button *b;
bld->find_widget("reset_changes", b);
b->signal_clicked().connect(sigc::mem_fun(this, &PluginDisplay::on_delete_changes));
bld->find_widget("master_slider_idx", cb);
cb->set_model(masteridx_liststore);
bld->find_widget("button_cancel", b);
gtk_activatable_set_related_action(GTK_ACTIVATABLE(b->gobj()), actiongroup->get_action("QuitAction")->gobj());
bld->find_widget("button_apply", b);
gtk_activatable_set_related_action(GTK_ACTIVATABLE(b->gobj()), actiongroup->get_action("ApplyAction")->gobj());
bld->find_widget("button_save", b);
gtk_activatable_set_related_action(GTK_ACTIVATABLE(b->gobj()), actiongroup->get_action("SaveAction")->gobj());
bld->find_widget("select_all", b);
gtk_activatable_set_related_action(GTK_ACTIVATABLE(b->gobj()), actiongroup->get_action("SelectAllAction")->gobj());
bld->find_widget("select_none", b);
gtk_activatable_set_related_action(GTK_ACTIVATABLE(b->gobj()), actiongroup->get_action("SelectNoneAction")->gobj());
window->set_icon(icon);
window->show();
}
sessionSelectionDialog::sessionSelectionDialog(std::string const& _title,
t_longList const& _sessionIDs,
t_strList const& _sessionsNames,
bool const _disableSelection)
: disableSelection_(_disableSelection),
selected(false),
session(Command::INVALID_SESSION),
cbt(0)
{
Gtk::Button* cancelbutton = Gtk::manage(new class Gtk::Button(Gtk::StockID("gtk-cancel")));
Gtk::Button* okbutton = Gtk::manage(new class Gtk::Button(Gtk::StockID("gtk-ok")));
Gtk::Label* label = Gtk::manage(new class Gtk::Label(_title));
cbt = Gtk::manage(new class Gtk::ComboBoxText());
Gtk::VBox* vbox = Gtk::manage(new class Gtk::VBox(false, 0));
cancelbutton->set_flags(Gtk::CAN_FOCUS);
cancelbutton->set_relief(Gtk::RELIEF_NORMAL);
okbutton->set_flags(Gtk::CAN_FOCUS);
okbutton->set_relief(Gtk::RELIEF_NORMAL);
get_action_area()->property_layout_style().set_value(Gtk::BUTTONBOX_END);
label->set_alignment(0.5,0.5);
label->set_padding(0,0);
label->set_justify(Gtk::JUSTIFY_LEFT);
label->set_line_wrap(false);
label->set_use_markup(false);
label->set_selectable(false);
vbox->pack_start(*label, Gtk::PACK_SHRINK, 0);
vbox->pack_start(*cbt);
get_vbox()->set_homogeneous(false);
get_vbox()->set_spacing(0);
get_vbox()->pack_start(*vbox);
set_title(_title);
set_modal(true);
property_window_position().set_value(Gtk::WIN_POS_NONE);
set_resizable(true);
property_destroy_with_parent().set_value(false);
set_has_separator(true);
add_action_widget(*cancelbutton, -6);
add_action_widget(*okbutton, -5);
/// Fill the combobox with session ids.
t_strListCI sessionNameIter = _sessionsNames.begin();
for (t_longListCI sessionIter = _sessionIDs.begin();
sessionIter != _sessionIDs.end();
sessionIter++)
{
std::string session_descr = convertToString<t_long>(*sessionIter);
session_descr += " (";
session_descr += *sessionNameIter;
session_descr += ")";
cbt->append_text(session_descr);
sessionNameIter++;
}
// Select the first session id.
cbt->set_active(0);
if (!disableSelection_)
{
cancelbutton->show();
}
okbutton->show();
label->show();
cbt->show();
vbox->show();
show();
// Connect buttons to handlers.
okbutton->signal_clicked().connect(sigc::mem_fun(*this, &sessionSelectionDialog::on_ok_clicked));
if (!disableSelection_)
{
cancelbutton->signal_clicked().connect(sigc::mem_fun(*this, &sessionSelectionDialog::on_cancel_clicked));
}
}
void profile_selection::set_accounts(const std::vector<std::string>& accounts) {
utils::debug::scope_log log(DBG_LVL_1("gtox"), {});
m_accounts = accounts;
Glib::ustring tox_name;
Glib::ustring tox_status;
toxmm::contactAddrPublic tox_addr;
for (auto acc : accounts) {
int tox_error = 0;
bool can_write = false;
//TRY TO LOAD TOX DATA
try {
toxmm::core::try_load(acc, tox_name, tox_status, tox_addr, can_write);
if (tox_name.empty()) {
tox_name = tox_addr;
}
} catch (toxmm::exception exception) {
if (exception.type() == typeid(TOX_ERR_NEW)) {
switch (exception.what_id()) {
case TOX_ERR_NEW_LOAD_BAD_FORMAT:
tox_error = 1;
break;
case TOX_ERR_NEW_LOAD_ENCRYPTED:
tox_error = 2;
break;
default:
tox_error = 3;
break;
}
} else {
tox_error = 3;
}
} catch (std::exception exp) {
std::cerr << "Couldn't load profile \"" + acc + "\"" << std::endl;
std::cerr << exp.what() << std::endl;
tox_error = 3;
} catch (...) {
std::cerr << "Couldn't load profile \"" + acc + "\"" << std::endl;
std::cerr << "Unexpected error" << std::endl;
tox_error = 3;
}
utils::debug::scope_log log(DBG_LVL_2("gtox"), {});
utils::builder builder = Gtk::Builder::create_from_resource("/org/gtox/ui/list_item_profile.ui");
Gtk::ListBoxRow* row = nullptr;
builder->get_widget("pofile_list_item", row);
if (row) {
Gtk::Label* name = nullptr;
Gtk::Label* status = nullptr;
Gtk::Label* path = nullptr;
builder.get_widget("name", name);
builder.get_widget("status", status);
builder.get_widget("path", path);
builder.get_widget_derived<widget::avatar>("avatar", tox_addr);
path->set_text(acc);
row->set_sensitive(false);
switch (tox_error) {
case 0:
name->set_text(tox_name);
status->set_text(tox_status);
if (can_write) {
row->set_sensitive(true);
}
break;
case 1:
name->set_text(_("Corrupted profile"));
status->set_text(_("Profile couldn't be loaded"));
break;
case 2:
name->set_text(_("Encrypted profile"));
status->set_text(_("Profile couldn't be loaded"));
break;
default:
name->set_text(_("Profile not loaded for an unknown reason"));
status->set_text(_("Profile couldn't be loaded"));
break;
}
//reveale profil
Gtk::Revealer* revealer;
builder.get_widget("revealer", revealer);
revealer->set_reveal_child(true);
row->show();
m_profile_list->add(*row);
}
}
m_revealer->set_reveal_child(false);
}
void setLabelText(std::string TextLabel)
{
m_Label->set_markup(Glib::ustring::compose("<b>%1</b>", TextLabel));
}
// Creates buttons with labels. Sets butBox elements to have the same size,
// with 10 pixels between widgets
View::View(Controller *c, Model *m) : model_(m), controller_(c), hand_(true,10), table_(true,10), gameBox_(false,10) {
nullCardPixbuf_ = deck_.getNullCardImage();
// Sets some properties of the window.
set_title( "Straights UI" );
//Gtk::JUSTIFY_CENTER
set_default_size( 750, 500 );
add ( gameBox_ );
Gtk::HBox* menu = Gtk::manage( new Gtk::HBox() );
// Make the start button
startButton_.signal_clicked().connect( sigc::mem_fun( *this, &View::on_start_game_clicked_) );
startButton_.add_label("Start New Game");
endButton_.signal_clicked().connect( sigc::mem_fun( *this, &View::on_end_game_clicked_) );
endButton_.add_label("End Current Game");
menu->pack_start( startButton_);
menu->pack_start( endButton_);
gameBox_.pack_start( *menu, Gtk::PACK_SHRINK );
Gtk::VBox* cardArea = Gtk::manage( new Gtk::VBox() );
Gtk::Label *cardLabel = new Gtk::Label( "Cards on the table:" );
cardLabel->set_alignment( Gtk::ALIGN_LEFT, Gtk::ALIGN_TOP );
cardArea->pack_start( *cardLabel);
gameBox_.pack_start( *cardArea, Gtk::PACK_SHRINK );
cardLabel->show();
for (int j = 0; j < 4; j++) {
for (int i = 0; i < 13; i++ ) {
cards_[j][i] = new Gtk::Image( nullCardPixbuf_ );
suit_[j].pack_start( *cards_[j][i] );
}
table_.pack_start( suit_[j], Gtk::PACK_SHRINK, true, 0 );
}
gameBox_.pack_start( table_, Gtk::PACK_SHRINK, true, 0 );
/*
for (int i = 0; i < 4; i++ ) {
pScore_.push_back(0);
pDiscards_.push_back(0);
}
*/
for ( int i = 0; i < 4; i++ ) {
Gtk::VBox* playerArea = Gtk::manage( new Gtk::VBox(true, 0 ) );
playerRagequit_[i].set_label( "Rage!" );
playerRagequit_[i].signal_clicked().connect( sigc::bind(sigc::mem_fun( *this, &View::on_rage_clicked_ ), i) );
stringstream temp_i; temp_i << (i+1);
Gtk::Label *playerLabel = new Gtk::Label( "Player " + temp_i.str() );
playerRagequit_[i].set_sensitive(false);
playerLabel->set_alignment( Gtk::ALIGN_LEFT, Gtk::ALIGN_TOP );
//stringstream temp_score; temp_score << pScore_[i];
pScore_.push_back(0);
playerScore_[i] = new Gtk::Label( "0 points" );
//stringstream temp_disc; temp_disc << pDiscards_[i];
pDiscards_.push_back(0);
playerDiscards_[i] = new Gtk::Label( " 0 discards" );
playerArea->pack_start( *playerLabel );
playerArea->pack_start( playerRagequit_[i] );
playerArea->pack_start( *playerScore_[i] );
playerArea->pack_start( *playerDiscards_[i] );
playerFrame_[i].add( *playerArea );
player_.pack_start( playerFrame_[i]);
}
gameBox_.pack_start( player_, Gtk::PACK_SHRINK, true, 0 );
Gtk::VBox* handArea = Gtk::manage( new Gtk::VBox() );
Gtk::Label *handLabel = new Gtk::Label( "Your Hand:" );
handLabel->set_alignment( Gtk::ALIGN_LEFT, Gtk::ALIGN_TOP );
handArea->pack_start( *handLabel);
gameBox_.pack_start( *handArea, Gtk::PACK_SHRINK );
handLabel->show();
//Display empty 13 cards
for (int i = 0; i < 13; i++) {
Gtk::Image *image = Gtk::manage( new Gtk::Image ( nullCardPixbuf_ ) );
currentHand_[i].set_image( *image );
currentHand_[i].set_sensitive(false);
currentHand_[i].signal_clicked().connect( sigc::bind(sigc::mem_fun( *this, &View::on_card_clicked_ ), i) );
hand_.pack_start( currentHand_[i], Gtk::PACK_SHRINK, true, 0 );
}
gameBox_.pack_start( hand_, Gtk::PACK_SHRINK);
Gtk::VBox* playerLegalCardsArea = Gtk::manage( new Gtk::VBox() );
playerLegalCards_ = new Gtk::Label( "" );
playerLegalCards_->set_padding ( 10, 10 );
playerLegalCardsArea->pack_start( *playerLegalCards_ );
gameBox_.pack_start( *playerLegalCardsArea );
Gtk::VBox* playerTurnArea = Gtk::manage( new Gtk::VBox() );
playerTurn_ = new Gtk::Label( "" );
// playerTurn_->override_color(Gdk::RGBA("red"));
playerTurn_->set_padding ( 15, 15 );
playerTurnArea->pack_start( *playerTurn_ );
gameBox_.pack_start( *playerTurnArea );
// Register view as observer of model
model_->subscribe(this);
// The final step is to display the buttons (they display themselves)
show_all();
}
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();
}
BugzillaPreferences::BugzillaPreferences()
: Gtk::VBox(false, 12)
{
_init_static();
last_opened_dir = Glib::get_home_dir();
Gtk::Label *l = manage(new Gtk::Label (_("You can use any bugzilla just by dragging links "
"into notes. If you want a special icon for "
"certain hosts, add them here.")));
l->property_wrap() = true;
l->property_xalign() = 0;
pack_start(*l, false, false, 0);
icon_store = Gtk::ListStore::create(m_columns);
icon_store->set_sort_column(m_columns.host, Gtk::SORT_ASCENDING);
icon_tree = manage(new Gtk::TreeView (icon_store));
icon_tree->set_headers_visible(true);
icon_tree->get_selection()->set_mode(Gtk::SELECTION_SINGLE);
icon_tree->get_selection()->signal_changed().connect(
sigc::mem_fun(*this, &BugzillaPreferences::selection_changed));
Gtk::TreeViewColumn *host_col = manage(new Gtk::TreeViewColumn(_("Host Name"), m_columns.host));
host_col->set_sizing(Gtk::TREE_VIEW_COLUMN_AUTOSIZE);
host_col->set_resizable(true);
host_col->set_expand(true);
host_col->set_min_width(200);
host_col->set_sort_column(m_columns.host);
host_col->set_sort_indicator(false);
host_col->set_reorderable(false);
host_col->set_sort_order(Gtk::SORT_ASCENDING);
icon_tree->append_column (*host_col);
Gtk::TreeViewColumn *icon_col = manage(new Gtk::TreeViewColumn(_("Icon"), m_columns.icon));
icon_col->set_sizing(Gtk::TREE_VIEW_COLUMN_FIXED);
icon_col->set_max_width(50);
icon_col->set_min_width(50);
icon_col->set_resizable(false);
icon_tree->append_column (*icon_col);
Gtk::ScrolledWindow *sw = manage(new Gtk::ScrolledWindow ());
sw->set_shadow_type(Gtk::SHADOW_IN);
sw->property_height_request() = 200;
sw->property_width_request() = 300;
sw->set_policy (Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
sw->add (*icon_tree);
pack_start(*sw, true, true, 0);
add_button = manage(new Gtk::Button (Gtk::Stock::ADD));
add_button->signal_clicked().connect(
sigc::mem_fun(*this, &BugzillaPreferences::add_clicked));
remove_button = manage(new Gtk::Button (Gtk::Stock::REMOVE));
remove_button->set_sensitive(false);
remove_button->signal_clicked().connect(
sigc::mem_fun(*this, &BugzillaPreferences::remove_clicked));
Gtk::HButtonBox *hbutton_box = manage(new Gtk::HButtonBox ());
hbutton_box->set_layout(Gtk::BUTTONBOX_START);
hbutton_box->set_spacing(6);
hbutton_box->pack_start(*add_button);
hbutton_box->pack_start(*remove_button);
pack_start(*hbutton_box, false, false, 0);
show_all ();
}
void
RLight::initGTK()
{
_optList.reset(new Gtk::VBox);
{ //Intensity
Gtk::HBox* box = manage(new Gtk::HBox);
box->show();
{
Gtk::Label* label = manage(new Gtk::Label("Intensity and Color", 0.95, 0.5));
box->pack_start(*label, true, true);
label->show();
}
_intensityEntry.reset(new Gtk::Entry);
box->pack_start(*_intensityEntry, false, false);
_intensityEntry->show(); _intensityEntry->set_width_chars(7);
_intensityEntry->set_text(boost::lexical_cast<std::string>(_intensity));
_intensityEntry->signal_changed()
.connect(sigc::bind<Gtk::Entry&>(&magnet::gtk::forceNumericEntry, *_intensityEntry));
_intensityEntry->signal_activate().connect(sigc::mem_fun(*this, &RLight::guiUpdate));
{
_lightColor.reset(new Gtk::ColorButton);
_lightColor->set_use_alpha(false);
Gdk::Color color;
color.set_rgb(_color[0] * G_MAXUSHORT, _color[1] * G_MAXUSHORT, _color[2] * G_MAXUSHORT);
_lightColor->set_color(color);
box->pack_start(*_lightColor, false, false);
_lightColor->show();
_lightColor->signal_color_set().connect(sigc::mem_fun(*this, &RLight::guiUpdate));
}
{
Gtk::Label* label = manage(new Gtk::Label("Attenuation", 0.95, 0.5));
box->pack_start(*label, true, true);
label->show();
}
_attenuationEntry.reset(new Gtk::Entry);
box->pack_start(*_attenuationEntry, false, false);
_attenuationEntry->show(); _attenuationEntry->set_width_chars(7);
_attenuationEntry->set_text(boost::lexical_cast<std::string>(_attenuation));
_attenuationEntry->signal_changed()
.connect(sigc::bind<Gtk::Entry&>(&magnet::gtk::forceNumericEntry, *_attenuationEntry));
_attenuationEntry->signal_activate().connect(sigc::mem_fun(*this, &RLight::guiUpdate));
_optList->pack_start(*box, false, false);
}
{ //Specular
Gtk::HBox* box = manage(new Gtk::HBox);
box->show();
{
Gtk::Label* label = manage(new Gtk::Label("Specular Exponent", 0.95, 0.5));
box->pack_start(*label, true, true);
label->show();
}
_specularExponentEntry.reset(new Gtk::Entry);
box->pack_start(*_specularExponentEntry, false, false);
_specularExponentEntry->show(); _specularExponentEntry->set_width_chars(7);
_specularExponentEntry->set_text(boost::lexical_cast<std::string>(_specularExponent));
_specularExponentEntry->signal_changed()
.connect(sigc::bind<Gtk::Entry&>(&magnet::gtk::forceNumericEntry, *_specularExponentEntry));
_specularExponentEntry->signal_activate().connect(sigc::mem_fun(*this, &RLight::guiUpdate));
{
Gtk::Label* label = manage(new Gtk::Label("Specular Strength", 0.95, 0.5));
box->pack_start(*label, true, true);
label->show();
}
_specularFactorEntry.reset(new Gtk::Entry);
box->pack_start(*_specularFactorEntry, false, false);
_specularFactorEntry->show(); _specularFactorEntry->set_width_chars(7);
_specularFactorEntry->set_text(boost::lexical_cast<std::string>(_specularFactor));
_specularFactorEntry->signal_changed()
.connect(sigc::bind<Gtk::Entry&>(&magnet::gtk::forceNumericEntry, *_specularFactorEntry));
_specularFactorEntry->signal_activate().connect(sigc::mem_fun(*this, &RLight::guiUpdate));
_optList->pack_start(*box, false, false);
}
{ //Specular
Gtk::HBox* box = manage(new Gtk::HBox);
box->show();
{
Gtk::Label* label = manage(new Gtk::Label("Position", 0.95, 0.5));
box->pack_start(*label, true, true);
label->show();
}
_positionXEntry.reset(new Gtk::Entry);
box->pack_start(*_positionXEntry, false, false);
_positionXEntry->show();
_positionXEntry->set_width_chars(7);
_positionXEntry->set_text(boost::lexical_cast<std::string>(getEyeLocationObjSpace()[0]));
_positionXEntry->signal_changed().connect(sigc::bind<Gtk::Entry&>(&magnet::gtk::forceNumericEntry, *_specularFactorEntry));
_positionXEntry->signal_activate().connect(sigc::mem_fun(*this, &RLight::guiUpdate));
_positionYEntry.reset(new Gtk::Entry);
box->pack_start(*_positionYEntry, false, false);
_positionYEntry->show();
_positionYEntry->set_width_chars(7);
_positionYEntry->set_text(boost::lexical_cast<std::string>(getEyeLocationObjSpace()[1]));
_positionYEntry->signal_changed().connect(sigc::bind<Gtk::Entry&>(&magnet::gtk::forceNumericEntry, *_specularFactorEntry));
_positionYEntry->signal_activate().connect(sigc::mem_fun(*this, &RLight::guiUpdate));
_positionZEntry.reset(new Gtk::Entry);
box->pack_start(*_positionZEntry, false, false);
_positionZEntry->show();
_positionZEntry->set_width_chars(7);
_positionZEntry->set_text(boost::lexical_cast<std::string>(getEyeLocationObjSpace()[2]));
_positionZEntry->signal_changed().connect(sigc::bind<Gtk::Entry&>(&magnet::gtk::forceNumericEntry, *_specularFactorEntry));
_positionZEntry->signal_activate().connect(sigc::mem_fun(*this, &RLight::guiUpdate));
_optList->pack_start(*box, false, false);
}
_optList->show();
guiUpdate();
}
CanvasProperties::CanvasProperties(Gtk::Window& parent,etl::handle<synfigapp::CanvasInterface> canvas_interface):
Gtk::Dialog(_("Canvas Properties"),parent),
canvas_interface_(canvas_interface)
{
widget_rend_desc.show();
widget_rend_desc.signal_changed().connect(sigc::mem_fun(*this,&studio::CanvasProperties::on_rend_desc_changed));
Gtk::Alignment *dialogPadding = manage(new Gtk::Alignment(0, 0, 1, 1));
dialogPadding->set_padding(12, 12, 12, 12);
get_vbox()->pack_start(*dialogPadding, false, false, 0);
Gtk::VBox *dialogBox = manage(new Gtk::VBox(false, 12));
dialogPadding->add(*dialogBox);
Gtk::Frame *info_frame=manage(new Gtk::Frame(_("Canvas Info")));
info_frame->set_shadow_type(Gtk::SHADOW_NONE);
((Gtk::Label *) info_frame->get_label_widget())->set_markup(_("<b>Canvas Info</b>"));
dialogBox->pack_start(*info_frame, false, false, 0);
Gtk::Alignment *infoPadding = manage(new Gtk::Alignment(0, 0, 1, 1));
infoPadding->set_padding(6, 0, 24, 0);
info_frame->add(*infoPadding);
Gtk::Table *info_table=manage(new Gtk::Table(2,2,false));
info_table->set_row_spacings(6);
info_table->set_col_spacings(12);
infoPadding->add(*info_table);
// The root canvas doesn't have an ID, so don't
// display it if this is a root canvas.
if(!canvas_interface_->get_canvas()->is_root())
{
Gtk::Label *idLabel = manage(new Gtk::Label(_("_ID"), true));
idLabel->set_alignment(0, 0.5);
idLabel->set_mnemonic_widget(entry_id);
info_table->attach(*idLabel, 0, 1, 0, 1, Gtk::SHRINK|Gtk::FILL, Gtk::SHRINK|Gtk::FILL, 0, 0);
info_table->attach(entry_id, 1, 2, 0, 1, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK|Gtk::FILL, 0, 0);
}
Gtk::Label *nameLabel = manage(new Gtk::Label(_("_Name"), true));
nameLabel->set_alignment(0, 0.5);
nameLabel->set_mnemonic_widget(entry_name);
Gtk::Label *descriptionLabel = manage(new Gtk::Label(_("_Description"), true));
descriptionLabel->set_alignment(0, 0.5);
descriptionLabel->set_mnemonic_widget(entry_description);
info_table->attach(*nameLabel, 0, 1, 1, 2, Gtk::SHRINK|Gtk::FILL, Gtk::SHRINK|Gtk::FILL, 0, 0);
info_table->attach(*descriptionLabel, 0, 1, 2, 3, Gtk::SHRINK|Gtk::FILL, Gtk::SHRINK|Gtk::FILL, 0, 0);
info_table->attach(entry_name, 1, 2, 1, 2, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK|Gtk::FILL, 0, 0);
info_table->attach(entry_description, 1, 2, 2, 3, Gtk::EXPAND|Gtk::FILL, Gtk::SHRINK|Gtk::FILL, 0, 0);
dialogBox->pack_start(widget_rend_desc, false, false, 0);
canvas_interface_->signal_rend_desc_changed().connect(sigc::mem_fun(*this,&studio::CanvasProperties::refresh));
canvas_interface_->signal_id_changed().connect(sigc::mem_fun(*this,&studio::CanvasProperties::refresh));
Gtk::Button *ok_button(manage(new class Gtk::Button(Gtk::StockID("gtk-ok"))));
ok_button->show();
add_action_widget(*ok_button,2);
ok_button->signal_clicked().connect(sigc::mem_fun(*this, &studio::CanvasProperties::on_ok_pressed));
Gtk::Button *apply_button(manage(new class Gtk::Button(Gtk::StockID("gtk-apply"))));
apply_button->show();
add_action_widget(*apply_button,1);
apply_button->signal_clicked().connect(sigc::mem_fun(*this, &studio::CanvasProperties::on_apply_pressed));
Gtk::Button *cancel_button(manage(new class Gtk::Button(Gtk::StockID("gtk-close"))));
cancel_button->show();
add_action_widget(*cancel_button,0);
cancel_button->signal_clicked().connect(sigc::mem_fun(*this, &studio::CanvasProperties::on_cancel_pressed));
//set_default_response(1);
get_vbox()->show_all();
refresh();
update_title();
}
//------------------------------------------------------------------------------
void DbMySQLTableEditorFKPage::update_fk_details()
{
::bec::FKConstraintListBE *fk_be = _be->get_fks();
fk_be->refresh();
::bec::FKConstraintColumnsListBE *fk_columns_be = fk_be->get_columns();
fk_columns_be->refresh();
std::string text;
if (_fk_node.is_valid())
fk_be->get_field(_fk_node, ::bec::FKConstraintListBE::OnUpdate, text);
set_selected_combo_item(_fk_update_combo, text);
if (_fk_node.is_valid())
fk_be->get_field(_fk_node, ::bec::FKConstraintListBE::OnDelete, text);
set_selected_combo_item(_fk_delete_combo, text);
if (_fk_node.is_valid())
fk_be->get_field(_fk_node, ::bec::FKConstraintListBE::Comment, text);
Gtk::TextView *fk_comment(0);
_xml->get_widget("fk_comment", fk_comment);
fk_comment->get_buffer()->set_text(text);
Gtk::Label *label;
_xml->get_widget("fk_index_name", label);
if (_fk_node.is_valid())
fk_be->get_field(_fk_node, ::bec::FKConstraintListBE::Index, text);
else
text = "";
label->set_text(text);
ssize_t model_only= 0;
if (_fk_node.is_valid())
fk_be->get_field(_fk_node, ::bec::FKConstraintListBE::ModelOnly, model_only);
_fk_model_only->set_active(model_only!=0);
// Update columns
_fk_columns_tv->unset_model();
if ( fk_columns_be->count() >= 1 && _fk_node.is_valid() && _fk_node.back() < _be->get_fks()->real_count())
{
_fk_columns_tv->remove_all_columns();
_fk_columns_model = ListModelWrapper::create(fk_columns_be, _fk_columns_tv, "FKColumnsModel");
_fk_columns_model->model().append_check_column(bec::FKConstraintColumnsListBE::Enabled, "", EDITABLE);
_fk_columns_model->model().append_string_column(bec::FKConstraintColumnsListBE::Column, "Column", RO, NO_ICON);
const std::vector<std::string> list;
_fk_columns_model->model().append_combo_column(::bec::FKConstraintColumnsListBE::RefColumn
,"Referenced Column"
,model_from_string_list(list)
,EDITABLE
,true);
_fk_columns_tv->set_model(_fk_columns_model);
// Connect signal so we can fill referenced columns combobox cell with correct values
_fkcol_cell_edit_conn.disconnect();
Gtk::CellRendererCombo* rend = static_cast<Gtk::CellRendererCombo*>(_fk_columns_tv->get_column_cell_renderer(2));
if ( rend )
{
_fkcol_cell_edit_conn = rend->signal_editing_started().
connect(sigc::mem_fun(this, &DbMySQLTableEditorFKPage::fkcol_cell_editing_started)
);
}
else
g_message("REND is 0!");
_fk_update_combo->set_sensitive(true);
_fk_delete_combo->set_sensitive(true);
fk_comment->set_sensitive(true);
_fk_model_only->set_sensitive(true);
}
else
{
_fk_update_combo->set_sensitive(false);
_fk_delete_combo->set_sensitive(false);
fk_comment->set_sensitive(false);
_fk_model_only->set_sensitive(false);
}
}
MESignPostInfoDialog::MESignPostInfoDialog(
OldConnection* conn, uint32 toNodeID, MEMapArea* mapArea)
{
m_connection = conn;
m_toNodeID = toNodeID;
m_mapArea = mapArea;
m_editSpDialog = NULL;
char tmpStr[256];
sprintf( tmpStr, "%s, 0x%x",
"Sign post info", m_mapArea->getMap()->getMapID() );
set_title(tmpStr);
// list with all sign posts for this connection
Gtk::Frame* frame = manage(new Gtk::Frame("Signposts:"));
// Create ListStore and add to TreeView
m_listStore = Gtk::ListStore::create(m_columns);
m_treeView.set_model(m_listStore);
// Add visible columns to TreeView
m_treeView.append_column("REMOVE ME", m_columns.m_info);
m_treeView.set_headers_visible(false);
// Create selection object to handle selections
m_selection = m_treeView.get_selection();
if(!m_selection)
{
// If this doesn't work we're in trouble.
mc2log << error << "No selection object created for corresponding "
<< "TreeView" << endl;
MC2_ASSERT(false);
}
Gtk::ScrolledWindow* scrolledWin = manage(new Gtk::ScrolledWindow());
scrolledWin->set_size_request(200, 150);
scrolledWin->set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
scrolledWin->add(m_treeView);
frame->add(*scrolledWin);
get_vbox()->pack_start(*frame, true, true, 5);
// buttons for Edit and Close in the action area
Gtk::HBox* actionBox = manage(new Gtk::HBox());
if (m_mapArea != NULL) {
Gtk::Button* editButton = manage(new Gtk::Button("Edit"));
editButton->set_size_request(75, 25);
editButton->signal_clicked().connect(
sigc::mem_fun(*this, &MESignPostInfoDialog::editSpPressed));
actionBox->pack_start(*editButton);
} else {
// empty label..
Gtk::Label* editLabel = manage(new Gtk::Label(""));
editLabel->set_size_request(75, 25);
actionBox->pack_start(*editLabel);
}
Gtk::Button* closeButton = manage(new Gtk::Button("Close"));
closeButton->signal_clicked().connect(
sigc::mem_fun(*this, &MESignPostInfoDialog::closePressed));
closeButton->set_size_request(75, 25);
actionBox->pack_start(*closeButton);
get_action_area()->pack_start(*actionBox);
// Don't show the dialog now, wait for show()-command.
}
void update_temp (double value)
{
gchar *tmp = g_strdup_printf ("%3g", value);
m_temp->set_text(tmp);
}
