settings.cpp

linux pritner GUI

	}
      
	// look for "PS_VIEWER:"
	else if (find_prog_parm("PS_VIEWER:", file_read) || find_prog_parm("#PS_VIEWER:", file_read)) {
	  if (!found_ps_view_cmd) {
	    found_ps_view_cmd = true;
	    file_list.push_back(Glib::filename_from_utf8(ps_view_cmd_line));
	  }
	}
      
	// look for "SOCK_SERVER:"
	else if (find_prog_parm("SOCK_SERVER:", file_read) || find_prog_parm("#SOCK_SERVER:", file_read)) {
	  if (!found_run_server) {
	    found_run_server = true;
	    file_list.push_back(run_server_line);
	  }
	}
      
	// look for "SOCK_POPUP:"
	else if (find_prog_parm("SOCK_POPUP:", file_read) || find_prog_parm("#SOCK_POPUP:", file_read)) {
	  if (!found_sock_popup) {
	    found_sock_popup = true;
	    file_list.push_back(sock_popup_line);
	  }
	}
      
	// look for "SOCK_SERVER_PORT:"
	else if (find_prog_parm("SOCK_SERVER_PORT:", file_read) || find_prog_parm("#SOCK_SERVER_PORT:", file_read)) {
	  if (!found_sock_port) {
	    found_sock_port = true;
	    file_list.push_back(sock_port_line);
	  }
	}
      
	// look for "SOCK_CLIENT_ADDRESS:"
	else if (find_prog_parm("SOCK_CLIENT_ADDRESS:", file_read) || find_prog_parm("#SOCK_CLIENT_ADDRESS:", file_read)) {
	  if (!found_sock_client_address) {
	    found_sock_client_address = true;
	    file_list.push_back(sock_client_address_line);
	  }
	}
      
	// look for "SOCK_OTHER_ADDRESSES:"
	else if (find_prog_parm("SOCK_OTHER_ADDRESSES:", file_read) || find_prog_parm("#SOCK_OTHER_ADDRESSES:", file_read)) {
	  if (!found_sock_other_addresses) {
	    found_sock_other_addresses = true;
	    file_list.push_back(sock_other_addresses_line);
	  }
	}

	// look for "FAX_RECEIVED_POPUP:"
	else if (find_prog_parm("FAX_RECEIVED_POPUP:", file_read) || find_prog_parm("#FAX_RECEIVED_POPUP:", file_read)) {
	  if (!found_fax_received_popup) {
	    found_fax_received_popup = true;
	    file_list.push_back(fax_received_popup_line);
	  }
	}
      
	// look for "FAX_RECEIVED_EXEC:"
	else if (find_prog_parm("FAX_RECEIVED_EXEC:", file_read) || find_prog_parm("#FAX_RECEIVED_EXEC:", file_read)) {
	  if (!found_fax_received_exec) {
	    found_fax_received_exec = true;
	    file_list.push_back(fax_received_exec_line);
	  }
	}
      
	// look for "FAX_RECEIVED_PROG:"
	else if (find_prog_parm("FAX_RECEIVED_PROG:", file_read) || find_prog_parm("#FAX_RECEIVED_PROG:", file_read)) {
	  if (!found_fax_received_prog) {
	    found_fax_received_prog = true;
	    file_list.push_back(Glib::filename_from_utf8(fax_received_prog_line));
	  }
	}
      
	// look for "LOG_FILE:"
	else if (find_prog_parm("LOG_FILE:", file_read) || find_prog_parm("#LOG_FILE:", file_read)) {
	  if (!found_log_file) {
	    found_log_file = true;
	    file_list.push_back(Glib::filename_from_utf8(logfile_line));
	  }
	}
      
	// add any residual lines to the list, except the terminating line
	else if (!find_prog_parm(terminating_line, file_read)) file_list.push_back(file_read);
      }
      catch (Glib::ConvertError&) {
	write_error("UTF-8 conversion error in SettingsDialog::write_config()\n");
      }
    }


    if (found_number == false) file_list.push_back(number_line);
    if (found_device == false) file_list.push_back(device_line);
    if (found_class == false) file_list.push_back(class_line);
    if (found_page == false) file_list.push_back(page_line);
    if (found_res == false) file_list.push_back(res_line);
    if (found_rings == false) file_list.push_back(rings_line);
    if (found_dialmode = false) file_list.push_back(dialmode_line);
    if (found_init == false) file_list.push_back(init_line);
    if (found_reset == false) file_list.push_back(reset_line);
    if (found_capabilities == false) file_list.push_back(capabilities_line);
    if (found_parms == false) file_list.push_back(extra_parms_line);
    if (found_print_shrink == false) file_list.push_back(print_shrink_line);
    if (found_print_popup == false) file_list.push_back(print_popup_line);
    if (found_run_server == false) file_list.push_back(run_server_line);
    if (found_sock_popup == false) file_list.push_back(sock_popup_line);
    if (found_sock_port == false) file_list.push_back(sock_port_line);
    if (found_sock_client_address == false) file_list.push_back(sock_client_address_line);
    if (found_sock_other_addresses == false) file_list.push_back(sock_other_addresses_line);
    if (found_fax_received_popup == false) file_list.push_back(fax_received_popup_line);
    if (found_fax_received_exec == false) file_list.push_back(fax_received_exec_line);

    try {
      if (found_name == false) file_list.push_back(Glib::locale_from_utf8(name_line));
    }
    catch (Glib::ConvertError&) {
      write_error("UTF-8 conversion error in SettingsDialog::write_config()\n");
    }

    try {
      if (found_lock == false) file_list.push_back(Glib::filename_from_utf8(lock_line));
    }
    catch (Glib::ConvertError&) {
      write_error("UTF-8 conversion error in SettingsDialog::write_config()\n");
    }

    try {
      if (found_print_cmd == false) file_list.push_back(Glib::filename_from_utf8(print_cmd_line));
    }
    catch (Glib::ConvertError&) {
      write_error("UTF-8 conversion error in SettingsDialog::write_config()\n");
    }

    try {
      if (found_ps_view_cmd == false) file_list.push_back(Glib::filename_from_utf8(ps_view_cmd_line));
    }
    catch (Glib::ConvertError&) {
      write_error("UTF-8 conversion error in SettingsDialog::write_config()\n");
    }

    try {
      if (found_fax_received_prog == false) file_list.push_back(Glib::filename_from_utf8(fax_received_prog_line));
    }
    catch (Glib::ConvertError&) {
      write_error("UTF-8 conversion error in SettingsDialog::write_config()\n");
    }

    try {
      if (found_log_file == false) file_list.push_back(Glib::filename_from_utf8(logfile_line));
    }
    catch (Glib::ConvertError&) {
      write_error("UTF-8 conversion error in SettingsDialog::write_config()\n");
    }

    // add the terminating line
    file_list.push_back(terminating_line);
    
    // now write out the new config file
    
    rcfile = prog_config.homedir + "/.";
    rcfile += RC_FILE;
    
    std::ofstream fileout(rcfile.c_str(), std::ios::out);
    if (!fileout) {
      std::string message("Can't open file");
      message += rcfile;
      message += '\n';
      write_error(message.c_str());
      return_val = false;
    }
    else {
      std::copy(file_list.begin(), file_list.end(),
		std::ostream_iterator<std::string>(fileout, "\n"));
    }
  }
  return return_val;
}

