Slic3r::FirmwareDialog::priv Struct Reference

Collaboration diagram for Slic3r::FirmwareDialog::priv:

Public Types
enum	AvrDudeComplete { AC_NONE , AC_SUCCESS , AC_FAILURE , AC_USER_CANCELLED }

Public Member Functions
	priv (FirmwareDialog *q)
void	find_serial_ports ()
void	fit_no_shrink ()
void	set_txt_status (const wxString &label)
void	flashing_start (unsigned tasks)
void	flashing_done (AvrDudeComplete complete)
void	set_autodetect (bool autodetect)
void	update_flash_enabled ()
void	load_hex_file (const wxString &path)
void	queue_event (AvrdudeEvent aevt, wxString message)
bool	ask_model_id_mismatch (const std::string &printer_model)
bool	check_model_id ()
void	avr109_wait_for_bootloader (Avr109Pid usb_pid, unsigned retries)
void	avr109_reboot (const SerialPortInfo &port)
void	avr109_lookup_port (Avr109Pid usb_pid)
void	prepare_common ()
void	prepare_mk2 ()
void	prepare_mk3 ()
void	prepare_avr109 (Avr109Pid usb_pid)
bool	get_serial_port ()
void	perform_upload ()
void	user_cancel ()
void	on_avrdude (const wxCommandEvent &evt)
void	on_async_dialog (const wxCommandEvent &evt)
void	ensure_joined ()
void	queue_status (wxString message)
template<class ... Args>
void	queue_message (const wxString &format, Args... args)
template<class ... Args>
void	queue_error (const wxString &format, Args... args)

Static Public Member Functions
static const char *	avr109_dev_name (Avr109Pid usb_pid)

Public Attributes
FirmwareDialog *	q
wxComboBox *	port_picker
wxStaticText *	txt_port_autodetect
wxFilePickerCtrl *	hex_picker
wxStaticText *	txt_status
wxGauge *	progressbar
wxCollapsiblePane *	spoiler
wxTextCtrl *	txt_stdout
wxButton *	btn_rescan
wxButton *	btn_close
wxButton *	btn_flash
wxString	btn_flash_label_ready
wxString	btn_flash_label_flashing
wxString	label_status_flashing
wxTimer	timer_pulse
int	min_width
int	min_height
int	min_height_expanded
std::mutex	mutex
int	modal_response
std::condition_variable	response_cv
std::vector< SerialPortInfo >	ports
optional< SerialPortInfo >	port
bool	port_autodetect
HexFile	hex_file
AvrDude::Ptr	avrdude
unsigned	progress_tasks_done
unsigned	progress_tasks_bar
bool	user_cancelled
const bool	extra_verbose

Detailed Description

Member Enumeration Documentation

AvrDudeComplete

enum Slic3r::FirmwareDialog::priv::AvrDudeComplete

Enumerator
AC_NONE
AC_SUCCESS
AC_FAILURE
AC_USER_CANCELLED

  {
    AC_NONE,
    AC_SUCCESS,
    AC_FAILURE,
    AC_USER_CANCELLED,
  };

Constructor & Destructor Documentation

priv()

Slic3r::FirmwareDialog::priv::priv ( FirmwareDialog *  q )

inline

                          :
    q(q),
    btn_flash_label_ready(_(L("Flash!"))),
    btn_flash_label_flashing(_(L("Cancel"))),
    label_status_flashing(_(L("Flashing in progress. Please do not disconnect the printer!"))),
    timer_pulse(q),
    port_autodetect(false),
    progress_tasks_done(0),
    progress_tasks_bar(0),
    user_cancelled(false),
    extra_verbose(false)
  {}

Member Function Documentation

ask_model_id_mismatch()

bool Slic3r::FirmwareDialog::priv::ask_model_id_mismatch

(

const std::string &

printer_model

)

