PrinterFileSystem Class Reference

#include </home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Printer/PrinterFileSystem.h>

Inheritance diagram for PrinterFileSystem:

Collaboration diagram for PrinterFileSystem:

Classes
struct	Progress
struct	File
struct	UploadFile
struct	Void
struct	Session
struct	Download
struct	Upload

Public Types
enum	{   SUCCESS = 0 , CONTINUE = 1 , ERROR_JSON = 2 , ERROR_PIPE = 3 ,   ERROR_CANCEL = 4 , ERROR_RES_BUSY = 5 , ERROR_TIME_OUT = 6 , FILE_NO_EXIST = 10 ,   FILE_NAME_INVALID = 11 , FILE_SIZE_ERR = 12 , FILE_OPEN_ERR = 13 , FILE_READ_WRITE_ERR = 14 ,   FILE_CHECK_ERR = 15 , FILE_TYPE_ERR = 16 , STORAGE_UNAVAILABLE = 17 , API_VERSION_UNSUPPORT = 18 ,   FILE_EXIST = 19 , STORAGE_SPACE_NOT_ENOUGH = 20 , FILE_CREATE_ERR = 21 , FILE_WRITE_ERR = 22 ,   MD5_COMPARE_ERR = 23 , FILE_RENAME_ERR = 24 , SEND_ERR = 25 }
enum	FileType { F_TIMELAPSE , F_VIDEO , F_MODEL , F_INVALID_TYPE }
enum	GroupMode { G_NONE , G_MONTH , G_YEAR }
enum	Flags {   FF_SELECT = 1 , FF_THUMNAIL = 2 , FF_DOWNLOAD = 4 , FF_DELETED = 8 ,   FF_FETCH_MODEL = 16 , FF_UPLOADING = 1 << 5 , FF_UPLOADDONE = 1 << 6 , FF_UPLOADCANCEL = 1 << 7 ,   FF_THUMNAIL_RETRY = 0x100 }
enum	UploadStatus { Uploading = 1 << 0 , UploadDone = 1 << 1 , UploadCancel = 1 << 2 }
enum	RequestMediaAbilityStatus { S_SUCCESS , S_FAILED }
enum	Status {   Initializing , Connecting , ListSyncing , ListReady ,   Failed , Reconnecting }
template<typename T>
using	Callback = std::function<void(int, T)>
typedef std::vector< File >	FileList
typedef std::vector< std::string >	MediaAbilityList

Public Member Functions
	PrinterFileSystem ()
	~PrinterFileSystem ()
void	SetFileType (FileType type, std::string const &storage={})
void	SetGroupMode (GroupMode mode)
size_t	EnterSubGroup (size_t index)
FileType	GetFileType () const
GroupMode	GetGroupMode () const
void	ListAllFiles ()
void	DeleteFiles (size_t index)
void	DownloadFiles (size_t index, std::string const &path)
void	GetPickImage (int id, const std::string &local_path, const std::string &path)
void	GetPickImages (const std::vector< std::string > &local_paths, const std::vector< std::string > &targetpaths)
void	DownloadRamFile (int index, const std::string &local_path, const std::string &param)
void	SendExistedFile ()
void	SendConnectFail ()
void	DownloadCheckFiles (std::string const &path)
bool	DownloadCheckFile (size_t index)
void	DownloadCancel (size_t index)
void	FetchModel (size_t index, std::function< void(int, std::string const &)> callback)
void	FetchModelCancel ()
size_t	GetCount () const
size_t	GetIndexAtTime (boost::uint32_t time)
void	ToggleSelect (size_t index)
void	SelectAll (bool select)
size_t	GetSelectCount () const
void	SetFocusRange (size_t start, size_t count)
File const &	GetFile (size_t index)
File const &	GetFile (size_t index, bool &select)
Status	GetStatus () const
int	GetLastError () const
void	Attached ()
void	Start ()
void	Retry ()
void	SetUrl (std::string const &url)
void	Stop (bool quit=false)
boost::uint32_t	RequestMediaAbility (int api_version)
void	RequestUploadFile ()
MediaAbilityList	GetMediaAbilityList () const
void	SetUploadFile (const std::string &path, const std::string &name, const std::string &select_storage)
void	CancelUploadTask (bool send_cancel_req=true)

Protected Attributes
FileType	m_file_type = F_INVALID_TYPE
std::string	m_file_storage
GroupMode	m_group_mode = G_NONE
FileList	m_file_list
std::map< std::pair< FileType, std::string >, FileList >	m_file_list_cache
std::vector< size_t >	m_group_year
std::vector< size_t >	m_group_month
std::vector< int >	m_group_flags
std::shared_ptr< UploadFile >	m_upload_file

Private Types
enum	{   LIST_INFO = 0x0001 , SUB_FILE = 0x0002 , FILE_DEL = 0x0003 , FILE_DOWNLOAD = 0x0004 ,   FILE_UPLOAD = 0x0005 , REQUEST_MEDIA_ABILITY = 0x0007 , NOTIFY_FIRST = 0x0100 , LIST_CHANGE_NOTIFY = 0x0100 ,   LIST_RESYNC_NOTIFY = 0x0101 , TASK_CANCEL = 0x1000 }
template<typename T>
using	Translator = std::function<int(nlohmann::json const &, T &, unsigned char const *)>
typedef std::function< void(int, nlohmann::json const &resp)>	callback_t
typedef std::function< int(int, nlohmann::json const &resp, unsigned char const *data)>	callback_t2
typedef std::function< int(std::string &msg)>	callback_t3
template<typename T>
using	Applier = std::function<void(T const &)>

Private Member Functions
void	BuildGroups ()
void	UpdateGroupSelect ()
void	DeleteFilesContinue ()
void	DownloadNextFile ()
void	UpdateFocusThumbnail ()
void	UpdateFocusThumbnail2 (std::shared_ptr< std::vector< File > > files, int type)
void	FileRemoved (std::pair< FileType, std::string > type, size_t index, std::string const &name, bool by_path)
std::pair< FileList &, size_t >	FindFile (std::pair< FileType, std::string > type, size_t index, std::string const &name, bool by_path)
void	SendChangedEvent (wxEventType type, size_t index=(size_t) -1, std::string const &str={}, long extra=0)
template<typename T>
boost::uint32_t	SendRequest (int type, nlohmann::json const &req, Translator< T > const &translator, Callback< T > const &callback, const std::string &param="")
template<typename T>
void	InstallNotify (int type, Translator< T > const &translator, Applier< T > const &applier)
boost::uint32_t	SendRequest (int type, nlohmann::json const &req, callback_t2 const &callback, const std::string &param="")
void	InstallNotify (int type, callback_t2 const &callback)
void	CancelRequest (boost::uint32_t seq)
void	CancelRequests (std::vector< boost::uint32_t > const &seqs)
void	CancelRequests2 (std::vector< boost::uint32_t > const &seqs)
void	RecvMessageThread ()
void	HandleResponse (boost::unique_lock< boost::mutex > &l, Bambu_Sample const &sample)
void	Reconnect (boost::unique_lock< boost::mutex > &l, int result)
template<typename T>
void	PostCallback (Callback< T > const &callback, int result, T const &resp)
void	PostCallback (std::function< void(void)> const &callback)
int	UploadFileTask (std::shared_ptr< UploadFile > upload_file, boost::uint64_t seq, std::string &msg)

Static Private Member Functions
static bool	ParseThumbnail (File &file)
static bool	ParseThumbnail (File &file, std::istream &is)
static void	DumpLog (void *context, int level, tchar const *msg)

Private Attributes
size_t	m_select_count = 0
size_t	m_lock_start = 0
size_t	m_lock_end = 0
int	m_task_flags = 0
std::vector< bool >	m_download_states
Session	m_session
boost::uint32_t	m_sequence = 0
boost::uint32_t	m_download_seq = 0
boost::uint32_t	m_fetch_model_seq = 0
boost::uint32_t	m_upload_seq = 0
std::deque< std::string >	m_messages
std::deque< callback_t2 >	m_callbacks
std::deque< callback_t2 >	m_notifies
bool	m_stopped = true
boost::mutex	m_mutex
boost::condition_variable	m_cond
boost::thread	m_recv_thread
Status	m_status
int	m_last_error = 0
MediaAbilityList	m_media_ability_list
std::map< boost::uint32_t, callback_t3 >	m_produce_message_cb_map

Static Private Attributes
static const int	CTRL_TYPE = 0x3001

Detailed Description

---

Class Documentation

PrinterFileSystem::Void

struct PrinterFileSystem::Void

PrinterFileSystem::Session

struct PrinterFileSystem::Session

Collaboration diagram for PrinterFileSystem::Session:

Class Members
PrinterFileSystem *	owner
Bambu_Tunnel	tunnel = nullptr

Member Typedef Documentation

Applier

template<typename T>

using PrinterFileSystem::Applier = std::function<void(T const &)>

private

Callback

template<typename T>

using PrinterFileSystem::Callback = std::function<void(int, T)>

callback_t

typedef std::function<void(int, nlohmann::json const & resp)> PrinterFileSystem::callback_t

private

callback_t2

typedef std::function<int(int, nlohmann::json const &resp, unsigned char const *data)> PrinterFileSystem::callback_t2

private

callback_t3

typedef std::function<int(std::string &msg)> PrinterFileSystem::callback_t3

private

FileList

typedef std::vector<File> PrinterFileSystem::FileList

MediaAbilityList

typedef std::vector<std::string> PrinterFileSystem::MediaAbilityList

Translator

template<typename T>

using PrinterFileSystem::Translator = std::function<int(nlohmann::json const &, T &, unsigned char const *)>

private

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Enumerator
LIST_INFO
SUB_FILE
FILE_DEL
FILE_DOWNLOAD
FILE_UPLOAD
REQUEST_MEDIA_ABILITY
NOTIFY_FIRST
LIST_CHANGE_NOTIFY
LIST_RESYNC_NOTIFY
TASK_CANCEL

         {
        LIST_INFO             = 0x0001,
        SUB_FILE              = 0x0002,
        FILE_DEL              = 0x0003,
        FILE_DOWNLOAD         = 0x0004,
        FILE_UPLOAD           = 0x0005,
        REQUEST_MEDIA_ABILITY = 0x0007,
        NOTIFY_FIRST          = 0x0100,
        LIST_CHANGE_NOTIFY    = 0x0100,
        LIST_RESYNC_NOTIFY    = 0x0101,
        TASK_CANCEL           = 0x1000
    };

anonymous enum

anonymous enum

Enumerator
SUCCESS
CONTINUE
ERROR_JSON
ERROR_PIPE
ERROR_CANCEL
ERROR_RES_BUSY
ERROR_TIME_OUT
FILE_NO_EXIST
FILE_NAME_INVALID
FILE_SIZE_ERR
FILE_OPEN_ERR
FILE_READ_WRITE_ERR
FILE_CHECK_ERR
FILE_TYPE_ERR
STORAGE_UNAVAILABLE
API_VERSION_UNSUPPORT
FILE_EXIST
STORAGE_SPACE_NOT_ENOUGH
FILE_CREATE_ERR
FILE_WRITE_ERR
MD5_COMPARE_ERR
FILE_RENAME_ERR
SEND_ERR

         {
        SUCCESS                  = 0,
        CONTINUE                 = 1,
        ERROR_JSON               = 2,
        ERROR_PIPE               = 3,
        ERROR_CANCEL             = 4,
        ERROR_RES_BUSY           = 5,
        ERROR_TIME_OUT           = 6,
        FILE_NO_EXIST            = 10,
        FILE_NAME_INVALID        = 11,
        FILE_SIZE_ERR            = 12,
        FILE_OPEN_ERR            = 13,
        FILE_READ_WRITE_ERR      = 14,
        FILE_CHECK_ERR           = 15,
        FILE_TYPE_ERR            = 16,
        STORAGE_UNAVAILABLE      = 17,
        API_VERSION_UNSUPPORT    = 18,
        FILE_EXIST               = 19,
        STORAGE_SPACE_NOT_ENOUGH = 20,
        FILE_CREATE_ERR          = 21,
        FILE_WRITE_ERR           = 22,
        MD5_COMPARE_ERR          = 23,
        FILE_RENAME_ERR          = 24,
        SEND_ERR                 = 25,
    };

FileType

enum PrinterFileSystem::FileType

