fax_list.cpp

linux pritner GUI

/* Copyright (C) 2001 to 2004 Chris Vine

This program is distributed under the General Public Licence, version 2.
For particulars of this and relevant disclaimers see the file
COPYING distributed with the source files.

*/

#include <vector>
#include <iomanip>
#include <cstring>
#include <cstdlib>

#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <limits.h>
#include <signal.h>
#include <errno.h>

#include <gtkmm/image.h>
#include <gtkmm/tooltips.h>
#include <gtkmm/main.h>
#include <gtkmm/stock.h>

#include <gdkmm/pixbuf.h>
#include <gdk/gdkkeysyms.h> // the key codes are here

#include <glibmm/convert.h>
#include <glibmm/timer.h>
#include <glibmm/thread.h>

#include "fax_list.h"
#include "dialogs.h"
#include "fax_list_icons.h"
#include "pipes.h"

#ifdef HAVE_PTHREAD_SIGMASK 
#include <pthread.h>
#endif

#ifdef HAVE_STRINGSTREAM
#include <sstream>
#else
#include <strstream>
#endif

#ifdef ENABLE_NLS
#include <libintl.h>
#endif

int FaxListDialog::is_fax_received_list = 0;
int FaxListDialog::is_fax_sent_list = 0;



FaxListDialog::FaxListDialog(FaxListEnum::Mode mode_, const int standard_size_):
                              Gtk::Window(Gtk::WINDOW_TOPLEVEL),
                              mode(mode_), standard_size(standard_size_),
			      fax_basename_sem(1),
                              fax_list_manager(mode),
			      fax_list_box(false, 0), table(2, 1, false),
                              close_button(Gtk::Stock::CLOSE),
			      button_box(Gtk::BUTTONBOX_SPREAD) {

  // notify the existence of this object
  if (mode == FaxListEnum::received) is_fax_received_list++;
  else is_fax_sent_list++;

  folder_list_scroll_window.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
  folder_list_scroll_window.set_shadow_type(Gtk::SHADOW_IN);
  fax_list_manager.insert_folder_tree_view(folder_list_scroll_window);

  fax_list_scroll_window.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_AUTOMATIC);
  fax_list_scroll_window.set_shadow_type(Gtk::SHADOW_IN);
  fax_list_manager.insert_fax_tree_view(fax_list_scroll_window);

  // set up the tool bar
  tool_bar.set_orientation(Gtk::ORIENTATION_HORIZONTAL);
  tool_bar.set_toolbar_style(Gtk::TOOLBAR_ICONS);

  // first make the image widgets
  Gtk::Image* print_image_p = manage(new Gtk::Image(Gdk::Pixbuf::create_from_xpm_data(print_xpm)));
  Gtk::Image* view_image_p = manage(new Gtk::Image(Gdk::Pixbuf::create_from_xpm_data(view_xpm)));
  Gtk::Image* describe_image_p = manage(new Gtk::Image(Gdk::Pixbuf::create_from_xpm_data(describe_xpm)));
  Gtk::Image* delete_fax_image_p = manage(new Gtk::Image(Gdk::Pixbuf::create_from_xpm_data(delete_xpm)));
  Gtk::Image* add_folder_image_p = manage(new Gtk::Image(Gdk::Pixbuf::create_from_xpm_data(add_folder_xpm)));
  Gtk::Image* delete_folder_image_p = manage(new Gtk::Image(Gdk::Pixbuf::create_from_xpm_data(delete_folder_xpm)));
  Gtk::Image* refresh_image_p = manage(new Gtk::Image(Gdk::Pixbuf::create_from_xpm_data(refresh_xpm)));

  tool_bar.set_tooltips(true);