{
  // model_id in the hex file doesn't match what the printer repoted.
  // Ask the user if it should be flashed anyway.
 
  std::unique_lock<std::mutex> lock(mutex);
 
  auto evt = new wxCommandEvent(EVT_ASYNC_DIALOG, this->q->GetId());
  evt->SetString(wxString::Format(_(L(
    "This firmware hex file does not match the printer model.\n"
    "The hex file is intended for: %s\n"
    "Printer reported: %s\n\n"
    "Do you want to continue and flash this hex file anyway?\n"
    "Please only continue if you are sure this is the right thing to do.")),
    hex_file.model_id, printer_model
  ));
  wxQueueEvent(this->q, evt);
 
  response_cv.wait(lock, [this]() { return this->modal_response != wxID_NONE; });
 
  if (modal_response == wxID_YES) { 
    return true;
  } else {
    user_cancel();
    return false;
  }
}

References _, and L.

avr109_dev_name()

const char * Slic3r::FirmwareDialog::priv::avr109_dev_name ( Avr109Pid  usb_pid )

static

                                                                 {
  switch (usb_pid.boot) {
    case USB_PID_MMU_BOOT:
      return "Original Prusa MMU 2.0 Control";
    case USB_PID_CW1_BOOT:
      return "Original Prusa CW1";
    case USB_PID_CW1S_BOOT:
      return "Original Prusa CW1S";
    default: throw Slic3r::RuntimeError((boost::format("Invalid avr109 device USB PID: %1%") % usb_pid.boot).str());
  }
}

References Slic3r::Avr109Pid::boot, Slic3r::USB_PID_CW1_BOOT, Slic3r::USB_PID_CW1S_BOOT, and Slic3r::USB_PID_MMU_BOOT.

avr109_lookup_port()

void Slic3r::FirmwareDialog::priv::avr109_lookup_port

(

Avr109Pid

usb_pid

)

{
  const char *dev_name = avr109_dev_name(usb_pid);
  const wxString msg_not_found = wxString::Format(
    _(L("The %s device was not found.\n"
      "If the device is connected, please press the Reset button next to the USB connector ...")),
    dev_name);
 
  queue_message("Flashing %s, looking for VID/PID 0x2c99/%u or 0x2c99/%u ...", dev_name, usb_pid.boot, usb_pid.app);
 
  auto ports = Utils::scan_serial_ports_extended();
  ports.erase(std::remove_if(ports.begin(), ports.end(), [=](const SerialPortInfo &port ) {
    return port.id_vendor != USB_VID_PRUSA ||
      (port.id_product != usb_pid.boot && port.id_product != usb_pid.app);
  }), ports.end());
 
  if (ports.size() == 0) {
    queue_message("The %s device was not found.", dev_name);
    queue_status(msg_not_found);
    avr109_wait_for_bootloader(usb_pid, 30);
  } else if (ports.size() > 1) {
    queue_message("Several VID/PID 0x2c99/%u devices found", usb_pid.boot);
    queue_error(_(L("Multiple %s devices found. Please only connect one at a time for flashing.")), dev_name);
  } else {
    if (ports[0].id_product == usb_pid.app) {
      // The device needs to be rebooted into the bootloader mode
      queue_message("Found VID/PID 0x2c99/%u at `%s`, rebooting the device ...", usb_pid.app, ports[0].port);
      avr109_reboot(ports[0]);
      avr109_wait_for_bootloader(usb_pid, 10);
 
      if (! port) {
        // The device in bootloader mode was not found, inform the user and wait some more...
        queue_message("%s device not found after reboot", dev_name);
        queue_status(msg_not_found);
        avr109_wait_for_bootloader(usb_pid, 30);
      }
    } else {
      port = ports[0];
    }
  }
}

References _, Slic3r::Avr109Pid::app, Slic3r::Avr109Pid::boot, L, and Slic3r::Utils::scan_serial_ports_extended().

Here is the call graph for this function:

avr109_reboot()

void Slic3r::FirmwareDialog::priv::avr109_reboot

(

const SerialPortInfo &

port

)