Enumerator
F_TIMELAPSE
F_VIDEO
F_MODEL
F_INVALID_TYPE

                  {
        F_TIMELAPSE,
        F_VIDEO,
        F_MODEL,
        F_INVALID_TYPE,
    };

Flags

enum PrinterFileSystem::Flags

Enumerator
FF_SELECT
FF_THUMNAIL
FF_DOWNLOAD
FF_DELETED
FF_FETCH_MODEL
FF_UPLOADING
FF_UPLOADDONE
FF_UPLOADCANCEL
FF_THUMNAIL_RETRY

               {
        FF_SELECT         = 1,
        FF_THUMNAIL       = 2,      // Thumbnail ready
        FF_DOWNLOAD       = 4,      // Request download
        FF_DELETED        = 8,      // Request delete
        FF_FETCH_MODEL    = 16,     // Request model
        FF_UPLOADING      = 1 << 5, // File uploading
        FF_UPLOADDONE     = 1 << 6, // File upload done
        FF_UPLOADCANCEL   = 1 << 7, // File upload cancel
        FF_THUMNAIL_RETRY = 0x100,  // Thumbnail need retry
    };

GroupMode

enum PrinterFileSystem::GroupMode

Enumerator
G_NONE
G_MONTH
G_YEAR

                   {
        G_NONE,
        G_MONTH,
        G_YEAR,
    };

RequestMediaAbilityStatus

enum PrinterFileSystem::RequestMediaAbilityStatus

Enumerator
S_SUCCESS
S_FAILED

    {
        S_SUCCESS,
        S_FAILED
    };

Status

enum PrinterFileSystem::Status

Enumerator
Initializing
Connecting
ListSyncing
ListReady
Failed
Reconnecting

                {
        Initializing,
        Connecting,
        ListSyncing,
        ListReady,
        Failed,
        Reconnecting,
    };

UploadStatus

enum PrinterFileSystem::UploadStatus

Enumerator
Uploading
UploadDone
UploadCancel

    {
        Uploading = 1 << 0,
        UploadDone = 1 << 1,
        UploadCancel = 1 << 2,
    };

Constructor & Destructor Documentation

PrinterFileSystem()

PrinterFileSystem::PrinterFileSystem

(

)

    : BambuLib(StaticBambuLib::get(this))
{
    if (!default_thumbnail.IsOk()) {
        default_thumbnail = *Slic3r::GUI::BitmapCache().load_svg("printer_file", 0, 0);
#ifdef __APPLE__
        default_thumbnail = wxBitmap(default_thumbnail.ConvertToImage(), -1, 1);
#endif
    }
    m_session.owner = this;
#ifdef PRINTER_FILE_SYSTEM_TEST
    auto time = wxDateTime::Now();
    wxString path = "D:\\work\\pic\\";
    for (int i = 0; i < 10; ++i) {
        auto name = wxString::Format(L"gcode-%02d.3mf", i + 1);
        m_file_list.push_back({name.ToUTF8().data(), "", time.GetTicks(), 26937, i < 5 ? FF_DOWNLOAD : 0, default_thumbnail});
        std::ifstream ifs((path + name).ToUTF8().data(), std::ios::binary);
        if (ifs)
            ParseThumbnail(m_file_list.back(), ifs);
        time.Add(wxDateSpan::Days(-1));
    }
    m_file_list.swap(m_file_list_cache[{F_MODEL, ""}]);
    time = wxDateTime::Now();
    for (int i = 0; i < 100; ++i) {
        auto name = wxString::Format(L"img-%03d.jpg", i + 1);
        wxImage im(path + name);
        m_file_list.push_back({name.ToUTF8().data(), "", time.GetTicks(), 26937, i < 20 ? FF_DOWNLOAD : 0, i > 3 ? im : default_thumbnail});
        time.Add(wxDateSpan::Days(-1));
    }
    m_file_list[0].thumbnail = default_thumbnail;
    m_file_list.swap(m_file_list_cache[{F_TIMELAPSE, ""}]);
#endif
}

References default_thumbnail, F_MODEL, F_TIMELAPSE, FF_DOWNLOAD, L, m_file_list, m_file_list_cache, m_session, and ParseThumbnail().

Referenced by DumpLog().

Here is the call graph for this function:

Here is the caller graph for this function:

~PrinterFileSystem()

PrinterFileSystem::~PrinterFileSystem

(

)

{
    m_recv_thread.detach();
}

References m_recv_thread.

Member Function Documentation

Attached()

void PrinterFileSystem::Attached

(

)

{
    boost::unique_lock lock(m_mutex);
    m_recv_thread = boost::thread([w = weak_from_this()] {
        boost::shared_ptr<PrinterFileSystem> s = w.lock();
        if (s) s->RecvMessageThread();
    });
}

References m_mutex, and m_recv_thread.

BuildGroups()

void PrinterFileSystem::BuildGroups ( )

private

{
    m_group_year.clear();
    m_group_month.clear();
    if (m_file_list.empty())
        return;
    wxDateTime t = wxDateTime((time_t) m_file_list.front().time);
    m_group_year.push_back(0);
    m_group_month.push_back(0);
    for (size_t i = 0; i < m_file_list.size(); ++i) {
        wxDateTime s = wxDateTime((time_t) m_file_list[i].time);
        if (s.GetYear() != t.GetYear()) {
            m_group_year.push_back(m_group_month.size());
            m_group_month.push_back(i);
        } else if (s.GetMonth() != t.GetMonth()) {
            m_group_month.push_back(i);
        }
        t = s;
    }
}

References m_file_list, m_group_month, and m_group_year.

Referenced by ListAllFiles(), and SetFileType().

Here is the caller graph for this function:

CancelRequest()

void PrinterFileSystem::CancelRequest ( boost::uint32_t seq )

private

{ CancelRequests({seq}); }

References CancelRequests().

Referenced by CancelUploadTask(), DownloadCancel(), and HandleResponse().

Here is the call graph for this function:

Here is the caller graph for this function:

CancelRequests()

void PrinterFileSystem::CancelRequests ( std::vector< boost::uint32_t > const & seqs )

private

{
    json req;
    json arr;
    for (auto seq : seqs)
        arr.push_back(seq);
    req["tasks"] = arr;
    SendRequest(TASK_CANCEL, req, [this](int result, json const &resp, unsigned char const *) -> int {
        if (result != 0) return result;
        json tasks = resp["tasks"];
        std::vector<boost::uint32_t> seqs;
        for (auto &f : tasks) seqs.push_back(f);
        CancelRequests2(seqs);
        return 0;
    });
}

References CancelRequests2(), SendRequest(), and TASK_CANCEL.

Referenced by CancelRequest().

Here is the call graph for this function:

Here is the caller graph for this function:

CancelRequests2()

void PrinterFileSystem::CancelRequests2 ( std::vector< boost::uint32_t > const & seqs )

private

{
    std::vector<std::pair<boost::uint32_t, callback_t2>> callbacks;
    boost::unique_lock      l(m_mutex);
    for (auto &f : seqs) {
        boost::uint32_t seq = f;
        seq -= m_sequence;
        if (size_t(seq) >= m_callbacks.size()) continue;
        auto &c = m_callbacks[seq];
        if (c == nullptr) continue;
        callbacks.emplace_back(f, c);
        c = nullptr;
 
        // erase m_produce_message_cb
        if (m_produce_message_cb_map.find(seq) != m_produce_message_cb_map.end())
            m_produce_message_cb_map.erase(seq);
    }
    while (!m_callbacks.empty() && m_callbacks.front() == nullptr) {
        m_callbacks.pop_front();
        ++m_sequence;
    }
    l.unlock();
    for (auto &c : callbacks) {
        wxLogInfo("PrinterFileSystem::CancelRequests2: %u\n", c.first);
        c.second(ERROR_CANCEL, json(), nullptr);
    }
}

References ERROR_CANCEL, m_callbacks, m_mutex, m_produce_message_cb_map, and m_sequence.

Referenced by CancelRequests(), CancelUploadTask(), and FetchModelCancel().

Here is the caller graph for this function:

CancelUploadTask()

void PrinterFileSystem::CancelUploadTask

(

bool

send_cancel_req = true

)

{
    if (!m_upload_file)
        return;
 
    {
        boost::unique_lock l(m_mutex);
        if (m_produce_message_cb_map.find(m_upload_seq) != m_produce_message_cb_map.end())
            m_produce_message_cb_map.erase(m_upload_seq);
        if (m_upload_file->upload->ifs.is_open()) {
            m_upload_file->upload->ifs.close();
        }
        m_upload_file.reset();
    }
 
    if (send_cancel_req) {
        CancelRequest(m_upload_seq);
    } else {
        CancelRequests2({m_upload_seq});
    }
}

References CancelRequest(), CancelRequests2(), m_mutex, m_produce_message_cb_map, m_upload_file, and m_upload_seq.

Here is the call graph for this function:

DeleteFiles()

void PrinterFileSystem::DeleteFiles

(

size_t

index

)

{
    if (index == size_t(-1)) {
        size_t n = 0;
        for (size_t i = 0; i < m_file_list.size(); ++i) {
            auto &file = m_file_list[i];
            if ((file.flags & FF_SELECT) != 0 && (file.flags & FF_DELETED) == 0) {
                file.flags |= FF_DELETED;
                ++n;
            }
        }
        if (n == 0) return;
    } else {
        if (index >= m_file_list.size())
            return;
        auto &file = m_file_list[index];
        if ((file.flags & FF_DELETED) != 0)
            return;
        file.flags |= FF_DELETED;
    }
    if ((m_task_flags & FF_DELETED) == 0)
        DeleteFilesContinue();
}

References DeleteFilesContinue(), FF_DELETED, FF_SELECT, m_file_list, and m_task_flags.

Here is the call graph for this function:

DeleteFilesContinue()

void PrinterFileSystem::DeleteFilesContinue ( )

private

{
    std::vector<size_t> indexes;
    std::vector<std::string> names;
    std::vector<std::string> paths;
    for (size_t i = 0; i < m_file_list.size(); ++i)
        if ((m_file_list[i].flags & FF_DELETED) && !m_file_list[i].name.empty()) {
            indexes.push_back(i);
            auto &file = m_file_list[i];
            if (file.path.empty())
                names.push_back(file.name);
            else
                paths.push_back(file.path);
            if (names.size() >= 64 || paths.size() >= 64)
                break;
        }
    m_task_flags &= ~FF_DELETED;
    if (names.empty() && paths.empty())
        return;
    json req;
    json arr;
    if (paths.empty()) {
        for (auto &name : names) arr.push_back(name);
        req["delete"] = arr;
    } else {
        for (auto &path : paths) arr.push_back(path);
        req["paths"] = arr;
    }
    m_task_flags |= FF_DELETED;
    auto type = std::make_pair(m_file_type, m_file_storage);
    SendRequest<Void>(
        FILE_DEL, req, nullptr,
        [indexes, type, names = paths.empty() ? names : paths, bypath = !paths.empty(), this](int, Void const &) {
            // TODO:
            for (size_t i = indexes.size() - 1; i != size_t(-1); --i)
                FileRemoved(type, indexes[i], names[i], bypath);
            SendChangedEvent(EVT_FILE_CHANGED, indexes.size());
            DeleteFilesContinue();
        });
}

References FF_DELETED, FILE_DEL, m_file_list, m_file_storage, m_file_type, m_task_flags, and SendRequest().

Referenced by DeleteFiles().

Here is the call graph for this function:

Here is the caller graph for this function:

DownloadCancel()

void PrinterFileSystem::DownloadCancel

(

size_t

index

)

{
    if (index == (size_t) -1) return;
    if (index >= m_file_list.size()) return;
    auto &file = m_file_list[index];
    if ((file.flags & FF_DOWNLOAD) == 0 || !file.download) return;
    if (file.DownloadProgress() >= 0)
        CancelRequest(m_download_seq);
    else
        file.flags &= ~FF_DOWNLOAD, file.download.reset();
}

References CancelRequest(), FF_DOWNLOAD, m_download_seq, and m_file_list.

Here is the call graph for this function:

DownloadCheckFile()

bool PrinterFileSystem::DownloadCheckFile

(

size_t

index

)