#if GTKMM_VERSION >= 24

  tool_bar.set_toolbar_style(Gtk::TOOLBAR_ICONS);

  Gtk::Tooltips* tooltips_p = tool_bar.get_tooltips_object();
  tooltips_p->enable();

  print_button_p = manage(new Gtk::ToolButton(*print_image_p));
  tool_bar.append(*print_button_p, sigc::mem_fun(*this, &FaxListDialog::print_fax_prompt));
  print_button_p->set_sensitive(false);
  print_button_p->set_tooltip(*tooltips_p, gettext("Print selected fax"));

  view_button_p = manage(new Gtk::ToolButton(*view_image_p));
  tool_bar.append(*view_button_p, sigc::mem_fun(*this, &FaxListDialog::view_fax));
  view_button_p->set_sensitive(false);
  view_button_p->set_tooltip(*tooltips_p, gettext("View selected fax"));

  describe_button_p = manage(new Gtk::ToolButton(*describe_image_p));
  tool_bar.append(*describe_button_p, sigc::mem_fun(*this, &FaxListDialog::describe_fax_prompt));
  describe_button_p->set_sensitive(false);
  describe_button_p->set_tooltip(*tooltips_p, gettext("Add/amend description for selected fax"));

  delete_fax_button_p = manage(new Gtk::ToolButton(*delete_fax_image_p));
  tool_bar.append(*delete_fax_button_p, sigc::mem_fun(*this, &FaxListDialog::delete_fax_prompt));
  delete_fax_button_p->set_sensitive(false);
  delete_fax_button_p->set_tooltip(*tooltips_p, gettext("Delete selected fax"));

  Gtk::ToolButton* add_folder_button_p = manage(new Gtk::ToolButton(*add_folder_image_p));
  tool_bar.append(*add_folder_button_p, sigc::mem_fun(*this, &FaxListDialog::add_folder_prompt));
  add_folder_button_p->set_tooltip(*tooltips_p, gettext("Add new folder"));

  delete_folder_button_p = manage(new Gtk::ToolButton(*delete_folder_image_p));
  tool_bar.append(*delete_folder_button_p, sigc::mem_fun(*this, &FaxListDialog::delete_folder_prompt));
  delete_folder_button_p->set_sensitive(false);
  delete_folder_button_p->set_tooltip(*tooltips_p, gettext("Delete selected folder"));

  Gtk::ToolButton* refresh_button_p = manage(new Gtk::ToolButton(*refresh_image_p));
  tool_bar.append(*refresh_button_p, sigc::mem_fun(*this, &FaxListDialog::refresh_slot));
  refresh_button_p->set_tooltip(*tooltips_p, gettext("Refresh fax list"));

#else

  Gtk::Button* add_folder_button_p;
  Gtk::Button* refresh_button_p;
  {
    using namespace Gtk::Toolbar_Helpers;
    
    ToolList& tool_list = tool_bar.tools();
    tool_list.push_back(ButtonElem(*print_image_p, SigC::slot(*this, &FaxListDialog::print_fax_prompt),
				   gettext("Print selected fax")));
    print_button_p = static_cast<Gtk::Button*>(tool_list.back().get_widget());
    print_button_p->set_relief(Gtk::RELIEF_NONE);
    print_button_p->set_sensitive(false);

    tool_list.push_back(ButtonElem(*view_image_p, SigC::slot(*this, &FaxListDialog::view_fax),
				   gettext("View selected fax")));
    view_button_p = static_cast<Gtk::Button*>(tool_list.back().get_widget());
    view_button_p->set_relief(Gtk::RELIEF_NONE);
    view_button_p->set_sensitive(false);

    tool_list.push_back(ButtonElem(*describe_image_p, SigC::slot(*this, &FaxListDialog::describe_fax_prompt),
				   gettext("Add/amend description for selected fax")));
    describe_button_p = static_cast<Gtk::Button*>(tool_list.back().get_widget());
    describe_button_p->set_relief(Gtk::RELIEF_NONE);
    describe_button_p->set_sensitive(false);

    tool_list.push_back(ButtonElem(*delete_fax_image_p, SigC::slot(*this, &FaxListDialog::delete_fax_prompt),
				   gettext("Delete selected fax")));
    delete_fax_button_p = static_cast<Gtk::Button*>(tool_list.back().get_widget());
    delete_fax_button_p->set_relief(Gtk::RELIEF_NONE);
    delete_fax_button_p->set_sensitive(false);

    tool_list.push_back(ButtonElem(*add_folder_image_p, SigC::slot(*this, &FaxListDialog::add_folder_prompt),
				   gettext("Add new folder")));
    add_folder_button_p = static_cast<Gtk::Button*>(tool_list.back().get_widget());

    tool_list.push_back(ButtonElem(*delete_folder_image_p, SigC::slot(*this, &FaxListDialog::delete_folder_prompt),
				   gettext("Delete selected folder")));
    delete_folder_button_p = static_cast<Gtk::Button*>(tool_list.back().get_widget());
    delete_folder_button_p->set_relief(Gtk::RELIEF_NONE);
    delete_folder_button_p->set_sensitive(false);

    tool_list.push_back(ButtonElem(*refresh_image_p, SigC::slot(*this, &FaxListDialog::refresh_slot),
				   gettext("Refresh fax list")));
    refresh_button_p = static_cast<Gtk::Button*>(tool_list.back().get_widget());
  }

