View *View::create(Model *model)
{
std::vector<std::string> dirs = Platform::getConfigPaths();
Glib::ustring ui;
for (std::vector<std::string>::const_iterator i = dirs.begin();
i != dirs.end(); ++i) {
std::string f_name = Glib::build_filename (*i, "repsnapper.ui");
Glib::RefPtr<Gio::File> file = Gio::File::create_for_path(f_name);
try {
char *ptr;
gsize length;
file->load_contents(ptr, length);
ui = Glib::ustring(ptr);
g_free(ptr);
break;
} catch(Gio::Error e) {
switch(e.code()) {
case Gio::Error::NOT_FOUND:
continue;
default:
Gtk::MessageDialog dialog (_("Error reading UI description!!"), false,
Gtk::MESSAGE_ERROR, Gtk::BUTTONS_CLOSE);
dialog.set_secondary_text(e.what());
dialog.run();
return NULL;
}
}
}
if(ui.empty()) {
Gtk::MessageDialog dialog (_("Couldn't find UI description!"), false,
Gtk::MESSAGE_ERROR, Gtk::BUTTONS_CLOSE);
dialog.set_secondary_text (_("Check that repsnapper has been correctly installed."));
dialog.run();
return NULL;
}
Glib::RefPtr<Gtk::Builder> builder;
try {
builder = Gtk::Builder::create_from_string(ui);
}
catch(const Gtk::BuilderError& ex)
{
Gtk::MessageDialog dialog (_("Error loading UI!"), false,
Gtk::MESSAGE_ERROR, Gtk::BUTTONS_CLOSE);
dialog.set_secondary_text(ex.what());
dialog.run();
throw ex;
}
View *view = 0;
builder->get_widget_derived("main_window", view);
view->setModel (model);
return view;
}
Glib::ustring Document::keyReplaceDialog (
Glib::ustring const &original,
Glib::ustring const &replacement,
const char *message_text)
{
Glib::ustring message = String::ucompose (
"<big><b>%1</b></big>\n\n%2",
_("Key naming conflict"),
String::ucompose (
message_text,
original, replacement));
Gtk::MessageDialog dialog (message, true, Gtk::MESSAGE_QUESTION, Gtk::BUTTONS_NONE, true);
Gtk::Button *button;
button = dialog.add_button (_("_Ignore"), Gtk::RESPONSE_CANCEL);
Gtk::Image *noImage = Gtk::manage (new Gtk::Image (Gtk::Stock::NO, Gtk::ICON_SIZE_BUTTON));
button->set_image (*noImage);
button = dialog.add_button (_("_Replace"), Gtk::RESPONSE_ACCEPT);
Gtk::Image *yesImage = Gtk::manage (new Gtk::Image (Gtk::Stock::YES, Gtk::ICON_SIZE_BUTTON));
button->set_image (*yesImage);
dialog.set_default_response (Gtk::RESPONSE_ACCEPT);
if (dialog.run () == Gtk::RESPONSE_ACCEPT)
return replacement;
else
return original;
}
void PredicateDialog::onAddPredicate() {
SimpleTypeBox box( ("New predicate name?"), "");
std::string name = boost::trim_copy(box.run());
if (box.valid() and checkName(name)) {
setSensitivePredicate(false);
Gtk::TreeIter iter = m_model->append();
if (iter) {
savePreviousPredicate(mPredicateNameEntry->get_text());
mPredicateNameEntry->set_text(name);
Gtk::ListStore::Row row = *iter;
row[m_viewscolumnrecord.name] = name;
mTextViewFunction->get_buffer()->set_text("");
mHeaderPred->set_text( "bool " + name
+ "() const {" );
m_iter = iter;
mTreePredicateList->set_cursor(m_model->get_path(iter));
mPredicateName.push_back(name);
setSensitivePredicate(true);
}
}
else {
Gtk::MessageDialog errorDial ("Name error !",
false,
Gtk::MESSAGE_ERROR,
Gtk::BUTTONS_OK,
true);
errorDial.set_title("Error !");
errorDial.run();
}
}
void MainSynthWindow::onDspEntryActivate (void)
{
gthPatchManager *patchMgr = gthPatchManager::instance();
string dspfile = dspEntry_.get_text();
int pagenum = notebook_.get_current_page();
/* noop caused by a spurious Enter */
if (dspfile == "")
return;
if (patchMgr->newPatch(dspfile, pagenum) == false)
{
char *error = g_strdup_printf("Couldn't load DSP %s; syntax error, or does not exist",
dspfile.c_str());
Gtk::MessageDialog errorDialog (error, false, Gtk::MESSAGE_ERROR);
errorDialog.run();
free(error);
return;
}
notebook_.hide_all();
notebook_.pages().clear();
populate();
notebook_.show_all();
notebook_.set_current_page(pagenum);
}
// Function executed after the map has been solved
void MapWindow::on_notification_from_worker_thread()
{
if (m_WorkerThread && worker.has_stopped())
{
// Show a window dialog if there is no solution
if( !worker.get_solution_exists() )
{
DialogWindow.notification();
Gtk::MessageDialog *dlg = new Gtk::MessageDialog("No solution exists.");
dlg->run();
delete dlg;
}
// Work is done.
m_WorkerThread->join();
m_WorkerThread = NULL;
// Update buttons
m_Button_Solve.set_sensitive(false);
m_Button_File.set_sensitive(true);
// Force the on_draw function
m_draw.queue_draw();
// Hide the spinner window
DialogWindow.notification();
}
}
void PredicateDialog::onRenamePredicate() {
Glib::RefPtr < Gtk::TreeView::Selection > ref = mTreePredicateList->
get_selection();
if (ref) {
Gtk::TreeModel::iterator iter = ref->get_selected();
if (iter) {
Gtk::TreeModel::Row row = *iter;
std::string oldName(row.get_value(m_viewscolumnrecord.name));
savePreviousPredicate(oldName);
SimpleTypeBox box(("Predicate new name?"), "");
std::string name = boost::trim_copy(box.run());
if (box.valid() and checkName(name)) {
setSensitivePredicate(false);
m_model->erase(iter);
Gtk::TreeModel::Children children = m_model->children();
m_iter = children.begin();
iter = m_model->append();
mPredicateNameEntry->set_text(name);
Gtk::ListStore::Row row = *iter;
row[m_viewscolumnrecord.name] = name;
if (mPredicateFunction.find(oldName) !=
mPredicateFunction.end()) {
mTextViewFunction->get_buffer()->
set_text(mPredicateFunction[oldName]);
mPredicateFunction[name] = mPredicateFunction[oldName];
mPredicateFunction.erase(oldName);
}
mPredicateName.push_back(name);
// Delete the element in the vector
for (std::vector < std::string > ::iterator it =
mPredicateName.begin(); it != mPredicateName.end(); ) {
if ( *it == oldName ) {
it = mPredicateName.erase(it);
}
else {
++it;
}
}
mTreePredicateList->set_cursor(m_model->get_path(iter));
setSensitivePredicate(true);
}
else {
Gtk::MessageDialog errorDial ("Name error !",
false,
Gtk::MESSAGE_ERROR,
Gtk::BUTTONS_OK,
true);
errorDial.set_title("Error !");
errorDial.run();
}
}
}
}
void ShowMessage(const Glib::ustring& s, Gtk::Window* parent)
{
Gtk::MessageDialog* msg = new Gtk::MessageDialog(s);
if(parent)
msg->set_transient_for(*parent);
msg->run();
delete msg;
}
void View::alert (Gtk::MessageType t, const char *message,
const char *secondary)
{
Gtk::MessageDialog dialog (*this, message, false /* markup */,
t, Gtk::BUTTONS_CLOSE, true);
if (secondary)
dialog.set_secondary_text (secondary);
dialog.run();
}
void LoginWindow::new_user_clicked()
{
if (login.get_text() != "" && pass.get_text() != "" && uc->addUser(login.get_text(), pass.get_text()))
{
Gtk::MessageDialog *info = new Gtk::MessageDialog("Konto utworzono");
info->set_modal(true);
info->run();
delete info;
}
}
void MainSynthWindow::onPatchLoadError (const char* failure)
{
char *error = g_strdup_printf("Couldn't load patchfile %s; syntax error, or DSP does not exist",
failure);
Gtk::MessageDialog errorDialog (error, false, Gtk::MESSAGE_ERROR);
errorDialog.run();
free(error);
}
void Model::SendNow(string str)
{
if (rr_dev_fd (m_device) > 0)
rr_dev_enqueue_cmd (m_device, RR_PRIO_HIGH, str.data(), str.size());
else {
Gtk::MessageDialog dialog ("Can't send command", false,
Gtk::MESSAGE_INFO, Gtk::BUTTONS_CLOSE);
dialog.set_secondary_text ("You must first connect to a device!");
dialog.run ();
}
}
void show()
{
openfluid::core::UnitsCollection* TestUnitsColl = 0;
if (!mp_SimulationBlob)
{
mp_Dialog->set_message("I am DummyModalWindow\n"
"Nb of units in TestUnits class: no CoreRepository\n"
"Nothing to do");
}
else
{
unsigned int Size = 0;
TestUnitsColl = mp_SimulationBlob->getCoreRepository().getUnits(
"TestUnits");
if (TestUnitsColl)
Size = TestUnitsColl->getList()->size();
mp_Dialog->set_message(Glib::ustring::compose("I am DummyModalWindow\n"
"Nb of units in TestUnits class: %1\n"
"Clicking ok will add a Unit of class \"TestUnits\"", Size));
}
if (mp_Dialog->run() == Gtk::RESPONSE_OK && mp_SimulationBlob)
{
unsigned int NextId = 1;
if (TestUnitsColl)
{
openfluid::core::UnitsList_t* TestUnits = TestUnitsColl->getList();
if (!TestUnits->empty())
{
NextId = TestUnits->end().operator --()->getID() + 1;
while (TestUnitsColl->getUnit(NextId))
NextId++;
}
}
openfluid::core::Unit U("TestUnits", NextId, 1,
openfluid::core::InstantiationInfo::DESCRIPTOR);
mp_SimulationBlob->getCoreRepository().addUnit(U);
signal_ChangedOccurs().emit();
}
mp_Dialog->hide();
}
void DocumentProperties::onNewExtraField ()
{
Gtk::Dialog dialog ("New Field", *dialog_, true, false);
Gtk::VBox *vbox = dialog.get_vbox ();
Gtk::HBox hbox;
hbox.set_spacing (12);
vbox->pack_start (hbox, true, true, 0);
Gtk::Label label ("Field name:", false);
hbox.pack_start (label, false, false, 0);
Gtk::Entry entry;
entry.set_activates_default (true);
hbox.pack_start (entry, true, true, 0);
dialog.add_button (Gtk::Stock::CANCEL, Gtk::RESPONSE_CANCEL);
dialog.add_button (Gtk::Stock::OK, Gtk::RESPONSE_ACCEPT);
dialog.set_default_response (Gtk::RESPONSE_ACCEPT);
dialog.show_all ();
vbox->set_border_width (12);
if (dialog.run () == Gtk::RESPONSE_ACCEPT) {
Gtk::ListStore::iterator it = extrafieldsstore_->children().begin ();
Gtk::ListStore::iterator const end = extrafieldsstore_->children().end ();
bool key_isnew = true;
for (; it != end; ++it)
if (Utility::firstCap ((*it)[extrakeycol_]) == Utility::firstCap (entry.get_text ())) {
key_isnew = false;
}
if ( key_isnew ) {
Gtk::ListStore::iterator row = extrafieldsstore_->append ();
(*row)[extrakeycol_] = Utility::firstCap (entry.get_text ());
(*row)[extravalcol_] = "";
} else {
Glib::ustring message;
message = String::ucompose (
"<b><big>%1</big></b>",
_("This key already exists.\n"));
Gtk::MessageDialog dialog (
message, true,
Gtk::MESSAGE_ERROR, Gtk::BUTTONS_CLOSE, true);
dialog.run ();
}
}
}
void LoginWindow::ok_clicked()
{
if (login_ok = uc->checkUser(login.get_text(), pass.get_text()))
{
hide();
}
else
{
Gtk::MessageDialog *info = new Gtk::MessageDialog("Błędny login lub hasło.");
info->set_modal(true);
info->run();
delete info;
}
}
void PhotoPreview::SetSilhouette() {
try {
Image=Gdk::Pixbuf::create_from_file(Cfg->GetSilhouetteImage());
} catch(...) {
Gtk::MessageDialog *message = new Gtk::MessageDialog(_("Error reading data file: ")+Cfg->GetSilhouetteImage()+"\n",
false,Gtk::MESSAGE_WARNING,Gtk::BUTTONS_OK,true);
message->run();
delete message;
return;
}
Redraw();
IsSilhouette=true;
}
void
catch_and_return_to_GUI_thread (void)
{
try
{
throw;
}
catch (const std::exception& e)
{
Gtk::MessageDialog dialog (e.what (), false, Gtk::MESSAGE_ERROR);
dialog.set_keep_above ();
dialog.run ();
}
}
void MainSynthWindow::onBrowseButton (void)
{
gthPatchManager *patchMgr = gthPatchManager::instance();
int pagenum = notebook_.get_current_page();
Gtk::FileSelection fileSel("thinksynth - Load DSP");
if (prevDir_ != "")
fileSel.set_filename(prevDir_);
if (fileSel.run() == Gtk::RESPONSE_OK)
{
dspEntry_.set_text(fileSel.get_filename());
if (patchMgr->newPatch(fileSel.get_filename(), pagenum))
{
string dn = thUtil::dirname((char*)fileSel.get_filename().c_str());
prevDir_ = dn + "/";
string **vals = new string *[2];
vals[0] = new string(prevDir_);
vals[1] = NULL;
gthPrefs *prefs = gthPrefs::instance();
prefs->Set("dspdir", vals);
/* load up the patch file */
notebook_.hide_all();
notebook_.pages().clear();
populate();
notebook_.show_all();
notebook_.set_current_page(pagenum);
}
else
{
char *error = g_strdup_printf("Couldn't load DSP %s; syntax error, or does not exist",
fileSel.get_filename().c_str());
Gtk::MessageDialog errorDialog (error, false, Gtk::MESSAGE_ERROR);
errorDialog.run();
free(error);
}
}
}
void mixer_window::open_quit_dialog()
{
Gtk::MessageDialog dialog (*this, gettext("Really quit?"), false, Gtk::MESSAGE_QUESTION, Gtk::BUTTONS_NONE);
dialog.add_button(gettext("No, continue running dvswitch."), Gtk::RESPONSE_CANCEL);
dialog.add_button(gettext("Yes, exit dvswitch."), Gtk::RESPONSE_YES);
dialog.set_default_response(Gtk::RESPONSE_CANCEL);
dialog.set_position (Gtk::WIN_POS_CENTER_ON_PARENT);
switch (dialog.run())
{
case Gtk::RESPONSE_ACCEPT:
case Gtk::RESPONSE_YES:
Gtk::Main::quit();
break;
default:
break;
}
}
void DocumentProperties::onPasteBibtex ()
{
GdkAtom const selection = GDK_SELECTION_CLIPBOARD;
Glib::RefPtr<Gtk::Clipboard> clipboard = Gtk::Clipboard::get (selection);
Glib::ustring clipboardtext = clipboard->wait_for_text ();
DocumentList doclist;
int const imported = doclist.import (clipboardtext, BibUtils::FORMAT_BIBTEX);
DEBUG ("DocumentProperties::onPasteBibtex: Imported %1 references", imported);
if (imported) {
DocumentList::Container &docs = doclist.getDocs ();
DocumentList::Container::iterator it = docs.begin ();
/*
* This will lose the key from the bibtex since it's
* in Document not BibData
*/
Document doc;
save(doc);
doc.getBibData().mergeIn (it->getBibData());
update (doc);
} else {
Glib::ustring message;
if (imported < 1) {
message = String::ucompose (
"<b><big>%1</big></b>",
_("No references found on clipboard.\n"));
} else {
message = String::ucompose (
"<b><big>%1</big></b>",
_("Multiple references found on clipboard.\n"));
}
Gtk::MessageDialog dialog (
message, true,
Gtk::MESSAGE_ERROR, Gtk::BUTTONS_CLOSE, true);
dialog.run ();
}
}
void AckFunctionDialog::onAddAck() {
SimpleTypeBox box( ("New acknowledge function name?"), "");
std::string name = boost::trim_copy(box.run());
if (box.valid()) {
if (checkName(name)) {
setSensitiveAck(false);
Gtk::TreeIter iter = m_model->append();
if (iter) {
savePreviousAck(mAckNameEntry->get_text());
mAckNameEntry->set_text(name);
Gtk::ListStore::Row row = *iter;
row[m_viewscolumnrecord.name] = name;
mHeaderAck->set_text("void " + name + "(const std::string&"\
"activityname,\n\t"\
"const ved::Activity& activity) {");
std::string generatedFunc = "";
mTextViewFunction->get_buffer()->set_text(generatedFunc);
m_iter = iter;
mTreeAckList->set_cursor(m_model->get_path(iter));
mAckName.push_back(name);
setSensitiveAck(true);
}
}
else {
Gtk::MessageDialog errorDial ("Name error !",
false,
Gtk::MESSAGE_ERROR,
Gtk::BUTTONS_OK,
true);
errorDial.set_title("Error !");
errorDial.run();
}
}
}
static void connectDialog (int error)
{
string msg;
switch (error)
{
case gthJackAudio::ERR_NO_PLAYBACK:
msg = "Could not find a playback target for JACK\n"
"(alsa_pcm or oss.)";
break;
case gthJackAudio::ERR_HANDLE_NULL:
msg = "Can't connect to the JACK server because it no\n"
"longer seems to be running.";
break;
default:
msg = "Could not (dis)connect JACK, errno = " + error;
break;
}
Gtk::MessageDialog errorDialog (msg.c_str(), false, Gtk::MESSAGE_ERROR);
errorDialog.run();
}
void show()
{
mp_Dialog->run();
mp_Dialog->hide();
}
void
file_chooser::on_response (int response_id)
{
if (Gtk::RESPONSE_ACCEPT != response_id) return;
if (get_current_extension ().empty ())
set_current_extension (default_extension_);
std::string fmt;
{ // check whether extension is known
std::string ext (get_current_extension ());
bool found = false;
Gtk::TreeModel::Children children (file_type_.get_model ()->children ());
for (Gtk::TreeModel::Children::const_iterator it = children.begin ();
!found && children.end () != it;
++it)
{
Gtk::TreeModel::Row r = *it;
extension_list l = r[column->exts];
found = count (l.begin (), l.end (), ext);
if (found) fmt = r[column->text];
}
if (!found)
{
Gtk::MessageDialog tbd
(*this, _("Unsupported file format."),
use_markup, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_OK, modal);
tbd.set_secondary_text
((format (_("The '%1%' file extension is not associated with"
" a supported file format. Please select a file"
" format or use one of the known file extensions."))
% ext).str ());
if (dynamic_cast< Gtk::Window * > (this))
get_group ()->add_window (tbd);
tbd.run ();
signal_response ().emission_stop ();
response (Gtk::RESPONSE_CANCEL);
return;
}
}
if (!single_image_mode_
&& requests_single_file (get_current_name ()))
{ // check whether single file is okay
if (!supports_multi_image (get_current_name ()))
{
Gtk::MessageDialog tbd
(*this, (format (_("The %1% format does not support multiple"
" images in a single file.")) % fmt).str (),
use_markup, Gtk::MESSAGE_WARNING, Gtk::BUTTONS_OK, modal);
tbd.set_secondary_text
((format (_("Please save to PDF or TIFF if you want a single"
" file. If you prefer the %1% image format, use"
" a filename such as 'Untitled-%%3i%2%'."))
% fmt % get_current_extension ()).str ());
if (dynamic_cast< Gtk::Window * > (this))
get_group ()->add_window (tbd);
tbd.run ();
signal_response ().emission_stop ();
response (Gtk::RESPONSE_CANCEL);
return;
}
}
if (!do_overwrite_confirmation_) return;
format message;
format details;
if (requests_single_file (get_current_name ()))
{
if (!fs::exists (std::string (get_filename ()))) return;
message = format (_("The name \"%1%\" already exists.\n"
"OK to overwrite this name using the new settings?"));
details = format (_("The file already exists in \"%1%\"."
" Replacing it will overwrite its contents."));
}
else
{
// FIXME Add meaningful checking
// if (no_possible_matches ) return;
message = format (_("Files matching \"%1%\" may already exist."
" Do you want to replace them?"));
//details = format (_("These files already exist in \"%1%\"."
// " Replacing them may overwrite their contents."));
// FIXME show list of matching files in an expander with details
}
message % get_current_name ();
if (0 < details.size ())
details % get_current_folder ();
Gtk::MessageDialog tbd (*this, message.str (), use_markup,
Gtk::MESSAGE_QUESTION,
Gtk::BUTTONS_NONE, modal);
if (0 < details.size ())
tbd.set_secondary_text (details.str ());
tbd.add_button (Gtk::Stock::NO , Gtk::RESPONSE_CANCEL);
tbd.add_button (Gtk::Stock::YES, Gtk::RESPONSE_ACCEPT);
tbd.set_default_response (Gtk::RESPONSE_ACCEPT);
if (dynamic_cast< Gtk::Window * > (this))
get_group ()->add_window (tbd);
if (Gtk::RESPONSE_ACCEPT != tbd.run ())
{
signal_response ().emission_stop ();
response (Gtk::RESPONSE_CANCEL);
}
}
int main(int argc, char **argv)
{
Glib::thread_init();
// gdk_threads_init(); // locks everything at least on freebsd
Gtk::Main tk(argc, argv);
gchar *locale_dir;
#ifdef G_OS_WIN32
char *inst_dir;
inst_dir = g_win32_get_package_installation_directory_of_module (NULL);
locale_dir = g_build_filename (inst_dir, "share", "locale", NULL);
g_free (inst_dir);
#else
locale_dir = g_strdup (LOCALEDIR);
#endif
bindtextdomain (GETTEXT_PACKAGE, locale_dir);
textdomain (GETTEXT_PACKAGE);
//cerr << locale_dir<< endl;
g_free(locale_dir);
locale_dir = NULL;
if (!gtk_gl_init_check (&argc, &argv) ||
!gdk_gl_init_check (&argc, &argv) ) {
std::cerr << "Failed to initialize GL\n";
return 1;
}
CommandLineOptions opts (argc, argv);
Platform::setBinaryPath (argv[0]);
Model *model = new Model();
try {
std::string user_config_dir = Glib::build_filename (Glib::get_user_config_dir(), "repsnapper");
Gio::File::create_for_path(user_config_dir)->make_directory_with_parents();
} catch(Gio::Error e) {
switch(e.code()) {
case Gio::Error::EXISTS:
// Directory has already been created. Normal.
break;
default:
Gtk::MessageDialog dialog (_("Couldn't create user config directory!"),
false, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_CLOSE);
dialog.set_secondary_text(e.what());
dialog.run();
return 1;
}
}
std::vector<std::string> user_config_bits(3);
user_config_bits[0] = Glib::get_user_config_dir();
user_config_bits[1] = "repsnapper";
user_config_bits[2] = "repsnapper.conf";
std::string user_config_file = Glib::build_filename (user_config_bits);
Glib::RefPtr<Gio::File> conf = Gio::File::create_for_path(user_config_file);
try {
Glib::RefPtr<Gio::File> global = find_global_config();
if(!global) {
// Don't leave an empty config file behind
conf->remove();
Gtk::MessageDialog dialog (_("Couldn't find global configuration!"),
false, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_CLOSE);
dialog.set_secondary_text (_("It is likely that repsnapper is not correctly installed."));
dialog.run();
return 1;
}
global->copy(conf);
} catch(Gio::Error e) {
switch(e.code()) {
case Gio::Error::EXISTS:
// The user already has a config. This is the normal case.
break;
case Gio::Error::PERMISSION_DENIED:
{
// Fall back to global config
Gtk::MessageDialog dialog (_("Unable to create user config"), false,
Gtk::MESSAGE_WARNING, Gtk::BUTTONS_CLOSE);
dialog.set_secondary_text(e.what() + _("\nFalling back to global config. Settings will not be saved."));
dialog.run();
conf = find_global_config();
if(!conf) {
Gtk::MessageDialog dialog (_("Couldn't find global configuration!"), false,
Gtk::MESSAGE_ERROR, Gtk::BUTTONS_CLOSE);
dialog.set_secondary_text (_("It is likely that repsnapper is not correctly installed."));
dialog.run();
return 1;
}
break;
}
default:
{
Gtk::MessageDialog dialog (_("Failed to locate config"), false,
Gtk::MESSAGE_ERROR, Gtk::BUTTONS_CLOSE);
dialog.set_secondary_text(e.what());
dialog.run();
return 1;
}
}
}
if (opts.settings_path.size() > 0)
model->LoadConfig(Gio::File::create_for_path(opts.settings_path));
else {
// TODO: Error detection
model->LoadConfig(conf);
}
bool nonprintingmode = false;
if (opts.stl_input_path.size() > 0) {
model->Read(Gio::File::create_for_path(opts.stl_input_path));
}
if (opts.gcode_output_path.size() > 0) {
nonprintingmode = true;
}
if (!opts.use_gui) {
if (opts.settings_path.size() > 0)
model->LoadConfig(Gio::File::create_for_path(opts.settings_path));
ViewProgress vprog(new Gtk::HBox(),new Gtk::ProgressBar(),new Gtk::Label());
vprog.set_terminal_output(true);
model->SetViewProgress(&vprog);
model->statusbar=NULL;
if (opts.gcode_output_path.size() > 0) {
model->ConvertToGCode();
model->WriteGCode(Gio::File::create_for_path(opts.gcode_output_path));
}
else if (opts.svg_output_path.size() > 0) {
model->SliceToSVG(Gio::File::create_for_path(opts.svg_output_path),
opts.svg_single_output);
}
else if (opts.binary_output_path.size() > 0) {
model->SaveStl(Gio::File::create_for_path(opts.binary_output_path));
}
else cerr << _("No output file given") << endl;
return 0;
}
View* mainwin = View::create(model);
mainwin->setNonPrintingMode(nonprintingmode, opts.gcode_output_path);
mainwin->set_icon_name("gtk-convert");
mainwin->set_title("Repsnapper");
for (uint i = 0; i < opts.files.size(); i++)
model->Read(Gio::File::create_for_path(opts.files[i]));
tk.run();
delete mainwin;
delete model;
return 0;
}
void AckFunctionDialog::onRenameAck() {
Glib::RefPtr < Gtk::TreeView::Selection > ref = mTreeAckList->
get_selection();
if (ref) {
Gtk::TreeModel::iterator iter = ref->get_selected();
if (iter) {
Gtk::TreeModel::Row row = *iter;
std::string oldName(row.get_value(m_viewscolumnrecord.name));
savePreviousAck(oldName);
SimpleTypeBox box(("Acknowledge function new name?"), "");
std::string name = boost::trim_copy(box.run());
if (box.valid()) {
if (checkName(name)) {
setSensitiveAck(false);
m_model->erase(iter);
Gtk::TreeModel::Children children = m_model->children();
m_iter = children.begin();
iter = m_model->append();
mAckNameEntry->set_text(name);
Gtk::ListStore::Row row = *iter;
row[m_viewscolumnrecord.name] = name;
if (mAckFunction.find(oldName) != mAckFunction.end()) {
mTextViewFunction->get_buffer()->
set_text(mAckFunction[oldName]);
mAckFunction[name] = mAckFunction[oldName];
mAckFunction.erase(oldName);
}
mAckName.push_back(name);
mRenameList.push_back(std::make_pair(oldName, name));
mHeaderAck->set_text("void " + name + "(const std::string&"\
"activityname,\n\t"\
"const ved::Activity& activity) {");
// Delete the element in the vector
for (std::vector < std::string > ::iterator it =
mAckName.begin(); it != mAckName.end(); ) {
if ( *it == oldName ) {
it = mAckName.erase(it);
}
else {
++it;
}
}
mTreeAckList->set_cursor(m_model->get_path(iter));
setSensitiveAck(true);
}
else {
Gtk::MessageDialog errorDial ("Name error !",
false,
Gtk::MESSAGE_ERROR,
Gtk::BUTTONS_OK,
true);
errorDial.set_title("Error !");
errorDial.run();
}
}
}
}
}