{
    if (index >= m_file_list.size()) return false;
    auto &file = m_file_list[index];
    if ((file.flags & FF_DOWNLOAD) == 0 || file.local_path.empty())
        return false;
    if (!boost::filesystem::exists(file.local_path)) {
        file.flags &= ~FF_DOWNLOAD;
        file.local_path.clear();
        SendChangedEvent(EVT_DOWNLOAD, index, file.local_path);
        return false;
    }
    return true;
}

References FF_DOWNLOAD, m_file_list, and SendChangedEvent().

Here is the call graph for this function:

DownloadCheckFiles()

void PrinterFileSystem::DownloadCheckFiles

(

std::string const &

path

)

{
    for (size_t i = 0; i < m_file_list.size(); ++i) {
        auto &file = m_file_list[i];
        if ((file.flags & FF_DOWNLOAD) != 0 && file.download) continue;
        auto path2 = boost::filesystem::path(path) / file.name;
        boost::system::error_code ec;
        if (boost::filesystem::file_size(path2, ec) == file.size) {
            file.flags |= FF_DOWNLOAD;
            file.local_path = path2.string();
        }
    }
}

References FF_DOWNLOAD, and m_file_list.

DownloadFiles()

void PrinterFileSystem::DownloadFiles	(	size_t	index,
		std::string const &	path )

{
    if (index == (size_t) -1) {
        size_t n = 0;
        for (size_t i = 0; i < m_file_list.size(); ++i) {
            auto &file = m_file_list[i];
            if ((file.flags & FF_SELECT) == 0) continue;
            if ((file.flags & FF_DOWNLOAD) != 0 && file.DownloadProgress() >= -1) continue;
            file.flags |= FF_DOWNLOAD;
            std::shared_ptr<Download> download(new Download);
            download->progress = -1;
            download->local_path = (boost::filesystem::path(path) / file.name).string();
            file.download = download;
            ++n;
        }
        if (n == 0) return;
    } else {
        if (index >= m_file_list.size())
            return;
        auto &file = m_file_list[index];
        if ((file.flags & FF_DOWNLOAD) != 0 && file.DownloadProgress() >= -1)
            return;
        file.flags |= FF_DOWNLOAD;
        std::shared_ptr<Download> download(new Download);
        download->progress   = -1;
        download->local_path = (boost::filesystem::path(path) / file.name).string();
        file.download        = download;
    }
    boost::filesystem::create_directories(path);
    if ((m_task_flags & FF_DOWNLOAD) == 0)
        DownloadNextFile();
}

References DownloadNextFile(), FF_DOWNLOAD, FF_SELECT, m_file_list, and m_task_flags.

Here is the call graph for this function:

DownloadNextFile()

void PrinterFileSystem::DownloadNextFile ( )

private

{
    size_t index = size_t(-1);
    for (size_t i = 0; i < m_file_list.size(); ++i) {
        if (m_file_list[i].IsDownload() && m_file_list[i].DownloadProgress() == -1) {
            index = i;
            break;
        }
    }
    m_task_flags &= ~FF_DOWNLOAD;
    if (index >= m_file_list.size())
        return;
    auto &file = m_file_list[index];
    json req;
    if (file.path.empty())
        req["file"] = file.name;
    else
        req["path"] = file.path;
    SendChangedEvent(EVT_DOWNLOAD, index, m_file_list[index].name);
    std::shared_ptr<Download> download(m_file_list[index].download);
    download->index = index;
    download->name = file.name;
    download->path = file.path;
    m_task_flags |= FF_DOWNLOAD;
    m_download_seq = SendRequest<Progress>(
        FILE_DOWNLOAD, req,
        [download](json const &resp, Progress &prog, unsigned char const *data) -> int {
            // in work thread, continue recv
            size_t size = resp.value("size", 0);
            prog.size   = resp["offset"];
            prog.total  = resp["total"];
            if (prog.size == 0) {
                download->ofs.open(download->local_path, std::ios::binary);
                if (!download->ofs) {
                    download->error = last_system_error();
                    wxLogWarning("PrinterFileSystem::DownloadNextFile open error: %s\n", wxString::FromUTF8(download->error));
                    return FILE_OPEN_ERR;
                }
            }
            if (download->total && (download->size != prog.size || download->total != prog.total)) {
                wxLogWarning("PrinterFileSystem::DownloadNextFile data error: %d != %d\n", download->size, prog.size);
            }
            // receive data
            download->ofs.write((char const *) data, size);
            if (!download->ofs) {
                download->error = last_system_error();
                wxLogWarning("PrinterFileSystem::DownloadNextFile write error: %s\n", wxString::FromUTF8(download->error));
                return FILE_READ_WRITE_ERR;
            }
            download->boost_md5.process_bytes(data, size);
            prog.size += size;
            download->total = prog.total;
            download->size = prog.size;
            if (prog.size < prog.total) { return 0; }
            download->ofs.close();
            int         result = 0;
            std::string md5    = resp["file_md5"];
            // check size and md5
            if (prog.size == prog.total) {
                boost::uuids::detail::md5::digest_type digest;
                download->boost_md5.get_digest(digest);
                for (int i = 0; i < 4; ++i) digest[i] = boost::endian::endian_reverse(digest[i]);
                std::string str_md5;
                const auto  char_digest = reinterpret_cast<const char *>(&digest[0]);
                boost::algorithm::hex(char_digest, char_digest + sizeof(digest), std::back_inserter(str_md5));
                if (!boost::iequals(str_md5, md5)) {
                    wxLogWarning("PrinterFileSystem::DownloadNextFile checksum error: %s != %s\n", str_md5, md5);
                    boost::system::error_code ec;
                    boost::filesystem::rename(download->local_path, download->local_path + ".tmp", ec);
                    result = FILE_CHECK_ERR;
                }
            } else {
                result = FILE_SIZE_ERR;
            }
            if (result != 0) {
                boost::system::error_code ec;
                boost::filesystem::remove(download->local_path, ec);
            }
            return result;
        },
        [this, download, type = std::make_pair(m_file_type, m_file_storage)](int result, Progress const &data) {
            int progress = data.total ? data.size * 100 / data.total : 0;
            if (result == CONTINUE) {
                if (download->progress == progress)
                    return;
            }
            download->progress = progress;
            if (download->index != size_t(-1)) {
                auto file_index = FindFile(type, download->index, download->path.empty() ? download->name : download->path, !download->path.empty());
                download->index = file_index.second;
                if (download->index != size_t(-1)) {
                    auto &file = file_index.first[download->index];
                    if (result == CONTINUE)
                        ;
                    else if (result == SUCCESS)
                        file.download.reset(), file.local_path = download->local_path;
                    else if (result == ERROR_CANCEL)
                        file.download.reset(), file.flags &= ~FF_DOWNLOAD;
                    else // FAILED
                        file.download.reset();
                    if (&file_index.first == &m_file_list)
                        SendChangedEvent(EVT_DOWNLOAD, download->index, result ? download->error : file.local_path, result);
                }
            }
            if (result != CONTINUE) DownloadNextFile();
        });
}

References CONTINUE, DownloadNextFile(), ERROR_CANCEL, FF_DOWNLOAD, FILE_CHECK_ERR, FILE_DOWNLOAD, FILE_OPEN_ERR, FILE_READ_WRITE_ERR, FILE_SIZE_ERR, FindFile(), last_system_error(), m_download_seq, m_file_list, m_file_storage, m_file_type, m_task_flags, SendChangedEvent(), SendRequest(), PrinterFileSystem::Progress::size, SUCCESS, and PrinterFileSystem::Progress::total.

Referenced by DownloadFiles(), DownloadNextFile(), and ListAllFiles().

Here is the call graph for this function:

Here is the caller graph for this function:

DownloadRamFile()

void PrinterFileSystem::DownloadRamFile	(	int	index,
		const std::string &	local_path,
		const std::string &	param )

{
    std::shared_ptr<Download> download(new Download);
    download->local_path = local_path;
 
    json req;
    req["path"]              = "mem:/" + std::to_string(index);
    req["offset"] = 0;
    req["mem_dl_param_size"] = param.size();
 
    m_download_seq = SendRequest<Progress>(
        FILE_DOWNLOAD, req,
        [download](json const &resp, Progress &prog, unsigned char const *data) -> int {
            size_t size = resp.value("size", 0);
            prog.size   = resp["offset"];
            prog.total  = resp["total"];
 
            if (resp.contains("mem_dl_param_size")) {
                size_t s = resp["mem_dl_param_size"].get<size_t>();
                std::string json_str(reinterpret_cast<const char *>(data), s);
                // OutputDebugStringA(json_str.c_str());
                // OutputDebugStringA("\n");
                json        mem_dl_json = json::parse(json_str);
                //  download->mem_dl_param_size = size;
                if (!mem_dl_json.contains("result") || mem_dl_json["result"] == 1 ) {
                        wxLogWarning("Download failed: result = 1");
                    return ERROR_JSON;
                    }
                if(mem_dl_json.contains("size") && mem_dl_json["size"] == 0 )
                    return FILE_SIZE_ERR;
 
                return CONTINUE;
            }
 
            if (prog.size == 0 ) {
                download->ofs.open(download->local_path, std::ios::binary);
                if (!download->ofs) {
                    download->error = last_system_error();
                    wxLogWarning("DownloadImageFromRam open error: %s\n", wxString::FromUTF8(download->error));
                    return FILE_OPEN_ERR;
                }
            }
 
            download->ofs.write(reinterpret_cast<const char *>(data), size);
            if (!download->ofs) {
                download->error = last_system_error();
                wxLogWarning("DownloadImageFromRam write error: %s\n", wxString::FromUTF8(download->error));
                return FILE_READ_WRITE_ERR;
            }
 
            download->boost_md5.process_bytes(data, size);
 
            prog.size += size;
            download->total = prog.total;
            download->size  = prog.size;
 
            if (prog.size < prog.total) {
                return 0;
            }
            download->ofs.close();
 
            std::string                     md5 = resp["file_md5"];
            boost::uuids::detail::md5::digest_type digest;
            download->boost_md5.get_digest(digest);
            for (int i = 0; i < 4; ++i) digest[i] = boost::endian::endian_reverse(digest[i]);
            std::string str_md5;
            const auto  char_digest = reinterpret_cast<const char *>(&digest[0]);
            boost::algorithm::hex(char_digest, char_digest + sizeof(digest), std::back_inserter(str_md5));
            if (!boost::iequals(str_md5, md5)) {
                wxLogWarning("DownloadImageFromRam checksum error: %s != %s\n", str_md5, md5);
                boost::system::error_code ec;
                boost::filesystem::rename(download->local_path, download->local_path + ".tmp", ec);
                return FILE_CHECK_ERR;
            }
            return SUCCESS;
        },
 
        [this, download](int result, Progress const &data) {
            //OutputDebugStringA(std::to_string(result).c_str());
            //OutputDebugStringA("\n");
            if (result == CONTINUE) { return; }
            std::string msg;
            if (result == SUCCESS) {
                if (std::filesystem::exists(download->local_path)) {
                    m_download_states.emplace_back(true);
                    BOOST_LOG_TRIVIAL(info) <<"DownloadImageFromRam finished: " << download->local_path << "result = " << result;
                }else{
                    m_download_states.emplace_back(false);
                    BOOST_LOG_TRIVIAL(warning) <<"DownloadImageFromRam finished, but file not exist: " << download->local_path << "result = " << result;
                }
            } else if (result != CONTINUE) {
                m_download_states.emplace_back(false);
                BOOST_LOG_TRIVIAL(warning) << "DownloadImageFromRam failed: " << download->error << "result = " << result;
            }
 
            if(m_download_states.size() == 3){
                if(m_download_states[0] && m_download_states[1] && m_download_states[2]){
                    SendChangedEvent(EVT_RAMDOWNLOAD, SUCCESS);
                }else{
                    // FILE_NO_EXIST is not really error_code
                    SendChangedEvent(EVT_RAMDOWNLOAD, FILE_NO_EXIST);
                }
            }else{
                 BOOST_LOG_TRIVIAL(warning) << "m_download_states current size is : " << m_download_states.size();
            }
        },param);
}

References CONTINUE, ERROR_JSON, FILE_CHECK_ERR, FILE_DOWNLOAD, FILE_NO_EXIST, FILE_OPEN_ERR, FILE_READ_WRITE_ERR, FILE_SIZE_ERR, last_system_error(), m_download_seq, m_download_states, SendChangedEvent(), SendRequest(), PrinterFileSystem::Progress::size, SUCCESS, and PrinterFileSystem::Progress::total.