{
  asio::io_service io;
  Serial serial(io, port.port, 1200);
  std::this_thread::sleep_for(std::chrono::milliseconds(50));
}

References Slic3r::Utils::SerialPortInfo::port.

avr109_wait_for_bootloader()

void Slic3r::FirmwareDialog::priv::avr109_wait_for_bootloader	(	Avr109Pid	usb_pid,
		unsigned	retries
	)

{
  enum {
    SLEEP_MS = 500,
  };
 
  for (unsigned i = 0; i < retries && !user_cancelled; i++) {
    std::this_thread::sleep_for(std::chrono::milliseconds(SLEEP_MS));
 
    auto ports = Utils::scan_serial_ports_extended();
    ports.erase(std::remove_if(ports.begin(), ports.end(), [=](const SerialPortInfo &port ) {
      return port.id_vendor != USB_VID_PRUSA || port.id_product != usb_pid.boot;
    }), ports.end());
 
    if (ports.size() == 1) {
      port = ports[0];
      return;
    } else if (ports.size() > 1) {
      queue_message("Several VID/PID 0x2c99/%u devices found", usb_pid.boot);
      queue_error(_(L("Multiple %s devices found. Please only connect one at a time for flashing.")), avr109_dev_name(usb_pid));
      return;
    }
  }
}

References _, Slic3r::Avr109Pid::boot, L, and Slic3r::Utils::scan_serial_ports_extended().

Here is the call graph for this function:

check_model_id()

bool Slic3r::FirmwareDialog::priv::check_model_id

(

)

{
  // XXX: The implementation in Serial doesn't currently work reliably enough to be used.
  // Therefore, regretably, so far the check cannot be used and we just return true here.
  // TODO: Rewrite Serial using more platform-native code.
  return true;
 
  // if (hex_file.model_id.empty()) {
  //  // No data to check against, assume it's ok
  //  return true;
  // }
 
  // asio::io_service io;
  // Serial serial(io, port->port, 115200);
  // serial.printer_setup();
 
  // enum {
  //  TIMEOUT = 2000,
  //  RETREIES = 5,
  // };
 
  // if (! serial.printer_ready_wait(RETREIES, TIMEOUT)) {
  //  queue_error(wxString::Format(_(L("Could not connect to the printer at %s")), port->port));
  //  return false;
  // }
 
  // std::string line;
  // error_code ec;
  // serial.printer_write_line("PRUSA Rev");
  // while (serial.read_line(TIMEOUT, line, ec)) {
  //  if (ec) {
  //    queue_error(wxString::Format(_(L("Could not connect to the printer at %s")), port->port));
  //    return false;
  //  }
 
  //  if (line == "ok") { continue; }
 
  //  if (line == hex_file.model_id) {
  //    return true;
  //  } else {
  //    return ask_model_id_mismatch(line);
  //  }
 
  //  line.clear();
  // }
 
  // return false;
}

ensure_joined()

void Slic3r::FirmwareDialog::priv::ensure_joined

(

)

{
  // Make sure the background thread is collected and the AvrDude object reset
  if (avrdude) { avrdude->join(); }
  avrdude.reset();
}

find_serial_ports()

void Slic3r::FirmwareDialog::priv::find_serial_ports

(

)

{
  auto new_ports = Utils::scan_serial_ports_extended();
  if (new_ports != this->ports) {
    this->ports = new_ports;
    port_picker->Clear();
    for (const auto &port : this->ports)
      port_picker->Append(wxString::FromUTF8(port.friendly_name.data()));
    if (ports.size() > 0) {
      int idx = port_picker->GetValue().IsEmpty() ? 0 : -1;
      for (int i = 0; i < (int)this->ports.size(); ++ i)
        if (this->ports[i].is_printer) {
          idx = i;
          break;
        }
      if (idx != -1) {
        port_picker->SetSelection(idx);
        update_flash_enabled();
      }
    }
  }
}

References port, port_picker, ports, Slic3r::Utils::scan_serial_ports_extended(), and update_flash_enabled().

