file_list.cpp

linux pritner GUI

    if (row_iter != list_store_r->children().begin()) text += ", ";
    text += (*row_iter)[model_column.file_name];
  }
  return text;
}

void FileListDialog::move_up(void) {

  Gtk::TreeModel::iterator selected_row_iter = tree_view.get_selection()->get_selected();
  if (selected_row_iter && selected_row_iter != list_store_r->children().begin()) {

    Gtk::TreeModel::Path tree_path(selected_row_iter);
    tree_path.prev(); // tree_path now refers to the row of the list store
                      // preceding the selected one
    Gtk::TreeModel::iterator prev_row_iter = list_store_r->get_iter(tree_path);

    Glib::ustring selected_name = (*selected_row_iter)[model_column.file_name];
    Glib::ustring prev_name = (*prev_row_iter)[model_column.file_name];
      
    (*selected_row_iter)[model_column.file_name] = prev_name;
    (*prev_row_iter)[model_column.file_name] = selected_name;
    tree_view.get_selection()->select(prev_row_iter);
  }
  else beep();
}

void FileListDialog::move_down(void) {

  Gtk::TreeModel::iterator selected_iter = tree_view.get_selection()->get_selected();
  if (selected_iter) {
    Gtk::TreeModel::iterator succeding_iter = selected_iter;
    ++succeding_iter;
   
    if (succeding_iter != list_store_r->children().end()) {

      Glib::ustring selected_name = (*selected_iter)[model_column.file_name];
      Glib::ustring succeding_name = (*succeding_iter)[model_column.file_name];
      
      (*selected_iter)[model_column.file_name] = succeding_name;
      (*succeding_iter)[model_column.file_name] = selected_name;
      tree_view.get_selection()->select(succeding_iter);
    }
    else beep();
  }
  else beep();
}

void FileListDialog::set_buttons_slot(void) {

  // see if anything is selected
  if (tree_view.get_selection()->get_selected()) {
    view_button_p->set_sensitive(true);
    remove_button_p->set_sensitive(true);

#if GTKMM_VERSION == 20
    view_button_p->set_relief(Gtk::RELIEF_NORMAL);
    remove_button_p->set_relief(Gtk::RELIEF_NORMAL);
#endif
  }
    
  else {
    view_button_p->set_sensitive(false);
    remove_button_p->set_sensitive(false);

#if GTKMM_VERSION == 20
    view_button_p->set_relief(Gtk::RELIEF_NONE);
    remove_button_p->set_relief(Gtk::RELIEF_NONE);
#endif
  }
}

void FileListDialog::add_file(void) {

  FileReadSelectDialog file_dialog(standard_size, true, *this);
  std::vector<Glib::ustring> file_result = file_dialog.exec();
  if (!file_result.empty()) {
    std::vector<Glib::ustring>::const_iterator iter;
    for (iter = file_result.begin(); iter != file_result.end(); ++iter) {
      // get a list store row to insert the file name
      Gtk::TreeModel::Row row = *(list_store_r->append());
      row[model_column.file_name] = *iter;
    }
  }
}

std::pair<const char*, char* const*> FileListDialog::get_view_file_parms(const string& file_name) {

  std::vector<std::string> view_parms;
  std::string view_cmd;
  std::string view_name;
  std::string::size_type end_pos;
  try {
    // lock the Prog_config object to stop it being accessed in
    // FaxListDialog::get_ps_viewer_parms() while we are accessing it here
    // (this is ultra cautious as it is only copied/checked for emptiness
    // there, and the GUI interface is insensitive if we are here)
    Glib::Mutex::Lock lock(*prog_config.mutex_p);
    view_cmd = Glib::filename_from_utf8(prog_config.ps_view_cmd);
  }
  catch (Glib::ConvertError&) {
    write_error("UTF-8 conversion error in FileListDialog::get_view_file_parms()\n");
    return std::pair<const char*, char* const*>(0,0);
  }

  if ((end_pos = view_cmd.find_first_of(' ')) != std::string::npos) { // we have parms
    view_name.assign(view_cmd, 0, end_pos);
    view_parms.push_back(view_name);
    // find start of next parm
    std::string::size_type start_pos = view_cmd.find_first_not_of(' ', end_pos);
    while (start_pos != std::string::npos) {
      end_pos = view_cmd.find_first_of(' ', start_pos);
      if (end_pos != std::string::npos) {
	view_parms.push_back(view_cmd.substr(start_pos, end_pos - start_pos));
	start_pos = view_cmd.find_first_not_of(' ', end_pos); // prepare for next interation
      }
      else {
	view_parms.push_back(view_cmd.substr(start_pos, 
					     view_cmd.size() - start_pos));
	start_pos = end_pos;
      }
    }
  }

  else { // just a view command without parameters to be passed
    view_name = view_cmd;
    view_parms.push_back(view_name);
  }

  view_parms.push_back(file_name);

  char** exec_parms = new char*[view_parms.size() + 1];

  char**  temp_pp = exec_parms;
  std::vector<std::string>::const_iterator iter;
  for (iter = view_parms.begin(); iter != view_parms.end(); ++iter, ++temp_pp) {
    *temp_pp = new char[iter->size() + 1];
    std::strcpy(*temp_pp, iter->c_str());
  }
  
  *temp_pp = 0;

  char* prog_name = new char[view_name.size() + 1];
  std::strcpy(prog_name, view_name.c_str());

  return std::pair<const char*, char* const*>(prog_name, exec_parms);
}