Referenced by GetPickImage().

Here is the call graph for this function:

Here is the caller graph for this function:

DumpLog()

void PrinterFileSystem::DumpLog ( void * context, int level, tchar const * msg )

staticprivate

{
 
#if !BBL_RELEASE_TO_PUBLIC
    BOOST_LOG_TRIVIAL(info) << "PrinterFileSystem: " << wxString(msg).ToUTF8().data();
#endif
 
    static_cast<PrinterFileSystem*>(thiz)->Bambu_FreeLogMsg(msg);
}

References PrinterFileSystem(), and Bambu_FreeLogMsg().

Referenced by Reconnect().

Here is the call graph for this function:

Here is the caller graph for this function:

EnterSubGroup()

size_t PrinterFileSystem::EnterSubGroup

(

size_t

index

)

{
    if (m_group_mode == G_NONE)
        return index;
    index = m_group_mode == G_YEAR ? m_group_year[index] : m_group_month[index];
    SetGroupMode((GroupMode)(m_group_mode - 1));
    return index;
}

References G_NONE, G_YEAR, m_group_mode, m_group_month, m_group_year, and SetGroupMode().

Here is the call graph for this function:

FetchModel()

void PrinterFileSystem::FetchModel	(	size_t	index,
		std::function< void(int, std::string const &)>	callback )

{
    if (m_task_flags & FF_FETCH_MODEL)
        return;
    json req;
    json arr;
    if (index == (size_t) -1) return;
    if (index >= m_file_list.size()) return;
    auto &file = m_file_list[index];
    arr.push_back(file.path + "#_rels/.rels");
    arr.push_back(file.path + "#3D/3dmodel.model");
    arr.push_back(file.path + "#Metadata/model_settings.config");
    arr.push_back(file.path + "#Metadata/slice_info.config");
    arr.push_back(file.path + "#Metadata/project_settings.config");
    for (auto & meta : file.metadata) {
        if (boost::algorithm::starts_with(meta.first, "plate_thumbnail_"))
            arr.push_back(file.path + "#" + meta.second);
    }
    req["paths"] = arr;
    req["zip"] = true;
    m_task_flags |= FF_FETCH_MODEL;
    std::shared_ptr<std::string> file_data(new std::string());
    m_fetch_model_seq = SendRequest<Void>(
        SUB_FILE, req,
        [file_data](json const &resp, Void &, unsigned char const *data) -> int {
            // in work thread, continue recv
            // receive data
            boost::uint32_t size      = resp["size"];
            if (size > 0) {
                *file_data += std::string((char *) data, size);
            }
            return 0;
        },
        [this, file_data, callback](int result, Void const &) {
            if (result == CONTINUE) return;
            m_task_flags &= ~FF_FETCH_MODEL;
            if (result != 0) {
                auto iter = error_messages.find(result);
                if (iter != error_messages.end())
                    *file_data = _u8L(iter->second.c_str());
                else
                    file_data->clear();
            }
            callback(result, *file_data);
        });
}

References _u8L, CONTINUE, error_messages, FF_FETCH_MODEL, m_fetch_model_seq, m_file_list, m_task_flags, SendRequest(), and SUB_FILE.

Here is the call graph for this function:

FetchModelCancel()

void PrinterFileSystem::FetchModelCancel

(

)

{
    if ((m_task_flags & FF_FETCH_MODEL) == 0) return;
    CancelRequests2({m_fetch_model_seq});
}

References CancelRequests2(), FF_FETCH_MODEL, m_fetch_model_seq, and m_task_flags.

Here is the call graph for this function:

FileRemoved()

void PrinterFileSystem::FileRemoved ( std::pair< FileType, std::string > type, size_t index, std::string const & name, bool by_path )

private

{
    auto file_index = FindFile(type, index, name, by_path);
    if (file_index.second == size_t(-1))
        return;
    if (&file_index.first == &m_file_list) {
        auto removeFromGroup = [](std::vector<size_t> &group, size_t index, size_t total) {
            for (auto iter = group.begin(); iter != group.end(); ++iter) {
                size_t index2 = -1;
                if (*iter < index) continue;
                if (*iter == index) {
                    auto iter2 = iter + 1;
                    if (index + 1 == (iter2 == group.end() ? total : *iter2)) {
                        index2 = std::distance(group.begin(), iter);
                    }
                    ++iter;
                }
                for (; iter != group.end(); ++iter) {
                    --*iter;
                }
                return index2;
            }
            return size_t(-1);
        };
        size_t index2 = removeFromGroup(m_group_month, index, m_file_list.size());
        if (index2 < m_group_month.size()) {
            int index3 = removeFromGroup(m_group_year, index2, m_group_month.size());
            if (index3 < m_group_year.size()) {
                m_group_year.erase(m_group_year.begin() + index3);
                if (m_group_mode == G_YEAR)
                    m_group_flags.erase(m_group_flags.begin() + index3);
            }
            m_group_month.erase(m_group_month.begin() + index2);
            if (m_group_mode == G_MONTH)
                m_group_flags.erase(m_group_flags.begin() + index2);
        }
    }
    file_index.first.erase(file_index.first.begin() + index);
}

References FindFile(), G_MONTH, G_YEAR, m_file_list, m_group_flags, m_group_mode, m_group_month, and m_group_year.

Here is the call graph for this function:

FindFile()

std::pair< PrinterFileSystem::FileList &, size_t > PrinterFileSystem::FindFile ( std::pair< FileType, std::string > type, size_t index, std::string const & name, bool by_path )

private

{
    FileList & file_list = type == std::make_pair(m_file_type, m_file_storage) ?
                               m_file_list :
                               m_file_list_cache[type];
    if (index >= file_list.size() || (by_path ? file_list[index].path : file_list[index].name) != name) {
        auto iter = std::find_if(m_file_list.begin(), file_list.end(),
                [name, by_path](File &f) { return (by_path ? f.path : f.name) == name; });
        if (iter == m_file_list.end()) return {file_list, -1};
        index = std::distance(m_file_list.begin(), iter);
    }
    return {file_list, index};
}

References m_file_list, m_file_list_cache, m_file_storage, and m_file_type.

Referenced by DownloadNextFile(), and FileRemoved().

Here is the caller graph for this function:

GetCount()

size_t PrinterFileSystem::GetCount

(

)

const

{
    if (m_group_mode == G_NONE)
        return m_file_list.size();
    return m_group_mode == G_YEAR ? m_group_year.size() : m_group_month.size();
}

References G_NONE, G_YEAR, m_file_list, m_group_mode, m_group_month, and m_group_year.

Referenced by UpdateFocusThumbnail().

Here is the caller graph for this function:

GetFile() [1/2]

PrinterFileSystem::File const & PrinterFileSystem::GetFile

(

size_t

index

)

{
    if (m_group_mode == G_NONE)
        return m_file_list[index];
    if (m_group_mode == G_YEAR) index = m_group_year[index];
    return m_file_list[m_group_month[index]];
}

References G_NONE, G_YEAR, m_file_list, m_group_mode, m_group_month, and m_group_year.

Referenced by UpdateFocusThumbnail().

Here is the caller graph for this function:

GetFile() [2/2]

PrinterFileSystem::File const & PrinterFileSystem::GetFile	(	size_t	index,
		bool &	select )

{
    if (m_group_mode == G_NONE) {
        select = m_file_list[index].IsSelect();
        return m_file_list[index];
    }
    select = m_group_flags[index] & FF_SELECT;
    if (m_group_mode == G_YEAR)
        index = m_group_year[index];
    return m_file_list[m_group_month[index]];
}

References FF_SELECT, G_NONE, G_YEAR, m_file_list, m_group_flags, m_group_mode, m_group_month, and m_group_year.

GetFileType()

FileType PrinterFileSystem::GetFileType ( ) const

inline

{ return m_file_type; }

References m_file_type.

GetGroupMode()

GroupMode PrinterFileSystem::GetGroupMode ( ) const

inline

{ return m_group_mode; }

References m_group_mode.

GetIndexAtTime()

size_t PrinterFileSystem::GetIndexAtTime

(

boost::uint32_t

time

)

{
    auto   iter = std::upper_bound(m_file_list.begin(), m_file_list.end(), File{"", "", time});
    size_t n = std::distance(m_file_list.begin(), iter) - 1;
    if (m_group_mode == G_NONE) {
        return n;
    }
    auto & group = m_group_mode == G_YEAR ? m_group_year : m_group_month;
    auto iter2 = std::upper_bound(group.begin(), group.end(), n);
    return std::distance(group.begin(), iter2) - 1;
}

References G_NONE, G_YEAR, m_file_list, m_group_mode, m_group_month, and m_group_year.

GetLastError()

int PrinterFileSystem::GetLastError ( ) const

inline

{ return m_last_error; }

References m_last_error.

GetMediaAbilityList()

PrinterFileSystem::MediaAbilityList PrinterFileSystem::GetMediaAbilityList

(

)

const

{
    return m_media_ability_list;
}

References m_media_ability_list.

GetPickImage()

void PrinterFileSystem::GetPickImage	(	int	id,
		const std::string &	local_path,
		const std::string &	path )

{
    json j;
 
    j["sequence_id"]   = id;
    j["version"]       = 1;
    j["peer_host"]     = "studio";
    j["command"]       = "get_project_file";
    j["file_rel_path"] = targetpath;
 
    std::string param = j.dump();
 
    DownloadRamFile(16, local_path, param);
}

References DownloadRamFile().

Referenced by GetPickImages().

Here is the call graph for this function:

Here is the caller graph for this function:

GetPickImages()

void PrinterFileSystem::GetPickImages	(	const std::vector< std::string > &	local_paths,
		const std::vector< std::string > &	targetpaths )

{
    m_download_states.clear();
 
    GetPickImage(1, local_paths[0], targetpaths[0]);
    GetPickImage(2, local_paths[1], targetpaths[1]);
    GetPickImage(3, local_paths[2], targetpaths[2]);
 
}

References GetPickImage(), and m_download_states.

Here is the call graph for this function:

GetSelectCount()

size_t PrinterFileSystem::GetSelectCount

(

)

const

{ return m_select_count; }

References m_select_count.

GetStatus()

Status PrinterFileSystem::GetStatus ( ) const

inline

{ return m_status; }

References m_status.

HandleResponse()

void PrinterFileSystem::HandleResponse ( boost::unique_lock< boost::mutex > & l, Bambu_Sample const & sample )

private

{
    unsigned char const *end      = sample.buffer + sample.size;
    unsigned char const *json_end = (unsigned char const *) memchr(sample.buffer, '\n', sample.size);
    while (json_end && json_end + 3 < end && json_end[1] != '\n') json_end = (unsigned char const *) memchr(json_end + 2, '\n', end - json_end - 2);
    if (json_end)
        json_end += 2;
    else
        json_end = end;
    std::string msg((char const *) sample.buffer, json_end - sample.buffer);
    json        root;
    // OutputDebugStringA(msg.c_str());
    // OutputDebugStringA("\n");
    wxLogInfo("PrinterFileSystem::HandleResponse <<<: \n%s\n", wxString::FromUTF8(msg));
    std::istringstream iss(msg);
    int                cmd    = 0;
    int                seq    = -1;
    int                result = 0;
    json               resp;
    try {
        iss >> root;
        if (!root["result"].is_null()) {
            result = root["result"];
            seq    = root["sequence"];
            resp   = root["reply"];
        } else {
            // maybe notify
            cmd  = root["cmdtype"];
            seq  = root["sequence"];
            resp = root["notify"];
        }
    } catch (...) {
        result = ERROR_JSON;
        return;
    }
    if (cmd > 0) {
        if (cmd < NOTIFY_FIRST) return;
        cmd -= NOTIFY_FIRST;
        if (size_t(cmd) >= m_notifies.size()) return;
        auto n = m_notifies[cmd];
        l.unlock();
        n(result, resp, json_end);
        l.lock();
    } else {
        int seq2 = seq - m_sequence;
        if (size_t(seq2) >= m_callbacks.size()) return;
        auto c = m_callbacks[seq2];
        if (c == nullptr) return;
        l.unlock();
        int result2 = c(result, resp, json_end);
        l.lock();
        if (result2 != CONTINUE) {
            int seq2          = seq - m_sequence;
            m_callbacks[seq2] = callback_t2();
            if (seq2 == 0) {
                while (!m_callbacks.empty() && m_callbacks.front() == nullptr) {
                    m_callbacks.pop_front();
                    ++m_sequence;
                }
            }
            if (result == CONTINUE) {
                l.unlock();
                CancelRequest(seq);
                l.lock();
            }
 
            // error should erase m_produce_message_cb
            if (m_produce_message_cb_map.find(seq2) != m_produce_message_cb_map.end()) {
                m_produce_message_cb_map.erase(seq2);
            }
        }
    }
}