Here is the call graph for this function:

fit_no_shrink()

void Slic3r::FirmwareDialog::priv::fit_no_shrink

(

)

{
  // Ensure content fits into window and window is not shrinked
  const auto old_size = q->GetSize();
  q->Layout();
  q->Fit();
  const auto new_size = q->GetSize();
  const auto new_width = std::max(old_size.GetWidth(), new_size.GetWidth());
  const auto new_height = std::max(old_size.GetHeight(), new_size.GetHeight());
  q->SetSize(new_width, new_height);
}

flashing_done()

void Slic3r::FirmwareDialog::priv::flashing_done

(

AvrDudeComplete

complete

)

{
  port_picker->Enable();
  btn_rescan->Enable();
  hex_picker->Enable();
  btn_close->Enable();
  btn_flash->SetLabel(btn_flash_label_ready);
  txt_status->SetForegroundColour(GUI::wxGetApp().get_label_clr_default());
  timer_pulse.Stop();
  progressbar->SetValue(progressbar->GetRange());
 
  switch (complete) {
  case AC_SUCCESS: set_txt_status(_(L("Flashing succeeded!"))); break;
  case AC_FAILURE: set_txt_status(_(L("Flashing failed. Please see the avrdude log below."))); break;
  case AC_USER_CANCELLED: set_txt_status(_(L("Flashing cancelled."))); break;
  default: break;
  }
}

References _, and L.

flashing_start()

void Slic3r::FirmwareDialog::priv::flashing_start

(

unsigned

tasks

)

{
  modal_response = wxID_NONE;
  txt_stdout->Clear();
  set_txt_status(label_status_flashing);
    txt_status->SetForegroundColour(GUI::wxGetApp().get_label_clr_modified());
  port_picker->Disable();
  btn_rescan->Disable();
  hex_picker->Disable();
  btn_close->Disable();
  btn_flash->SetLabel(btn_flash_label_flashing);
  progressbar->SetRange(200 * tasks);   // See progress callback below
  progressbar->SetValue(0);
  progress_tasks_done = 0;
  progress_tasks_bar = 0;
  user_cancelled = false;
  timer_pulse.Start(50);
}

get_serial_port()

bool Slic3r::FirmwareDialog::priv::get_serial_port

(

)