void SettingsDialog::read_config(bool search_localfile) {
// search_localfile has a default value of true
// get rc file
  if (!get_rcfile_path(search_localfile)) {
    std::string message;
    if (search_localfile) {
      message =  "Can't find or open file " RC_DIR "/"  RC_FILE ",\n";
      if (std::strcmp(RC_DIR, "/etc")) {
	message += "/etc/" RC_FILE ", ";
      }
      message += "or ";
      message += prog_config.homedir + "/." RC_FILE "\n";
    }
    else {
      message =  "Can't find or open file " RC_DIR "/"  RC_FILE "\n";
      if (std::strcmp(RC_DIR, "/etc")) {
	message += "or /etc/" RC_FILE "\n";
      }
    }
    write_error(message.c_str());
  }

  else {
// now extract settings from file

    std::ifstream filein(rcfile.c_str(), std::ios::in);
    if (!filein) {
      std::string message("Can't open file ");
      message += rcfile;
      write_error(message.c_str());
    }

    else {
      std::string file_read;
      Glib::ustring result;
      while (std::getline(filein, file_read)) {

	if (!file_read.empty() && file_read[0] != '#') { // valid line to check
	  // now check for other comment markers
	  std::string::size_type pos = file_read.find_first_of('#');
	  if (pos != std::string::npos) file_read.resize(pos); // truncate
	
	  // look for "NAME:"
	  if (get_prog_parm("NAME:", file_read, result)) {
	    identity_table.set_name(result);
	  }
	
	  // look for "NUMBER:"
	  else if (get_prog_parm("NUMBER:", file_read, result)) {
	    identity_table.set_number(result);
	  }
	
	  // look for "DEVICE:"
	  else if (get_prog_parm("DEVICE:", file_read, result)) {
	    modem_table.set_device(result);
	  }
	
	  // look for "LOCK:"
	  else if (get_prog_parm("LOCK:", file_read, result, Glib::filename_to_utf8)) {
	    modem_table.set_lock(result);
	  }

	  // look for "CLASS:"
	  else if (get_prog_parm("CLASS:", file_read, result)) {
	    modem_table.set_class(result);
	  }

	  // look for "PAGE:"
	  else if (get_prog_parm("PAGE:", file_read, result)) {
	    page_table.set_page(result);
	  }

	  // look for "RES:"
	  else if (get_prog_parm("RES:", file_read, result)) {
	    page_table.set_res(result);
	  }
	
	  // look for "RINGS:"
	  else if (get_prog_parm("RINGS:", file_read, result)) {
	    modem_table.set_rings(result);
	  }
	
	  // look for "DIALMODE:"
	  else if (get_prog_parm("DIALMODE:", file_read, result)) {
	    modem_table.set_dialmode(result);
	  }
	
	  // look for "INIT:"
	  else if (get_prog_parm("INIT:", file_read, result)) {
	    parms_table.set_init(result);
	  }
	
	  // look for "RESET:"
	  else if (get_prog_parm("RESET:", file_read, result)) {
	    parms_table.set_reset(result);
	  }

	  // look for "CAPABILITIES:"
	  else if (get_prog_parm("CAPABILITIES:", file_read, result)) {
	    modem_table.set_capabilities(result);
	  }

	  // look for "PARMS:"
	  else if (get_prog_parm("PARMS:", file_read, result)) {
	    parms_table.set_parms(result);
	  }

	  // look for "PRINT_CMD:"
	  else if (get_prog_parm("PRINT_CMD:", file_read, result)) {
	    print_table.set_command(result);
	  }

	  // look for "PRINT_SHRINK:"
	  else if (get_prog_parm("PRINT_SHRINK:", file_read, result)) {
	    print_table.set_shrink(result);
	  }

	  // look for "PRINT_POPUP:"
	  else if (get_prog_parm("PRINT_POPUP:", file_read, result)) {
	    print_table.set_popup(result);
	  }

	  // look for "PS_VIEWER:"
	  else if (get_prog_parm("PS_VIEWER:", file_read, result)) {
	    view_table.set_ps_view_command(result);
	  }

	  // look for "SOCK_SERVER:"
	  else if (get_prog_parm("SOCK_SERVER:", file_read, result)) {
	    sock_table.set_run_server(result);
	  }

	  // look for "SOCK_POPUP:"
	  else if (get_prog_parm("SOCK_POPUP:", file_read, result)) {
	    sock_table.set_popup(result);
	  }

	  // look for "SOCK_SERVER_PORT:"
	  else if (get_prog_parm("SOCK_SERVER_PORT:", file_read, result)) {
	    sock_table.set_port(result);
	  }

	  // look for "SOCK_CLIENT_ADDRESS:"
	  else if (get_prog_parm("SOCK_CLIENT_ADDRESS:", file_read, result)) {
	    sock_table.set_if_other_address(result);
	  }

	  // look for "SOCK_OTHER_ADDRESSES:"
	  else if (get_prog_parm("SOCK_OTHER_ADDRESSES:", file_read, result)) {
	    sock_table.set_other_addresses(result);
	  }

	  // look for "FAX_RECEIVED_POPUP:"
	  else if (get_prog_parm("FAX_RECEIVED_POPUP:", file_read, result)) {
	    receive_table.set_popup(result);
	  }

	  // look for "FAX_RECEIVED_EXEC:"
	  else if (get_prog_parm("FAX_RECEIVED_EXEC:", file_read, result)) {
	    receive_table.set_exec(result);
	  }

	  // look for "FAX_RECEIVED_PROG:"
	  else if (get_prog_parm("FAX_RECEIVED_PROG:", file_read, result)) {
	    receive_table.set_prog(result);
	  }

	  // look for "LOG_FILE:"
	  else if (get_prog_parm("LOG_FILE:", file_read, result, Glib::filename_to_utf8)) {
	    logging_table.set_logfile(result);
	  }
	}
      }
    }
  }
}

void SettingsDialog::get_reset_settings_prompt(void) {
  Glib::ustring message(gettext("Enter settings from "));
  message += RC_DIR "/"  RC_FILE;
  if (std::strcmp(RC_DIR, "/etc")) {
    message += gettext(" or\n");
    message += "/etc/" RC_FILE;
  }
  message += gettext("?");

  PromptDialog* dialog_p = new PromptDialog(message, gettext("Reset settings"), standard_size, *this);
  dialog_p->accepted.connect(sigc::mem_fun(*this, &SettingsDialog::get_reset_settings));