References __Bambu_Sample::buffer, CancelRequest(), CONTINUE, ERROR_JSON, m_callbacks, m_notifies, m_produce_message_cb_map, m_sequence, NOTIFY_FIRST, and __Bambu_Sample::size.

Referenced by RecvMessageThread().

Here is the call graph for this function:

Here is the caller graph for this function:

InstallNotify() [1/2]

void PrinterFileSystem::InstallNotify ( int type, callback_t2 const & callback )

private

{
    type -= NOTIFY_FIRST;
    if (m_notifies.size() <= size_t(type)) m_notifies.resize(type + 1);
    m_notifies[type] = callback;
}

References m_notifies, and NOTIFY_FIRST.

InstallNotify() [2/2]

template<typename T>

void PrinterFileSystem::InstallNotify ( int type, Translator< T > const & translator, Applier< T > const & applier )

inlineprivate

    {
        auto c = [translator, applier, this](int result, nlohmann::json const &resp, unsigned char const *data) -> int
        {
            T t;
            if (result == 0 || result == CONTINUE) {
                try {
                    int n  = (translator != nullptr) ? translator(resp, t, data) : 0;
                    result = n == 0 ? result : n;
                }
                catch (...) {
                    result = ERROR_JSON;
                }
            }
            if (result == 0 && applier) {
                PostCallback<T>([applier](int, T const & t) {
                    applier(t);
                }, 0, t);
            }
            return result;
        };
        InstallNotify(type, c);
    }

References CONTINUE, ERROR_JSON, InstallNotify(), and PostCallback().

Referenced by InstallNotify().

Here is the call graph for this function:

Here is the caller graph for this function:

ListAllFiles()

void PrinterFileSystem::ListAllFiles

(

)

{
    json req;
    char const * types[] {"timelapse","video", "model" };
    req["type"] = types[m_file_type];
    if (!m_file_storage.empty())
        req["storage"] = m_file_storage;
    req["api_version"] = 2;
    req["notify"] = "DETAIL";
    SendRequest<FileList>(LIST_INFO, req, [type = m_file_type](json const& resp, FileList & list, auto) -> int {
        json files = resp["file_lists"];
        for (auto& f : files) {
            std::string     name = f["name"];
            std::string     path = f.value("path", "");
            time_t          time = f.value("time", 0);
            boost::uint64_t size = f["size"];
            if (type > F_TIMELAPSE && path.empty()) // Fix old printer that always return timelapses
                return FILE_TYPE_ERR;
            File            ff   = {name, path, time, size, 0};
            list.push_back(ff);
        }
        return 0;
    }, [this, type = m_file_type](int result, FileList list) {
        if (result != 0) {
            m_last_error = result;
            m_status = Status::Failed;
            m_file_list.clear();
            BuildGroups();
            UpdateGroupSelect();
            SendChangedEvent(EVT_STATUS_CHANGED, m_status, "", result);
            SendChangedEvent(EVT_FILE_CHANGED);
            return 0;
        }
        if (type != m_file_type)
            return 0;
        m_file_list.swap(list);
        for (auto & file : m_file_list)
            file.thumbnail = default_thumbnail;
        std::sort(m_file_list.begin(), m_file_list.end());
        auto iter1 = m_file_list.begin();
        auto end1  = m_file_list.end();
        auto iter2 = list.begin();
        auto end2  = list.end();
        while (iter1 != end1 && iter2 != end2) {
            if (*iter1 < *iter2) {
                ++iter1;
            } else if (*iter2 < *iter1) {
                ++iter2;
            } else {
                if (iter1->path == iter2->path && iter1->name == iter2->name) {
                    iter1->thumbnail = iter2->thumbnail;
                    iter1->flags     = iter2->flags;
                    if (!iter1->thumbnail.IsOk())
                        iter1->flags &= ~FF_THUMNAIL;
                    iter1->download   = iter2->download;
                    iter1->local_path = iter2->local_path;
                    iter1->metadata   = iter2->metadata;
                }
                ++iter1;
                ++iter2;
            }
        }
        BuildGroups();
        UpdateGroupSelect();
        m_last_error = 0;
        m_status = Status::ListReady;
        SendChangedEvent(EVT_STATUS_CHANGED, m_status);
        SendChangedEvent(EVT_FILE_CHANGED);
        if ((m_task_flags & FF_DOWNLOAD) == 0)
            DownloadNextFile();
        return 0;
    });
}

References BuildGroups(), default_thumbnail, DownloadNextFile(), F_TIMELAPSE, Failed, FF_DOWNLOAD, FF_THUMNAIL, FILE_TYPE_ERR, LIST_INFO, ListReady, m_file_list, m_file_storage, m_file_type, m_last_error, m_status, m_task_flags, SendChangedEvent(), SendRequest(), and UpdateGroupSelect().

Here is the call graph for this function:

ParseThumbnail() [1/2]

bool PrinterFileSystem::ParseThumbnail ( File & file )

staticprivate

{
    std::istringstream iss(file.local_path, std::ios::binary);
    return ParseThumbnail(file, iss);
}

References PrinterFileSystem::File::local_path, and ParseThumbnail().

Referenced by PrinterFileSystem(), ParseThumbnail(), and UpdateFocusThumbnail2().

Here is the call graph for this function:

Here is the caller graph for this function:

ParseThumbnail() [2/2]

bool PrinterFileSystem::ParseThumbnail ( File & file, std::istream & is )

staticprivate

{
    Slic3r::DynamicPrintConfig config;
    Slic3r::Model              model;
    Slic3r::PlateDataPtrs      plate_data_list;
    Slic3r::Semver file_version;
    if (!Slic3r::load_gcode_3mf_from_stream(is, &config, &model, &plate_data_list, &file_version))
        return false;
    float time      = 0.f;
    float weight    = 0.f;
    for (auto &plate : plate_data_list) {
        time += atof(plate->gcode_prediction.c_str());
        weight += atof(plate->gcode_weight.c_str());
        if (!plate->gcode_file.empty() && !plate->thumbnail_file.empty())
            file.metadata.emplace("plate_thumbnail_" + std::to_string(plate->plate_index), plate->thumbnail_file);
    }
    file.metadata.emplace("Title", model.model_info->model_name);
    file.metadata.emplace("Time", durationString(round(time)));
    file.metadata.emplace("Weight", std::to_string(int(round(weight))) + 'g');
    auto thumbnail = model.model_info->metadata_items["Thumbnail"];
    if (thumbnail.empty() && !plate_data_list.empty()) {
        thumbnail = plate_data_list.front()->thumbnail_file;
    }
    file.metadata.emplace("Thumbnail", thumbnail);
    return true;
}

References durationString(), Slic3r::load_gcode_3mf_from_stream(), PrinterFileSystem::File::metadata, and Slic3r::Model::model_info.

Here is the call graph for this function:

PostCallback() [1/2]

template<typename T>

void PrinterFileSystem::PostCallback ( Callback< T > const & callback, int result, T const & resp )

inlineprivate

    {
        PostCallback([=] { callback(result, resp); });
    }

References PostCallback().

Referenced by InstallNotify(), PostCallback(), Reconnect(), and SendRequest().

Here is the call graph for this function:

Here is the caller graph for this function:

PostCallback() [2/2]

void PrinterFileSystem::PostCallback ( std::function< void(void)> const & callback )

private

{
    wxCommandEvent *e = new CallbackEvent(callback, boost::weak_ptr(shared_from_this()));
    wxQueueEvent(this, e);
}

Reconnect()

void PrinterFileSystem::Reconnect ( boost::unique_lock< boost::mutex > & l, int result )

private

{
    if (m_session.tunnel) {
        auto tunnel = m_session.tunnel;
        m_session.tunnel = nullptr;
        wxLogMessage("PrinterFileSystem::Reconnect close %d", result);
        l.unlock();
        Bambu_Close(tunnel);
        Bambu_Destroy(tunnel);
        l.lock();
    }
    if (m_session.owner == nullptr)
        return;
    json r;
    while(!m_callbacks.empty()) {
        auto c = m_callbacks.front();
        m_callbacks.pop_front();
        ++m_sequence;
        if (c) c(result, r, nullptr);
    }
    m_messages.clear();
    if (result)
        m_cond.timed_wait(l, boost::posix_time::seconds(10));
 
 
    while (true) {
        while (m_stopped) {
            if (m_session.owner == nullptr)
                return;
           m_status = Status::Reconnecting;
           SendChangedEvent(EVT_STATUS_CHANGED, m_status);
           m_cond.wait(l);
        }
        wxLogMessage("PrinterFileSystem::Reconnect Initializing");
        m_status = Status::Initializing;
        m_last_error = 0;
        SendChangedEvent(EVT_STATUS_CHANGED, m_status);
        // wait for url
        while (!m_stopped && m_messages.empty())
            m_cond.wait(l);
        if (m_stopped || m_messages.empty()) continue;
        std::string url = m_messages.front();
        m_messages.clear();
        if (url.size() < 2) {
            wxLogMessage("PrinterFileSystem::Reconnect Initialize failed: %s", wxString::FromUTF8(url));
            m_last_error = atoi(url.c_str());
            if (m_last_error == 0)
                m_stopped = true;
        } else {
            wxLogInfo("PrinterFileSystem::Reconnect Initialized: %s", wxString::FromUTF8(url));
            l.unlock();
            m_status = Status::Connecting;
            wxLogMessage("PrinterFileSystem::Reconnect Connecting");
            SendChangedEvent(EVT_STATUS_CHANGED, m_status);
            Bambu_Tunnel tunnel = nullptr;
            int ret = Bambu_Create(&tunnel, url.c_str());
            if (ret == 0) {
 
                Bambu_SetLogger(tunnel, DumpLog, this);
                ret = Bambu_Open(tunnel);
            }
 
            if (ret == 0)
            {
                auto                             start_time = boost::posix_time::microsec_clock::universal_time();
                boost::posix_time::time_duration timeout    = boost::posix_time::seconds(3);
                do{
                    ret = Bambu_StartStreamEx ? Bambu_StartStreamEx(tunnel, CTRL_TYPE) : Bambu_StartStream(tunnel, false);
                    if (ret == Bambu_would_block)
                        boost::this_thread::sleep(boost::posix_time::milliseconds(100));
 
                     auto now = boost::posix_time::microsec_clock::universal_time();
                    if (now - start_time > timeout) {
                        BOOST_LOG_TRIVIAL(warning) << "StartStream timeout after 5 seconds.";
                        break;
                    }
 
                } while (ret == Bambu_would_block && !m_stopped);
            }
            l.lock();
            if (ret == 0) {
                m_session.tunnel = tunnel;
                wxLogMessage("PrinterFileSystem::Reconnect Connected");
                break;
            } else if (ret == 1) {
                m_stopped = true;
                ret = ERROR_RES_BUSY;
            }
            if (tunnel) {
                Bambu_Close(tunnel);
                Bambu_Destroy(tunnel);
            }
            m_last_error = ret;
        }
        wxLogMessage("PrinterFileSystem::Reconnect Failed");
        m_status = Status::Failed;
 
        SendChangedEvent(EVT_STATUS_CHANGED, m_status, "", url.size() < 2 ? 1 : m_last_error);
        m_cond.timed_wait(l, boost::posix_time::seconds(10));
    }
 
#ifdef PRINTER_FILE_SYSTEM_TEST
    PostCallback([this] { SendChangedEvent(EVT_FILE_CHANGED); });
#else
    PostCallback([this] {
        m_task_flags = 0;
        m_status     = Status::ListSyncing;
        SendChangedEvent(EVT_STATUS_CHANGED, m_status);
        });
#endif
}

References Bambu_Close(), Bambu_Create(), Bambu_Destroy(), Bambu_Open(), Bambu_SetLogger(), Bambu_StartStream(), Bambu_StartStreamEx(), Bambu_would_block, Connecting, CTRL_TYPE, DumpLog(), ERROR_RES_BUSY, Failed, Initializing, ListSyncing, m_callbacks, m_cond, m_last_error, m_messages, m_sequence, m_session, m_status, m_stopped, m_task_flags, PostCallback(), Reconnecting, and SendChangedEvent().