#endif

  button_box.add(close_button);

  list_pane.pack1(folder_list_scroll_window, false, true);
  list_pane.pack2(fax_list_scroll_window, true, true);

  list_pane.set_position(standard_size * 5);

  table.attach(list_pane, 0, 1, 0, 1, Gtk::EXPAND | Gtk::FILL,
         Gtk::EXPAND | Gtk::FILL, standard_size/3, standard_size/3);
  table.attach(button_box, 0, 1, 1, 2, Gtk::EXPAND | Gtk::FILL,
	 Gtk::SHRINK, standard_size/3, standard_size/3);

  fax_list_box.pack_start(tool_bar, false, false);
  fax_list_box.pack_start(table, true, true);

  // now connect up the signal which indicates a selection has been made
  fax_list_manager.selection_notify.connect(sigc::mem_fun(*this, &FaxListDialog::set_buttons_slot));

  // connect up close_button
  close_button.signal_clicked().connect(sigc::mem_fun(*this, &FaxListDialog::close_slot));
  close_button.set_flags(Gtk::CAN_DEFAULT);
  close_button.grab_focus();

  table.set_border_width(standard_size/3);

  if (mode == FaxListEnum::received) set_title(gettext("efax-gtk: Received fax list"));
  else set_title(gettext("efax-gtk: Sent fax list"));
  //set_position(Gtk::WIN_POS_CENTER);
  add(fax_list_box);

  set_default_size(standard_size * 18, standard_size * 16);

  set_icon(prog_config.window_icon_r);

  show_all();

#if GTKMM_VERSION < 24
  add_folder_button_p->set_relief(Gtk::RELIEF_NORMAL);
  refresh_button_p->set_relief(Gtk::RELIEF_NORMAL);
#endif
  add_folder_button_p->set_sensitive(true);
  refresh_button_p->set_sensitive(true);
}

FaxListDialog::~FaxListDialog(void) {
  // notify the destruction of this object
  if (mode == FaxListEnum::received) is_fax_received_list--;
  else is_fax_sent_list--;
}

void FaxListDialog::close_slot(void) {
  hide_all();
  delete this; // this is completely safe as the dialog is self-owning and modeless
}


bool FaxListDialog::on_delete_event(GdkEventAny*) {
  close_slot();
  return true; // returning true prevents destroy sig being emitted
}

void FaxListDialog::set_buttons_slot(void) {

  // see if fax is selected
  if (fax_list_manager.is_fax_selected()) {
    print_button_p->set_sensitive(true);
    view_button_p->set_sensitive(true);
    describe_button_p->set_sensitive(true);
    delete_fax_button_p->set_sensitive(true);

#if GTKMM_VERSION < 24
    print_button_p->set_relief(Gtk::RELIEF_NORMAL);
    view_button_p->set_relief(Gtk::RELIEF_NORMAL);
    describe_button_p->set_relief(Gtk::RELIEF_NORMAL);
    delete_fax_button_p->set_relief(Gtk::RELIEF_NORMAL);
#endif
  }
    
  else {
    print_button_p->set_sensitive(false);
    view_button_p->set_sensitive(false);
    describe_button_p->set_sensitive(false);
    delete_fax_button_p->set_sensitive(false);

#if GTKMM_VERSION < 24
    print_button_p->set_relief(Gtk::RELIEF_NONE);
    view_button_p->set_relief(Gtk::RELIEF_NONE);
    describe_button_p->set_relief(Gtk::RELIEF_NONE);
    delete_fax_button_p->set_relief(Gtk::RELIEF_NONE);
#endif
  }

  // see if folder is selected
  if (fax_list_manager.is_folder_selected()) {
    delete_folder_button_p->set_sensitive(true);
#if GTKMM_VERSION < 24
    delete_folder_button_p->set_relief(Gtk::RELIEF_NORMAL);
#endif
  }

  else {
    delete_folder_button_p->set_sensitive(false);
#if GTKMM_VERSION < 24
    delete_folder_button_p->set_relief(Gtk::RELIEF_NONE);
#endif
  }
}