{
  const int selection = port_picker->GetSelection();
  if (selection != wxNOT_FOUND) {
    port = this->ports[selection];
  } else {
    // User has supplied a custom filename
 
    std::string path_u8 = GUI::into_u8(port_picker->GetValue());
#ifdef _WIN32
    static const std::regex com_pattern("COM[0-9]+", std::regex::icase);
    std::smatch matches;
    if (std::regex_match(path_u8, matches, com_pattern)) {
#else
    if (fs::is_other(fs::path(path_u8))) {
#endif
      port = SerialPortInfo(std::move(path_u8));
    } else {
      port = boost::none;
    }
  }
 
  return !!port;
}

References Slic3r::GUI::into_u8().

Here is the call graph for this function:

load_hex_file()

void Slic3r::FirmwareDialog::priv::load_hex_file

(

const wxString &

path

)

{
  hex_file = HexFile(path.wx_str());
  const bool autodetect = hex_file.device == HexFile::DEV_MM_CONTROL || hex_file.device == HexFile::DEV_CW1 || hex_file.device == HexFile::DEV_CW1S;
  set_autodetect(autodetect);
}

References Slic3r::Utils::HexFile::DEV_CW1, Slic3r::Utils::HexFile::DEV_CW1S, and Slic3r::Utils::HexFile::DEV_MM_CONTROL.

on_async_dialog()

void Slic3r::FirmwareDialog::priv::on_async_dialog

(

const wxCommandEvent &

evt

)

{
  //wxMessageDialog dlg(this->q, evt.GetString(), wxMessageBoxCaptionStr, wxYES_NO | wxNO_DEFAULT | wxICON_QUESTION);
  GUI::MessageDialog dlg(this->q, evt.GetString(), wxMessageBoxCaptionStr, wxYES_NO | wxNO_DEFAULT | wxICON_QUESTION);
  {
    std::lock_guard<std::mutex> lock(mutex);
    modal_response = dlg.ShowModal();
  }
  response_cv.notify_all();
}

on_avrdude()

void Slic3r::FirmwareDialog::priv::on_avrdude

(

const wxCommandEvent &

evt

)

{
  AvrDudeComplete complete_kind;
 
  switch (evt.GetExtraLong()) {
  case AE_MESSAGE:
    txt_stdout->AppendText(evt.GetString());
    break;
 
  case AE_PROGRESS:
    // We try to track overall progress here.
    // Avrdude performs 3 tasks per one memory operation ("-U" arg),
    // first of which is reading of status data (very short).
    // We use the timer_pulse during the very first task to indicate intialization
    // and then display overall progress during the latter tasks.
 
    if (progress_tasks_done > 0) {
      progressbar->SetValue(progress_tasks_bar + evt.GetInt());
    }
 
    if (evt.GetInt() == 100) {
      timer_pulse.Stop();
      if (progress_tasks_done % 3 != 0) {
        progress_tasks_bar += 100;
      }
      progress_tasks_done++;
    }
 
    break;
 
  case AE_EXIT:
    BOOST_LOG_TRIVIAL(info) << "avrdude exit code: " << evt.GetInt();
 
    // Figure out the exit state
    if (user_cancelled) { complete_kind = AC_USER_CANCELLED; }
    else if (avrdude->cancelled()) { complete_kind = AC_NONE; } // Ie. cancelled programatically
    else { complete_kind = evt.GetInt() == 0 ? AC_SUCCESS : AC_FAILURE; }
 
    flashing_done(complete_kind);
    ensure_joined();
    break;
 
  case AE_STATUS:
    set_txt_status(evt.GetString());
    break;
 
  default:
    break;
  }
}

References Slic3r::AE_EXIT, Slic3r::AE_MESSAGE, Slic3r::AE_PROGRESS, and Slic3r::AE_STATUS.

perform_upload()

void Slic3r::FirmwareDialog::priv::perform_upload

(

)

{
  auto filename = hex_picker->GetPath();
  if (filename.IsEmpty()) { return; }
 
  load_hex_file(filename);  // Might already be loaded, but we want to make sure it's fresh
 
  if (!port_autodetect && !get_serial_port()) {
    return;
  }
 
  const bool extra_verbose = false;   // For debugging
 
  flashing_start(hex_file.device == HexFile::DEV_MK3 ? 2 : 1);
 
  // Init the avrdude object
  AvrDude avrdude;
 
  // It is ok here to use the q-pointer to the FirmwareDialog
  // because the dialog ensures it doesn't exit before the background thread is done.
  auto q = this->q;
 
  avrdude
    .on_run([this](AvrDude::Ptr avrdude) {
      this->avrdude = std::move(avrdude);
 
      try {
        switch (this->hex_file.device) {
        case HexFile::DEV_MK3:
          this->prepare_mk3();
          break;
 
        case HexFile::DEV_MM_CONTROL:
          this->prepare_avr109(Avr109Pid(USB_PID_MMU_BOOT, USB_PID_MMU_APP));
          break;
 
        case HexFile::DEV_CW1:
          this->prepare_avr109(Avr109Pid(USB_PID_CW1_BOOT, USB_PID_CW1_APP));
          break;
 
        case HexFile::DEV_CW1S:
          this->prepare_avr109(Avr109Pid(USB_PID_CW1S_BOOT, USB_PID_CW1S_APP));
          break;
 
        default:
          this->prepare_mk2();
          break;
        }
      } catch (const std::exception &ex) {
        if (port) {
          queue_error(_(L("Error accessing port at %s: %s")), port->port, ex.what());
        } else {
          queue_error(_(L("Error: %s")), ex.what());
        }
      }
    })
    .on_message([
#if !defined(__APPLE__) && !defined(__clang__)
          // clang complains when capturing constants.
      extra_verbose,
#endif // __APPLE__
      q](const char* msg, unsigned /* size */) {
      if (extra_verbose) {
        BOOST_LOG_TRIVIAL(debug) << "avrdude: " << msg;
      }
 
      auto evt = new wxCommandEvent(EVT_AVRDUDE, q->GetId());
      auto wxmsg = wxString::FromUTF8(msg);
#ifdef WIN32
      // The string might be in local encoding
      if (wxmsg.IsEmpty() && *msg != '\0') {
        wxmsg = wxString(msg);
      }
#endif
 
      evt->SetExtraLong(AE_MESSAGE);
      evt->SetString(std::move(wxmsg));
      wxQueueEvent(q, evt);
        })
        .on_progress([q](const char * /* task */, unsigned progress) {
      auto evt = new wxCommandEvent(EVT_AVRDUDE, q->GetId());
      evt->SetExtraLong(AE_PROGRESS);
      evt->SetInt(progress);
      wxQueueEvent(q, evt);
        })
        .on_complete([this]() {
      auto evt = new wxCommandEvent(EVT_AVRDUDE, this->q->GetId());
      evt->SetExtraLong(AE_EXIT);
      evt->SetInt(this->avrdude->exit_code());
      wxQueueEvent(this->q, evt);
        })
    .run();
}

References _, Slic3r::AE_EXIT, Slic3r::AE_MESSAGE, Slic3r::AE_PROGRESS, Slic3r::Utils::HexFile::DEV_CW1, Slic3r::Utils::HexFile::DEV_CW1S, Slic3r::Utils::HexFile::DEV_MK3, Slic3r::Utils::HexFile::DEV_MM_CONTROL, L, Slic3r::AvrDude::on_run(), Slic3r::FirmwareDialog::run(), Slic3r::USB_PID_CW1_APP, Slic3r::USB_PID_CW1_BOOT, Slic3r::USB_PID_CW1S_APP, Slic3r::USB_PID_CW1S_BOOT, Slic3r::USB_PID_MMU_APP, and Slic3r::USB_PID_MMU_BOOT.

Here is the call graph for this function:

prepare_avr109()

void Slic3r::FirmwareDialog::priv::prepare_avr109

(

Avr109Pid

usb_pid

)

{
  port = boost::none;
  avr109_lookup_port(usb_pid);
  if (! port) {
    queue_error(_(L("The %s device could not have been found")), avr109_dev_name(usb_pid));
    return;
  }
 
  queue_message("Found VID/PID 0x2c99/%u at `%s`, flashing ...", usb_pid.boot, port->port);
  queue_status(label_status_flashing);
 
  std::vector<std::string> args {{
    extra_verbose ? "-vvvvv" : "-v",
    "-p", "atmega32u4",
    "-c", "avr109",
    "-P", port->port,
    "-b", "57600",
    "-D",
    "-U", (boost::format("flash:w:0:%1%:i") % hex_file.path.string()).str(),
  }};
 
  BOOST_LOG_TRIVIAL(info) << "Preparing avrdude arguments: "
    << std::accumulate(std::next(args.begin()), args.end(), args[0], [](std::string a, const std::string &b) {
      return a + ' ' + b;
    });
 
  avrdude->push_args(std::move(args));
}

References _, Slic3r::Avr109Pid::boot, and L.

prepare_common()

void Slic3r::FirmwareDialog::priv::prepare_common

(

)

{
  std::vector<std::string> args {{
    extra_verbose ? "-vvvvv" : "-v",
    "-p", "atmega2560",
    // Using the "Wiring" mode to program Rambo or Einsy, using the STK500v2 protocol (not the STK500).
    // The Prusa's avrdude is patched to never send semicolons inside the data packets, as the USB to serial chip
    // is flashed with a buggy firmware.
    "-c", "wiring",
    "-P", port->port,
    "-b", "115200",   // TODO: Allow other rates? Ditto elsewhere.
    "-D",
    "-U", (boost::format("flash:w:0:%1%:i") % hex_file.path.string()).str(),
  }};
 
  BOOST_LOG_TRIVIAL(info) << "Preparing arguments avrdude: "
    << std::accumulate(std::next(args.begin()), args.end(), args[0], [](std::string a, const std::string &b) {
      return a + ' ' + b;
    });
 
  avrdude->push_args(std::move(args));
}

prepare_mk2()

void Slic3r::FirmwareDialog::priv::prepare_mk2

(

)

{
  if (! port) { return; }
 
  if (! check_model_id()) {
    avrdude->cancel();
    return;
  }
 
  prepare_common();
}

prepare_mk3()

void Slic3r::FirmwareDialog::priv::prepare_mk3

(

)

{
  if (! port) { return; }
 
  if (! check_model_id()) {
    avrdude->cancel();
    return;
  }
 
  prepare_common();
 
  // The hex file also contains another section with l10n data to be flashed into the external flash on MK3 (Einsy)
  // This is done via another avrdude invocation, here we build arg list for that:
  std::vector<std::string> args {{
    extra_verbose ? "-vvvvv" : "-v",
    "-p", "atmega2560",
    // Using the "Arduino" mode to program Einsy's external flash with languages, using the STK500 protocol (not the STK500v2).
    // The Prusa's avrdude is patched again to never send semicolons inside the data packets.
    "-c", "arduino",
    "-P", port->port,
    "-b", "115200",
    "-D",
    "-u", // disable safe mode
    "-U", (boost::format("flash:w:1:%1%:i") % hex_file.path.string()).str(),
  }};
 
  BOOST_LOG_TRIVIAL(info) << "Preparing avrdude arguments for external flash flashing: "
    << std::accumulate(std::next(args.begin()), args.end(), args[0], [](std::string a, const std::string &b) {
      return a + ' ' + b;
    });
 
  avrdude->push_args(std::move(args));
}

queue_error()

template<class ... Args>

void Slic3r::FirmwareDialog::priv::queue_error ( const wxString &  format, Args...  args  )

inline

                                                                                 {
    queue_message(format, args...);
    queue_event(AE_STATUS, _(L("Flashing failed")) +": "+ wxString::Format(format, args...));
    avrdude->cancel();
  }

References _, Slic3r::AE_STATUS, avrdude, Slic3r::format(), L, queue_event(), and queue_message().

Here is the call graph for this function:

queue_event()

void Slic3r::FirmwareDialog::priv::queue_event	(	AvrdudeEvent	aevt,
		wxString	message
	)

{
  auto evt = new wxCommandEvent(EVT_AVRDUDE, this->q->GetId());
  evt->SetExtraLong(aevt);
  evt->SetString(std::move(message));
  wxQueueEvent(this->q, evt);
}

Referenced by queue_error(), queue_message(), and queue_status().

Here is the caller graph for this function:

queue_message()

template<class ... Args>

void Slic3r::FirmwareDialog::priv::queue_message ( const wxString &  format, Args...  args  )

inline

                                                                                   {
    auto message = wxString::Format(format, args...);
    BOOST_LOG_TRIVIAL(info) << message;
    message.Append('\n');
    queue_event(AE_MESSAGE, std::move(message));
  }

References Slic3r::AE_MESSAGE, Slic3r::format(), and queue_event().

Referenced by queue_error().

Here is the call graph for this function:

Here is the caller graph for this function:

queue_status()

void Slic3r::FirmwareDialog::priv::queue_status ( wxString  message )

inline

{ queue_event(AE_STATUS, std::move(message)); }

References Slic3r::AE_STATUS, and queue_event().

Here is the call graph for this function:

set_autodetect()

void Slic3r::FirmwareDialog::priv::set_autodetect

(

bool

autodetect

)

{
  port_autodetect = autodetect;
 
  port_picker->Show(!autodetect);
  btn_rescan->Show(!autodetect);
  txt_port_autodetect->Show(autodetect);
  q->Layout();
  fit_no_shrink();
}

set_txt_status()

void Slic3r::FirmwareDialog::priv::set_txt_status

(

const wxString &

label

)

{
  const auto width = txt_status->GetSize().GetWidth();
  txt_status->SetLabel(label);
  txt_status->Wrap(width);
 
  fit_no_shrink();
}

update_flash_enabled()

void Slic3r::FirmwareDialog::priv::update_flash_enabled

(

)

{
  const bool hex_exists = wxFileExists(hex_picker->GetPath());
  const bool port_valid = port_autodetect || get_serial_port();
 
  btn_flash->Enable(hex_exists && port_valid);
}

Referenced by find_serial_ports().

Here is the caller graph for this function:

user_cancel()

void Slic3r::FirmwareDialog::priv::user_cancel

(

)

{
  if (avrdude) {
    user_cancelled = true;
    avrdude->cancel();
  }
}

Member Data Documentation

avrdude

AvrDude::Ptr Slic3r::FirmwareDialog::priv::avrdude

Referenced by queue_error().

btn_close

wxButton* Slic3r::FirmwareDialog::priv::btn_close

btn_flash

wxButton* Slic3r::FirmwareDialog::priv::btn_flash

btn_flash_label_flashing

wxString Slic3r::FirmwareDialog::priv::btn_flash_label_flashing

btn_flash_label_ready

wxString Slic3r::FirmwareDialog::priv::btn_flash_label_ready

btn_rescan

wxButton* Slic3r::FirmwareDialog::priv::btn_rescan

extra_verbose

const bool Slic3r::FirmwareDialog::priv::extra_verbose

hex_file

HexFile Slic3r::FirmwareDialog::priv::hex_file

hex_picker

wxFilePickerCtrl* Slic3r::FirmwareDialog::priv::hex_picker

label_status_flashing

wxString Slic3r::FirmwareDialog::priv::label_status_flashing

min_height

int Slic3r::FirmwareDialog::priv::min_height

min_height_expanded

int Slic3r::FirmwareDialog::priv::min_height_expanded

min_width

int Slic3r::FirmwareDialog::priv::min_width

modal_response

int Slic3r::FirmwareDialog::priv::modal_response

mutex

std::mutex Slic3r::FirmwareDialog::priv::mutex

port

optional<SerialPortInfo> Slic3r::FirmwareDialog::priv::port

Referenced by find_serial_ports().

port_autodetect

bool Slic3r::FirmwareDialog::priv::port_autodetect

port_picker

wxComboBox* Slic3r::FirmwareDialog::priv::port_picker

Referenced by find_serial_ports().

ports

std::vector<SerialPortInfo> Slic3r::FirmwareDialog::priv::ports

Referenced by find_serial_ports().

progress_tasks_bar

unsigned Slic3r::FirmwareDialog::priv::progress_tasks_bar

progress_tasks_done

unsigned Slic3r::FirmwareDialog::priv::progress_tasks_done

progressbar

wxGauge* Slic3r::FirmwareDialog::priv::progressbar

q

FirmwareDialog* Slic3r::FirmwareDialog::priv::q

response_cv

std::condition_variable Slic3r::FirmwareDialog::priv::response_cv

spoiler

wxCollapsiblePane* Slic3r::FirmwareDialog::priv::spoiler

timer_pulse

wxTimer Slic3r::FirmwareDialog::priv::timer_pulse

txt_port_autodetect

wxStaticText* Slic3r::FirmwareDialog::priv::txt_port_autodetect

txt_status

wxStaticText* Slic3r::FirmwareDialog::priv::txt_status

txt_stdout

wxTextCtrl* Slic3r::FirmwareDialog::priv::txt_stdout

user_cancelled

bool Slic3r::FirmwareDialog::priv::user_cancelled

---

The documentation for this struct was generated from the following file:

• src/slic3r/GUI/FirmwareDialog.cpp