Referenced by RecvMessageThread().

Here is the call graph for this function:

Here is the caller graph for this function:

RecvMessageThread()

void PrinterFileSystem::RecvMessageThread ( )

private

{
    Bambu_Sample sample;
    boost::unique_lock l(m_mutex);
    Reconnect(l, 0);
    while (true) {
        if (m_stopped && (m_session.owner == nullptr || (m_messages.empty() && m_callbacks.empty()))) {
            Reconnect(l, 0); // Close and wait start again
            if (m_session.owner == nullptr) {
                // clear callbacks first
                auto callbacks(std::move(m_callbacks));
                break;
            }
        }
        if (m_messages.empty() && !m_produce_message_cb_map.empty()) {
            auto it = m_produce_message_cb_map.begin();
            while(it != m_produce_message_cb_map.end()) {
                std::string     msg;
                auto            prodeuce_message_cb = it->second;
                l.unlock();
                int res = prodeuce_message_cb(msg);
                l.lock();
                if (res == CONTINUE || res == SUCCESS) {
                    m_messages.emplace_back(msg);
                    if (res == SUCCESS) {
                        it = m_produce_message_cb_map.erase(it);
                        continue;
                    }
                    it++;
                } else {
                    int seq2 = it->first - m_sequence;
                    // erase it
                    it = m_produce_message_cb_map.erase(it);
                    if (size_t(seq2) >= m_callbacks.size())
                        continue;
                    auto c = m_callbacks[seq2];
                    if (c == nullptr)
                        continue;;
                    m_callbacks[seq2] = nullptr;
                    if (seq2 == 0) {
                        // if produce message return error, erase callback and sequence should plus
                        while (!m_callbacks.empty() && m_callbacks.front() == nullptr) {
                            m_callbacks.pop_front();
                            ++m_sequence;
                        }
                    }
 
                    l.unlock();
                    c(res, json(), nullptr);
                    l.lock();
                }
            }
        }
        if (!m_messages.empty()) {
            auto & msg = m_messages.front();
            // OutputDebugStringA(msg.c_str());
            // OutputDebugStringA("\n");
            wxLogInfo("PrinterFileSystem::SendRequest >>>: \n%s\n", wxString::FromUTF8(msg));
            l.unlock();
            int n = Bambu_SendMessage(m_session.tunnel, CTRL_TYPE, msg.c_str(), msg.length());
            l.lock();
            if (n == 0)
                m_messages.pop_front();
            else if (n != Bambu_would_block) {
                Reconnect(l, n);
                continue;
            }
        }
        l.unlock();
        int n = Bambu_ReadSample(m_session.tunnel, &sample);
        l.lock();
        if (n == 0) {
            HandleResponse(l, sample);
        } else if (n == Bambu_stream_end) {
            m_stopped = true;
            Reconnect(l, m_status == ListSyncing ? ERROR_RES_BUSY : ERROR_PIPE);
        } else if (n == Bambu_would_block) {
            m_cond.timed_wait(l, boost::posix_time::milliseconds(m_messages.empty() && m_callbacks.empty() ? 1000 : 20));
        } else {
            Reconnect(l, n);
        }
    } // while
}

References Bambu_ReadSample(), Bambu_SendMessage(), Bambu_stream_end, Bambu_would_block, CONTINUE, CTRL_TYPE, ERROR_PIPE, ERROR_RES_BUSY, HandleResponse(), ListSyncing, m_callbacks, m_cond, m_messages, m_mutex, m_produce_message_cb_map, m_sequence, m_session, m_status, m_stopped, Reconnect(), and SUCCESS.

Here is the call graph for this function:

RequestMediaAbility()

boost::uint32_t PrinterFileSystem::RequestMediaAbility

(

int

api_version

)

{
    json req;
    req["peer"] = "studio";
    req["api_version"] = api_version;
 
    return SendRequest<MediaAbilityList>(
        REQUEST_MEDIA_ABILITY, req, [](const json &resp, MediaAbilityList &list, auto) -> int {
            json abliity_list = resp["storage"];
            list              = abliity_list.get<MediaAbilityList>();
            return 0;
        },
        [this](int result, MediaAbilityList list){
            if (result != 0) {
                m_last_error = result;
                m_media_ability_list.clear();
                SendChangedEvent(EVT_MEDIA_ABILITY_CHANGED, RequestMediaAbilityStatus::S_FAILED, "", m_last_error);
                return result;
            }
 
            m_media_ability_list.swap(list);
            SendChangedEvent(EVT_MEDIA_ABILITY_CHANGED, RequestMediaAbilityStatus::S_SUCCESS);
            return 0;
        });
}

References m_last_error, m_media_ability_list, REQUEST_MEDIA_ABILITY, S_FAILED, S_SUCCESS, SendChangedEvent(), and SendRequest().

Here is the call graph for this function:

RequestUploadFile()

void PrinterFileSystem::RequestUploadFile

(

)

{
    if (!m_upload_file) {
        return;
    }
 
    json req;
    req["type"]    = "model";
    req["storage"] = m_upload_file->select_storage;
    req["path"]    = m_upload_file->name;
 
    m_upload_file->upload = std::make_unique<Upload>();
    boost::filesystem::path   path = boost::filesystem::path(m_upload_file->path);
    boost::system::error_code ec;
    boost::uint32_t           file_size = boost::filesystem::file_size(path, ec);
 
    req["total"] = file_size;
    m_upload_file->size          = file_size;
    m_upload_file->upload->total = file_size;
 
    m_upload_seq = SendRequest(
        FILE_UPLOAD, req,
        [this](int result, const json& resp, auto) -> int{
            if (result != SUCCESS && result != CONTINUE && result != FILE_EXIST) {
                std::string error_msg = "";
                if (result == ERROR_CANCEL) {
                    error_msg = _u8L("User cancels task.");
                } else if (result == FILE_READ_WRITE_ERR || result == FILE_OPEN_ERR) {
                    error_msg = _u8L("Failed to read file, please try again.");
                }
                wxLogWarning("PrinterFileSystem::UploadFile error: %d\n", result);
                SendChangedEvent(EVT_UPLOAD_CHANGED, FF_UPLOADCANCEL, error_msg, result);
            } else if (result == SUCCESS) {
                SendChangedEvent(EVT_UPLOADING, 100);
                SendChangedEvent(EVT_UPLOAD_CHANGED, FF_UPLOADDONE);
            } else if (result == CONTINUE || result == FILE_EXIST) {
                if (m_upload_file) {
                    m_upload_file->chunk_size   = resp["chunk_size"];
                    m_upload_file->upload->size = resp["offset"];
                    m_upload_file->flags |= FF_UPLOADING;
                }
 
                {
                    boost::unique_lock l(m_mutex);
                    auto cb = [this, upload_file = m_upload_file, seq = m_upload_seq](std::string &msg) -> int {
                        return UploadFileTask(upload_file, seq, msg);
                    };
                    m_produce_message_cb_map[m_upload_seq] = cb;
                }
 
                return CONTINUE;
            }
 
            // reset m_upload_file
            if (m_upload_file) {
                if (m_upload_file->upload->ifs.is_open()) {
                    m_upload_file->upload->ifs.close();
                }
                m_upload_file.reset();
            }
            return result;
        });
}

References _u8L, CONTINUE, ERROR_CANCEL, FF_UPLOADCANCEL, FF_UPLOADDONE, FF_UPLOADING, FILE_EXIST, FILE_OPEN_ERR, FILE_READ_WRITE_ERR, FILE_UPLOAD, m_mutex, m_produce_message_cb_map, m_upload_file, m_upload_seq, SendChangedEvent(), SendRequest(), SUCCESS, and UploadFileTask().

Here is the call graph for this function:

Retry()

void PrinterFileSystem::Retry

(

)

{
    boost::unique_lock l(m_mutex);
    m_stopped = false;
    m_cond.notify_all();
}

References m_cond, m_mutex, and m_stopped.

SelectAll()

void PrinterFileSystem::SelectAll

(

bool

select

)

{
    if (select) {
        for (auto &f : m_file_list) f.flags |= FF_SELECT;
        m_select_count = m_file_list.size();
        for (auto &s : m_group_flags) s |= FF_SELECT;
    } else {
        for (auto &f : m_file_list) f.flags &= ~FF_SELECT;
        m_select_count = 0;
        for (auto &s : m_group_flags) s &= ~FF_SELECT;
    }
    SendChangedEvent(EVT_SELECT_CHANGED, m_select_count);
}

References FF_SELECT, m_file_list, m_group_flags, m_select_count, and SendChangedEvent().

Referenced by SetFileType().

Here is the call graph for this function:

Here is the caller graph for this function:

SendChangedEvent()

void PrinterFileSystem::SendChangedEvent ( wxEventType type, size_t index = (size_t)-1, std::string const & str = {}, long extra = 0 )

private

{
    wxCommandEvent event(type);
    event.SetEventObject(this);
    event.SetInt(index);
    if (!str.empty())
        event.SetString(wxString::FromUTF8(str.c_str()));
    else if (auto iter = error_messages.find(extra); iter != error_messages.end())
        event.SetString(_L(iter->second.c_str()));
    else if (extra > CONTINUE && extra != ERROR_CANCEL)
        event.SetString(wxString::Format(_L("Error code: %d"), int(extra)));
    event.SetExtraLong(extra);
    if (wxThread::IsMain())
        ProcessEventLocally(event);
    else
        wxPostEvent(this, event);
}

References _L, CONTINUE, ERROR_CANCEL, and error_messages.

Referenced by DownloadCheckFile(), DownloadNextFile(), DownloadRamFile(), ListAllFiles(), Reconnect(), RequestMediaAbility(), RequestUploadFile(), SelectAll(), SendConnectFail(), SendExistedFile(), SetFileType(), SetGroupMode(), ToggleSelect(), UpdateFocusThumbnail2(), and UploadFileTask().

Here is the caller graph for this function:

SendConnectFail()

void PrinterFileSystem::SendConnectFail

(

)

                                       {
    SendChangedEvent(EVT_RAMDOWNLOAD, ERROR_PIPE);
}

References ERROR_PIPE, and SendChangedEvent().

Here is the call graph for this function:

SendExistedFile()

void PrinterFileSystem::SendExistedFile

(

)

                                       {
    SendChangedEvent(EVT_RAMDOWNLOAD, SUCCESS);
}

References SendChangedEvent(), and SUCCESS.

Here is the call graph for this function:

SendRequest() [1/2]

boost::uint32_t PrinterFileSystem::SendRequest ( int type, nlohmann::json const & req, callback_t2 const & callback, const std::string & param = "" )

private

SendRequest() [2/2]

template<typename T>

boost::uint32_t PrinterFileSystem::SendRequest ( int type, nlohmann::json const & req, Translator< T > const & translator, Callback< T > const & callback, const std::string & param = "" )

inlineprivate

    {
        auto c = [translator, callback, this](int result, nlohmann::json const &resp, unsigned char const *data) -> int
        {
            T t;
            if (result == 0 || result == CONTINUE || result == FILE_EXIST) {
                try {
                    int n  = (translator != nullptr) ? translator(resp, t, data) : 0;
                    result = n == 0 ? result : n;
                }
                catch (...) {
                    result = ERROR_JSON;
                }
            }
            PostCallback<T>(callback, result, t);
            return result;
        };
        return SendRequest(type, req, c, param);
    }

References CONTINUE, ERROR_JSON, FILE_EXIST, PostCallback(), and SendRequest().

Referenced by CancelRequests(), DeleteFilesContinue(), DownloadNextFile(), DownloadRamFile(), FetchModel(), ListAllFiles(), RequestMediaAbility(), RequestUploadFile(), SendRequest(), and UpdateFocusThumbnail2().

Here is the call graph for this function:

Here is the caller graph for this function:

SetFileType()

void PrinterFileSystem::SetFileType	(	FileType	type,
		std::string const &	storage = {} )