void FileListDialog::view_file(void) {

  Gtk::TreeModel::iterator row_iter = tree_view.get_selection()->get_selected();
  
  bool is_ps_view_cmd_empty;
  { // lock the Prog_config object to stop it being accessed in
    // FaxListDialog::get_ps_viewer_parms() while we are accessing it here
    // (this is ultra cautious as it is only copied/checked for emptiness
    // there, and the GUI interface is insensitive if we are here)
    Glib::Mutex::Lock lock(*prog_config.mutex_p);
    is_ps_view_cmd_empty = prog_config.ps_view_cmd.empty();
  }
  if (row_iter && !is_ps_view_cmd_empty) {
    
    std::string file_name;
    try {
      file_name = Glib::filename_from_utf8((*row_iter)[model_column.file_name]);
    }
    catch (Glib::ConvertError&) {
      write_error("UTF-8 conversion error in FileListDialog::view_file()\n");
      beep();
      return;
    }

    // get the arguments for the exec() call below (because this is a
    // multi-threaded program, we must do this before fork()ing because
    // we use functions to get the arguments which are not async-signal-safe)
    std::pair<const char*, char* const*> view_file_parms(get_view_file_parms(file_name));

    if (view_file_parms.first) { // this will be 0 if get_view_file_parms()
                                 // threw a Glib::ConvertError)

      pid_t pid = fork();

      if (pid == -1) {
	write_error("Fork error - exiting\n");
	std::exit(FORK_ERROR);
      }
      if (!pid) {  // child process - as soon as everything is set up we are going to do an exec()

	connect_to_stderr();

	execvp(view_file_parms.first, view_file_parms.second);

	// if we reached this point, then the execvp() call must have failed
	// report error and end process - use _exit() and not exit()
	write_error("Can't find the postscript viewer program - please check your installation\n"
		    "and the PATH environmental variable\n");
      _exit(0);
      } // end of view program process
      // release the memory allocated on the heap for
      // the redundant view_file_parms
      // we are in the main parent process here - no worries about
      // only being able to use async-signal-safe functions
      delete_parms(view_file_parms);
    }
  }
}

void FileListDialog::delete_parms(std::pair<const char*, char* const*> parms_pair) {

  delete[] parms_pair.first;
  char* const* temp_pp = parms_pair.second;
  for(; *temp_pp != 0; ++temp_pp) {
    delete[] *temp_pp;
  }
  delete[] parms_pair.second;
}

void FileListDialog::remove_file_prompt(void) {

  Gtk::TreeModel::iterator row_iter = tree_view.get_selection()->get_selected();
  if (row_iter) {
    Glib::ustring msg(gettext("Remove file "));
    msg += (*row_iter)[model_column.file_name] + gettext(" from the list?");
    
    PromptDialog* dialog_p = new PromptDialog(msg, gettext("Remove file"), standard_size, *this);
    dialog_p->accepted.connect(sigc::mem_fun(*this, &FileListDialog::remove_file));
    // there is no memory leak -- the memory will be deleted when PromptDialog closes
  }
}

void FileListDialog::remove_file(void) {

  Gtk::TreeModel::iterator row_iter = tree_view.get_selection()->get_selected();
  if (row_iter) list_store_r->erase(row_iter);
}