void FaxListDialog::delete_fax_prompt(void) {

  if (fax_list_manager.is_fax_selected()) {
    Glib::ustring msg(gettext("Delete fax "));
    msg += fax_list_manager.get_fax_number() + (gettext("?"));
    
    PromptDialog* dialog_p = new PromptDialog(msg, gettext("Delete fax"),
					      standard_size, *this);
    dialog_p->accepted.connect(sigc::mem_fun(fax_list_manager, &FaxListManager::delete_fax));
    // there is no memory leak -- the memory will be deleted when PromptDialog closes
  }
}

void FaxListDialog::describe_fax_prompt(void) {

  if (fax_list_manager.is_fax_selected()) {
    DescriptionDialog* dialog_p = new DescriptionDialog(standard_size,
							fax_list_manager.get_fax_description(),
							*this);
    dialog_p->accepted.connect(sigc::mem_fun(fax_list_manager, &FaxListManager::describe_fax));
    // there is no memory leak -- the memory will be deleted when DescriptionDialog closes
  }
}

void FaxListDialog::add_folder_prompt(void) {

  AddFolderDialog* dialog_p = new AddFolderDialog(standard_size, *this);
  dialog_p->accepted.connect(sigc::mem_fun(*this, &FaxListDialog::add_folder));
  // there is no memory leak -- the memory will be deleted when DescriptionDialog closes

}

void FaxListDialog::add_folder(const Glib::ustring& folder_name) {

  std::pair<bool, Glib::ustring> result = fax_list_manager.is_folder_name_valid(folder_name);
  if (!result.first) {
    new InfoDialog(result.second, 
		   gettext("efax-gtk fax list"),
		   standard_size, Gtk::MESSAGE_WARNING,
		   *this);
    // there is no memory leak -- the memory will be deleted when InfoDialog closes
  }    

  else fax_list_manager.make_folder(folder_name, false);
}

void FaxListDialog::delete_folder_prompt(void) {

  if (fax_list_manager.is_folder_selected()) {
    if (!fax_list_manager.is_folder_empty()) {
      new InfoDialog(gettext("Empty the folder by deleting any child folders\n"
                             "and drag-and-dropping or deleting any contained\n"
			     "faxes before deleting folder"), 
		     gettext("efax-gtk fax list"),
		     standard_size, Gtk::MESSAGE_WARNING,
		     *this);
      // there is no memory leak -- the memory will be deleted when InfoDialog closes
    }

    else {
      Glib::ustring msg(gettext("Delete folder: "));
      msg += fax_list_manager.get_folder_name() + (gettext("?"));
    
      PromptDialog* dialog_p = new PromptDialog(msg, gettext("Delete folder"),
						standard_size, *this);
      dialog_p->accepted.connect(sigc::mem_fun(fax_list_manager, &FaxListManager::delete_folder));
      // there is no memory leak -- the memory will be deleted when PromptDialog closes
    }
  }
}

void FaxListDialog::print_fax_prompt(void) {

  // we do not need a mutex before reading prog_config.print_cmd
  // as although read in FaxListDialog::get_print_from_stdin_parms(),
  // the thread which executes that method cannot start until the prompt
  // dialog below is launched
  if(fax_list_manager.is_fax_selected()
     && !prog_config.print_cmd.empty()) {
    // we do not need a mutex before reading prog_config.print_popup either, even though
    // it is also read in FaxListDialog::print_fax_thread(), because it is of type
    // bool which can be safely concurrently read in different threads and in any
    // event it is read in FaxListDialog::print_fax_thread() in a separate process
    // after fork()ing so there isn't even concurrent access
    if (prog_config.print_popup) {
      
	Glib::ustring msg(gettext("Print fax "));
	msg += fax_list_manager.get_fax_number() + gettext("?");
      
	PromptDialog* dialog_p = new PromptDialog(msg, gettext("Print fax"), standard_size, *this);
	dialog_p->accepted.connect(sigc::mem_fun(*this, &FaxListDialog::print_fax));
	// there is no memory leak -- the memory will be deleted when PromptDialog closes