{
    if (m_file_type == type && m_file_storage == storage)
        return;
    SelectAll(false);
    assert(m_file_list_cache[std::make_pair(m_file_type, m_file_storage)].empty());
    m_file_list.swap(m_file_list_cache[{m_file_type, m_file_storage}]);
    std::swap(m_file_type, type);
    m_file_storage = storage;
    m_file_list.swap(m_file_list_cache[{m_file_type, m_file_storage}]);
    m_lock_start = m_lock_end = 0;
    BuildGroups();
    UpdateGroupSelect();
    SendChangedEvent(EVT_FILE_CHANGED);
    if (type == F_INVALID_TYPE)
        return;
    if (m_session.tunnel == nullptr)
        return;
    m_status = Status::ListSyncing;
    SendChangedEvent(EVT_STATUS_CHANGED, m_status);
}

References BuildGroups(), F_INVALID_TYPE, ListSyncing, m_file_list, m_file_list_cache, m_file_storage, m_file_type, m_lock_end, m_lock_start, m_session, m_status, SelectAll(), SendChangedEvent(), and UpdateGroupSelect().

Here is the call graph for this function:

SetFocusRange()

void PrinterFileSystem::SetFocusRange	(	size_t	start,
		size_t	count )

{
    m_lock_start = start;
    m_lock_end = start + count;
    if (!m_stopped && (m_task_flags & FF_THUMNAIL) == 0)
        UpdateFocusThumbnail();
}

References count, FF_THUMNAIL, m_lock_end, m_lock_start, m_stopped, m_task_flags, and UpdateFocusThumbnail().

Here is the call graph for this function:

SetGroupMode()

void PrinterFileSystem::SetGroupMode

(

GroupMode

mode

)

{
    if (this->m_group_mode == mode)
        return;
    this->m_group_mode = mode;
    m_lock_start = m_lock_end = 0;
    UpdateGroupSelect();
    SendChangedEvent(EVT_MODE_CHANGED);
}

References m_group_mode, m_lock_end, m_lock_start, SendChangedEvent(), and UpdateGroupSelect().

Referenced by EnterSubGroup().

Here is the call graph for this function:

Here is the caller graph for this function:

SetUploadFile()

void PrinterFileSystem::SetUploadFile	(	const std::string &	path,
		const std::string &	name,
		const std::string &	select_storage )

{
    boost::unique_lock l(m_mutex);
    if (!m_upload_file) {
        m_upload_file = std::make_unique<UploadFile>();
    }
    m_upload_file->path           = path;
    m_upload_file->name           = name;
    m_upload_file->select_storage = select_storage;
}

References m_mutex, and m_upload_file.

SetUrl()

void PrinterFileSystem::SetUrl

(

std::string const &

url

)

{
    boost::unique_lock l(m_mutex);
    m_messages.push_back(url);
    m_cond.notify_all();
}

References m_cond, m_messages, and m_mutex.

Start()

void PrinterFileSystem::Start

(

)

{
    boost::unique_lock l(m_mutex);
    if (!m_stopped) return;
    m_stopped = false;
    m_cond.notify_all();
}

References m_cond, m_mutex, and m_stopped.

Stop()

void PrinterFileSystem::Stop

(

bool

quit = false

)

{
    boost::unique_lock l(m_mutex);
    if (quit) {
        m_session.owner = nullptr;
    } else if (m_stopped) {
        return;
    }
    m_stopped = true;
    m_cond.notify_all();
}

References m_cond, m_mutex, m_session, and m_stopped.

ToggleSelect()

void PrinterFileSystem::ToggleSelect

(

size_t

index

)

{
    if (m_group_mode != G_NONE) {
        size_t beg = m_group_mode == G_YEAR ? m_group_month[m_group_year[index]] : m_group_month[index];
        size_t end_month = m_group_mode == G_YEAR ? ((index + 1) < m_group_year.size() ? m_group_year[index + 1] : m_group_month.size()) : index + 1;
        size_t end       = end_month < m_group_month.size() ? m_group_month[end_month] : m_file_list.size();
        if ((m_group_flags[index] & FF_SELECT) == 0) {
            for (int i = beg; i < end; ++i) {
                if ((m_file_list[i].flags & FF_SELECT) == 0) {
                    m_file_list[i].flags |= FF_SELECT;
                    ++m_select_count;
                }
            }
            m_group_flags[index] |= FF_SELECT;
        } else {
            for (int i = beg; i < end; ++i) {
                if (m_file_list[i].flags & FF_SELECT) {
                    m_file_list[i].flags &= ~FF_SELECT;
                    --m_select_count;
                }
            }
            m_group_flags[index] &= ~FF_SELECT;
        }
    } else if (index < m_file_list.size()) {
        m_file_list[index].flags ^= FF_SELECT;
        if (m_file_list[index].flags & FF_SELECT)
            ++m_select_count;
        else
            --m_select_count;
    }
    SendChangedEvent(EVT_SELECT_CHANGED, m_select_count);
}

References FF_SELECT, G_NONE, G_YEAR, m_file_list, m_group_flags, m_group_mode, m_group_month, m_group_year, m_select_count, and SendChangedEvent().

Here is the call graph for this function:

UpdateFocusThumbnail()

void PrinterFileSystem::UpdateFocusThumbnail ( )

private

{
    m_task_flags &= ~FF_THUMNAIL;
    if (m_lock_start >= m_file_list.size() || m_lock_start >= m_lock_end)
        return;
    size_t start = m_lock_start;
    size_t end   = std::min(m_lock_end, GetCount());
    std::vector<File> names;
    std::vector<File> paths;
    for (; start < end; ++start) {
        auto &file = GetFile(start);
        if ((file.flags & FF_THUMNAIL) == 0) {
            if (m_file_type == F_MODEL) {
                const_cast<File &>(file).metadata.emplace("Time", "...");
                const_cast<File &>(file).metadata.emplace("Weight", "...");
            }
            if (file.path.empty())
                names.push_back({file.name, ""});
            else
                paths.push_back({file.name, file.path});
            if (names.size() >= 2 || paths.size() >= 2)
                break;
            if ((file.flags & FF_THUMNAIL_RETRY) != 0) {
                const_cast<File&>(file).flags &= ~FF_THUMNAIL_RETRY;
                break;
            }
        }
    }
    if (names.empty() && paths.empty())
        return;
    m_task_flags |= FF_THUMNAIL;
    UpdateFocusThumbnail2(std::make_shared<std::vector<File>>(paths.empty() ? names : paths),
        paths.empty() ? OldThumbnail : m_file_type == F_MODEL ? ModelMetadata : VideoThumbnail);
}

References F_MODEL, FF_THUMNAIL, FF_THUMNAIL_RETRY, GetCount(), GetFile(), m_file_list, m_file_type, m_lock_end, m_lock_start, m_task_flags, ModelMetadata, OldThumbnail, UpdateFocusThumbnail2(), and VideoThumbnail.

Referenced by SetFocusRange(), and UpdateFocusThumbnail2().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateFocusThumbnail2()

void PrinterFileSystem::UpdateFocusThumbnail2 ( std::shared_ptr< std::vector< File > > files, int type )

private

{
    json req;
    json arr;
    if (type == OldThumbnail) {
        for (auto &file : *files) arr.push_back(file.name);
        req["files"] = arr;
    } else {
        if (type == VideoThumbnail) {
            for (auto &file : *files) arr.push_back(file.path + "#thumbnail");
        } else if (type == ModelMetadata) {
            for (auto &file : *files) {
                arr.push_back(file.path + "#_rels/.rels");
                arr.push_back(file.path + "#3D/3dmodel.model");
                arr.push_back(file.path + "#Metadata/model_settings.config");
                arr.push_back(file.path + "#Metadata/slice_info.config");
                arr.push_back(file.path + "#Metadata/project_settings.config");
            }
            req["zip"] = true;
        } else { // ModelThumbnail, FinishThumbnail
            std::vector<std::string> fails;
            for (auto &file : *files) {
                if ((file.flags & FF_THUMNAIL) == 0) {
                    fails.push_back(file.path);
                    file.flags |= FF_THUMNAIL;
                }
            }
            for (auto &path : fails) {
                auto iter = std::find_if(m_file_list.begin(), m_file_list.end(), [&path](auto &f) { return f.path == path; });
                if (iter != m_file_list.end()) {
                    if (type == ModelThumbnail) iter->metadata.clear();
                    iter->flags |= fails.size() == 1 ? FF_THUMNAIL : FF_THUMNAIL_RETRY;
                }
            }
            if (type == ModelThumbnail) {
                for (auto &file : *files) {
                    auto thumbnail = file.metadata["Thumbnail"];
                    if (!thumbnail.empty()) {
                        arr.push_back(file.path + "#" + thumbnail);
                        file.flags &= ~FF_THUMNAIL;
                        file.local_path.clear();
                    }
                }
            }
            if (arr.empty()) {
                UpdateFocusThumbnail();
                return;
            }
        }
        req["paths"] = arr;
    }
    SendRequest<File>(
        SUB_FILE, req, [type, files](json const &resp, File &file, unsigned char const *data) -> int {
            // in work thread, continue recv
            // receive data
            wxString        mimetype  = resp.value("mimetype", "");
            std::string     thumbnail = resp.value("thumbnail", "");
            std::string     path      = resp.value("path", "");
            boost::uint32_t size      = resp.value("size", 0);
            bool            cont      = resp.value("continue", false);
            if (size == 0) {
                file.name = thumbnail;
                file.path = path;
                return FILE_SIZE_ERR;
            }
            auto n = type == ModelMetadata ? std::string::npos : path.find_last_of('#'); // ModelMetadata is zipped without subpath
            auto path2 = n == std::string::npos ? path : path.substr(0, n);
            auto subpath = n == std::string::npos ? path : path.substr(n + 1);
            auto iter = std::find_if(files->begin(), files->end(), [&path2](auto &f) { return f.path == path2; });
            if (cont) {
                if (iter != files->end())
                    iter->local_path += std::string((char *) data, size);
                return 0;
            }
            if (type == ModelMetadata) {
                if (iter != files->end())
                    file.local_path = iter->local_path + std::string((char *) data, size);
                else
                    file.local_path = std::string((char *) data, size);
                ParseThumbnail(file);
            } else {
                if (mimetype.empty()) {
                    if (subpath.empty()) subpath = thumbnail;
                    auto n = subpath.find_last_of('.');
                    if (n != std::string::npos)
                        mimetype = "image/" + subpath.substr(n + 1);
                    else if (subpath == "thumbnail")
                        mimetype = "image/jpeg"; // default jpg
                }
                if (iter != files->end() && !iter->local_path.empty()) {
                    iter->local_path += std::string((char *) data, size);
                    data = reinterpret_cast<unsigned char const *>(iter->local_path.c_str());
                    size = iter->local_path.size();
                }
                wxMemoryInputStream mis(data, size);
                mimetype.Replace("jpg", "jpeg");
                file.thumbnail = wxImage(mis, mimetype);
                if (!file.thumbnail.IsOk()) {
                    BOOST_LOG_TRIVIAL(info) << "PrinterFileSystem: parse thumbnail failed" << size << mimetype;
                }
            }
            file.name = thumbnail;
            file.path = path;
            return 0;
        },
        [this, files, type](int result, File const &file) {
            auto n    = file.name.find_last_of('.');
            auto name  = n == std::string::npos ? file.name : file.name.substr(0, n) + ".mp4";
            n          = (type == ModelMetadata) ? std::string::npos : file.path.find_last_of('#');
            auto path = n == std::string::npos ? file.path : file.path.substr(0, n);
            auto iter = path.empty() ? std::find_if(m_file_list.begin(), m_file_list.end(), [&name](auto &f) { return f.name == name; }) :
                                       std::find_if(m_file_list.begin(), m_file_list.end(), [&path](auto &f) { return f.path == path; });
            auto iter2 = path.empty() ? std::find_if(files->begin(), files->end(), [&name](auto &f) { return f.name == name; }) :
                                        std::find_if(files->begin(), files->end(), [&path](auto &f) { return f.path == path; });
            if (iter != m_file_list.end()) {
                if (type == ModelMetadata) {
                    iter->metadata = file.metadata;
                    auto thumbnail = iter->metadata["Thumbnail"];
                    if (thumbnail.empty())
                        iter->flags |= FF_THUMNAIL; // DOTO: retry on fail
                    int index       = iter - m_file_list.begin();
                    SendChangedEvent(EVT_THUMBNAIL, index, file.name);
                    if (iter2 != files->end())
                        iter2->metadata = file.metadata;
                } else {
                    iter->flags |= FF_THUMNAIL; // DOTO: retry on fail
                    if (file.thumbnail.IsOk()) {
                        iter->thumbnail = file.thumbnail;
                        int index       = iter - m_file_list.begin();
                        SendChangedEvent(EVT_THUMBNAIL, index, file.name);
                    }
                }
            }
            if (iter2 != files->end())
                iter2->flags |= FF_THUMNAIL; // have received response
            if (result != CONTINUE)
                UpdateFocusThumbnail2(files, type == ModelMetadata ? ModelThumbnail : FinishThumbnail);
        });
}

References CONTINUE, FF_THUMNAIL, FF_THUMNAIL_RETRY, FILE_SIZE_ERR, FinishThumbnail, PrinterFileSystem::File::local_path, m_file_list, PrinterFileSystem::File::metadata, ModelMetadata, ModelThumbnail, PrinterFileSystem::File::name, OldThumbnail, ParseThumbnail(), PrinterFileSystem::File::path, SendChangedEvent(), SendRequest(), SUB_FILE, PrinterFileSystem::File::thumbnail, UpdateFocusThumbnail(), UpdateFocusThumbnail2(), and VideoThumbnail.

Referenced by UpdateFocusThumbnail(), and UpdateFocusThumbnail2().

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateGroupSelect()

void PrinterFileSystem::UpdateGroupSelect ( )

private

{
    m_group_flags.clear();
    int beg = 0;
    if (m_group_mode != G_NONE) {
        auto group = m_group_mode == G_YEAR ? m_group_year : m_group_month;
        if (m_group_mode == G_YEAR)
            for (auto &g : group) g = m_group_month[g];
        m_group_flags.resize(group.size(), FF_SELECT);
        for (int i = 0; i < m_file_list.size(); ++i) {
            if ((m_file_list[i].flags & FF_SELECT) == 0) {
                auto iter = std::upper_bound(group.begin(), group.end(), i);
                m_group_flags[iter - group.begin() - 1] &= ~FF_SELECT;
                if (iter == group.end()) break;
                i = *iter - 1; // start from next group
            }
        }
    }
}

References FF_SELECT, G_NONE, G_YEAR, m_file_list, m_group_flags, m_group_mode, m_group_month, and m_group_year.

Referenced by ListAllFiles(), SetFileType(), and SetGroupMode().

Here is the caller graph for this function:

UploadFileTask()

int PrinterFileSystem::UploadFileTask ( std::shared_ptr< UploadFile > upload_file, boost::uint64_t seq, std::string & msg )

private

{
    if (!upload_file)
        return FILE_OPEN_ERR;
 
    if (!(upload_file->flags & FF_UPLOADING))
        return FILE_OPEN_ERR;
 
    auto &upload = upload_file->upload;
    if (!upload->ifs.is_open()) {
        upload->ifs.open(upload_file->path, std::ios::binary);
        if (!upload_file->upload->ifs) {
            wxLogWarning("PrinterFileSystem::UploadFile open error: %s\n", wxString::FromUTF8(upload_file->path));
            return FILE_OPEN_ERR;
        }
        MD5_Init(&upload->ctx);
    }
 
    const boost::uint32_t buffer_size = upload_file->chunk_size * 1024;
    char *buffer = new char[buffer_size];
 
    upload->ifs.seekg(upload->size, std::ios::beg);
    upload->ifs.read(buffer, buffer_size);
    boost::int32_t read_size = upload->ifs.gcount();
 
    if (read_size <= 0) {
        wxLogWarning("PrinterFileSystem::Upload read error.\n");
        upload->ifs.close();
 
        if (buffer) {
            delete[] buffer;
            buffer = nullptr;
        }
        return FILE_READ_WRITE_ERR;
    }
 
    json req;
    req["frag_id"] = upload->frag_id;
    req["offset"]  = upload->size;
    req["size"]    = read_size;
 
    MD5_Update(&upload->ctx, buffer, read_size);
    upload->size += read_size;
    if (upload->size == upload->total) {
        unsigned char digest[16];
        MD5_Final(digest, &upload->ctx);
        char md5_str[33];
        for (int j = 0; j < 16; j++) { sprintf(&md5_str[j * 2], "%02X", (unsigned int) digest[j]); }
        std::string md5_out = std::string(md5_str);
        std::transform(md5_out.begin(), md5_out.end(), md5_out.begin(), ::tolower);
 
        req["file_md5"]     = md5_out;
        // OutputDebugStringA(md5_out.c_str());
        // OutputDebugStringA("\n");
    }
 
    if (m_upload_file && m_upload_file->flags & FF_UPLOADING) {
        upload->frag_id++;
        upload->progress = upload->size * 100 / upload->total;
        int progress     = upload->progress == 100 ? 99 : upload->progress;
        SendChangedEvent(EVT_UPLOADING, progress);
    }
 
    json root;
 
    root["cmdtype"] = FILE_UPLOAD;
    root["sequence"] = seq;
    root["req"]      = req;
 
    std::ostringstream oss;
    oss << root;
    oss << "\n\n";
    oss << std::string(buffer, read_size);
    msg = oss.str();
 
    if (buffer) {
        delete[] buffer;
        buffer = nullptr;
    }
 
    if (upload->size == upload->total) {
        upload->ifs.close();
        return SUCCESS;
    }
 
    return CONTINUE;
}

References CONTINUE, FF_UPLOADING, FILE_OPEN_ERR, FILE_READ_WRITE_ERR, FILE_UPLOAD, m_upload_file, SendChangedEvent(), and SUCCESS.

Referenced by RequestUploadFile().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

CTRL_TYPE

const int PrinterFileSystem::CTRL_TYPE = 0x3001

staticprivate

Referenced by Reconnect(), and RecvMessageThread().

m_callbacks

std::deque<callback_t2> PrinterFileSystem::m_callbacks

private

Referenced by CancelRequests2(), HandleResponse(), Reconnect(), and RecvMessageThread().

m_cond

boost::condition_variable PrinterFileSystem::m_cond

private

Referenced by Reconnect(), RecvMessageThread(), Retry(), SetUrl(), Start(), and Stop().

m_download_seq

boost::uint32_t PrinterFileSystem::m_download_seq = 0

private

Referenced by DownloadCancel(), DownloadNextFile(), and DownloadRamFile().

m_download_states

std::vector<bool> PrinterFileSystem::m_download_states

private

Referenced by DownloadRamFile(), and GetPickImages().

m_fetch_model_seq

boost::uint32_t PrinterFileSystem::m_fetch_model_seq = 0

private

Referenced by FetchModel(), and FetchModelCancel().

m_file_list

FileList PrinterFileSystem::m_file_list

protected

Referenced by PrinterFileSystem(), BuildGroups(), DeleteFiles(), DeleteFilesContinue(), DownloadCancel(), DownloadCheckFile(), DownloadCheckFiles(), DownloadFiles(), DownloadNextFile(), FetchModel(), FileRemoved(), FindFile(), GetCount(), GetFile(), GetFile(), GetIndexAtTime(), ListAllFiles(), SelectAll(), SetFileType(), ToggleSelect(), UpdateFocusThumbnail(), UpdateFocusThumbnail2(), and UpdateGroupSelect().

m_file_list_cache

std::map<std::pair<FileType, std::string>, FileList> PrinterFileSystem::m_file_list_cache

protected

Referenced by PrinterFileSystem(), FindFile(), and SetFileType().

m_file_storage

std::string PrinterFileSystem::m_file_storage

protected

Referenced by DeleteFilesContinue(), DownloadNextFile(), FindFile(), ListAllFiles(), and SetFileType().

m_file_type

FileType PrinterFileSystem::m_file_type = F_INVALID_TYPE

protected

Referenced by DeleteFilesContinue(), DownloadNextFile(), FindFile(), GetFileType(), ListAllFiles(), SetFileType(), and UpdateFocusThumbnail().

m_group_flags

std::vector<int> PrinterFileSystem::m_group_flags

protected

Referenced by FileRemoved(), GetFile(), SelectAll(), ToggleSelect(), and UpdateGroupSelect().

m_group_mode

GroupMode PrinterFileSystem::m_group_mode = G_NONE

protected

Referenced by EnterSubGroup(), FileRemoved(), GetCount(), GetFile(), GetFile(), GetGroupMode(), GetIndexAtTime(), SetGroupMode(), ToggleSelect(), and UpdateGroupSelect().

m_group_month

std::vector<size_t> PrinterFileSystem::m_group_month

protected

Referenced by BuildGroups(), EnterSubGroup(), FileRemoved(), GetCount(), GetFile(), GetFile(), GetIndexAtTime(), ToggleSelect(), and UpdateGroupSelect().

m_group_year

std::vector<size_t> PrinterFileSystem::m_group_year

protected

Referenced by BuildGroups(), EnterSubGroup(), FileRemoved(), GetCount(), GetFile(), GetFile(), GetIndexAtTime(), ToggleSelect(), and UpdateGroupSelect().

m_last_error

int PrinterFileSystem::m_last_error = 0

private

Referenced by GetLastError(), ListAllFiles(), Reconnect(), and RequestMediaAbility().

m_lock_end

size_t PrinterFileSystem::m_lock_end = 0

private

Referenced by SetFileType(), SetFocusRange(), SetGroupMode(), and UpdateFocusThumbnail().

m_lock_start

size_t PrinterFileSystem::m_lock_start = 0

private

Referenced by SetFileType(), SetFocusRange(), SetGroupMode(), and UpdateFocusThumbnail().

m_media_ability_list

MediaAbilityList PrinterFileSystem::m_media_ability_list

private

Referenced by GetMediaAbilityList(), and RequestMediaAbility().

m_messages

std::deque<std::string> PrinterFileSystem::m_messages

private

Referenced by Reconnect(), RecvMessageThread(), and SetUrl().

m_mutex

boost::mutex PrinterFileSystem::m_mutex

private

Referenced by Attached(), CancelRequests2(), CancelUploadTask(), RecvMessageThread(), RequestUploadFile(), Retry(), SetUploadFile(), SetUrl(), Start(), and Stop().

m_notifies

std::deque<callback_t2> PrinterFileSystem::m_notifies

private

Referenced by HandleResponse(), and InstallNotify().

m_produce_message_cb_map

std::map<boost::uint32_t, callback_t3> PrinterFileSystem::m_produce_message_cb_map

private

Referenced by CancelRequests2(), CancelUploadTask(), HandleResponse(), RecvMessageThread(), and RequestUploadFile().

m_recv_thread

boost::thread PrinterFileSystem::m_recv_thread

private

Referenced by ~PrinterFileSystem(), and Attached().

m_select_count

size_t PrinterFileSystem::m_select_count = 0

private

Referenced by GetSelectCount(), SelectAll(), and ToggleSelect().

m_sequence

boost::uint32_t PrinterFileSystem::m_sequence = 0

private

Referenced by CancelRequests2(), HandleResponse(), Reconnect(), and RecvMessageThread().

m_session

Session PrinterFileSystem::m_session

private

Referenced by PrinterFileSystem(), Reconnect(), RecvMessageThread(), SetFileType(), and Stop().

m_status

Status PrinterFileSystem::m_status

private

Referenced by GetStatus(), ListAllFiles(), Reconnect(), RecvMessageThread(), and SetFileType().

m_stopped

bool PrinterFileSystem::m_stopped = true

private

Referenced by Reconnect(), RecvMessageThread(), Retry(), SetFocusRange(), Start(), and Stop().

m_task_flags

int PrinterFileSystem::m_task_flags = 0

private

Referenced by DeleteFiles(), DeleteFilesContinue(), DownloadFiles(), DownloadNextFile(), FetchModel(), FetchModelCancel(), ListAllFiles(), Reconnect(), SetFocusRange(), and UpdateFocusThumbnail().

m_upload_file

std::shared_ptr<UploadFile> PrinterFileSystem::m_upload_file

protected

Referenced by CancelUploadTask(), RequestUploadFile(), SetUploadFile(), and UploadFileTask().

m_upload_seq

boost::uint32_t PrinterFileSystem::m_upload_seq = 0

private

Referenced by CancelUploadTask(), and RequestUploadFile().

---

The documentation for this class was generated from the following files:

• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Printer/PrinterFileSystem.h
• /home/runner/work/OrcaSlicer/OrcaSlicer/src/slic3r/GUI/Printer/PrinterFileSystem.cpp