36873490647

Committed 01 Oct 2026 02:04PM UTC coverage: 47.45% (-0.1%) from 47.56%

Build # 36873490647

Build Type

push

github

Committed by

jcelerier

Commit Message

addons: add trackingprotocols addon

Coverage Stats

152629 of 321661 relevant lines covered (47.45%)

145881.74 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.11

/src/plugins/score-lib-process/Process/Drop/ProcessDropHandler.cpp

#include <Process/Drop/ProcessDropHandler.hpp>

#include <score/tools/File.hpp>

#include <ossia/detail/algorithms.hpp>

#include <QDebug>
#include <QFile>
#include <QFileInfo>
#include <QSet>
#include <QUrl>
namespace Process
{

ProcessDropHandler::ProcessDropHandler() { }

ProcessDropHandler::~ProcessDropHandler() { }

void ProcessDropHandler::getCustomDrops(
    std::vector<ProcessDropHandler::ProcessDrop>& drops, const QMimeData& mime,
    const score::DocumentContext& ctx) const noexcept
{
  // dropCustom is no longer noexcept (some overrides invoke parsers that
  // can throw on malformed input — see ProcessDropHandler.hpp). Catch
  // here so a throwing handler never escapes through the noexcept
  // public API and tears down the editor.
  try
  {
    dropCustom(drops, mime, ctx);
  }
  catch(const std::exception& e)
  {
    qWarning() << "ProcessDropHandler::dropCustom threw:" << e.what();
  }
  catch(...)
  {
    qWarning() << "ProcessDropHandler::dropCustom threw an unknown exception";
  }
}

void ProcessDropHandler::getMimeDrops(
    std::vector<ProcessDropHandler::ProcessDrop>& drops, const QMimeData& mime,
    const QString& fmt, const score::DocumentContext& ctx) const noexcept
{
  qDebug() << fmt << mime.data(fmt);
  auto df = DroppedFile{{}, mime.data(fmt)};
  dropData(drops, df, ctx);
}

void ProcessDropHandler::getFileDrops(
    std::vector<ProcessDropHandler::ProcessDrop>& drops, const QMimeData& mime,
    const score::FilePath& path, const score::DocumentContext& ctx) const noexcept
{
  // Check for handling through paths
  auto old_sz = drops.size();
  dropPath(drops, path, ctx);
  if(drops.size() != old_sz)
    return;

  // Fall back to manual handling
  if(QFile file{path.absolute}; file.open(QIODevice::ReadOnly))
  {
    dropData(drops, {path, file.readAll()}, ctx);
  }
}

QSet<QString> ProcessDropHandler::mimeTypes() const noexcept
{
  return {};
}

QSet<QString> ProcessDropHandler::fileExtensions() const noexcept
{
  return {};
}

void ProcessDropHandler::dropCustom(
    std::vector<ProcessDropHandler::ProcessDrop>&, const QMimeData& data,
    const score::DocumentContext& ctx) const
{
}

void ProcessDropHandler::dropPath(
    std::vector<ProcessDropHandler::ProcessDrop>&, const score::FilePath& data,
    const score::DocumentContext& ctx) const noexcept
{
}

void ProcessDropHandler::dropData(
    std::vector<ProcessDropHandler::ProcessDrop>&, const DroppedFile& data,
    const score::DocumentContext& ctx) const noexcept
{
}

ProcessDropHandlerList::~ProcessDropHandlerList() { }

std::vector<ProcessDropHandler::ProcessDrop> ProcessDropHandlerList::getDrop(
    const QMimeData& originalMime, const score::DocumentContext& ctx) const noexcept
{
  std::vector<ProcessDropHandler::ProcessDrop> res;

  initCaches();

#if defined(__EMSCRIPTEN__)
  // On wasm, Qt writes dropped files to a transient /qt/tmp/ dir and deletes
  // them immediately after this callback returns. Move each dropped file into
  // score's persistent import area up front and rewrite the URLs, so BOTH the
  // custom-drop path (which re-reads mime.urls() itself, e.g. Sound) and the
  // file-extension path see a path that survives the drop and can be re-opened
  // later (undo/redo, reload of the process).
  QMimeData stagedMime;
  bool didStage = false;
  {
    QList<QUrl> newUrls;
    for(const QUrl& url : originalMime.urls())
    {
      // On the JSPI build (which we use), Qt hands dropped files a
      // "weblocalfile:/N/name" URL backed by the JS File object; QUrl::toLocalFile()
      // is empty but QFile can read it through QWasmFileEngine. On non-asyncify
      // builds files land at /qt/tmp instead. In both cases read the bytes here
      // (while the source is alive) and copy them into a real, persistent MEMFS
      // path so the fopen-based decoders (ffmpeg / sndfile) can open them later.
      QString src;
      if(const QString local = url.toLocalFile();
         !local.isEmpty() && QFileInfo::exists(local))
        src = local;
      else if(url.scheme() == QLatin1String("weblocalfile"))
        src = url.toString();

      if(!src.isEmpty())
      {
        if(QFile f{src}; f.open(QIODevice::ReadOnly))
        {
          const QByteArray bytes = f.readAll();
          f.close();
          QString name = url.fileName();
          if(name.isEmpty())
            name = QFileInfo{src}.fileName();
          if(QString staged = score::stageImportedFile(name, bytes); !staged.isEmpty())
          {
            newUrls.push_back(QUrl::fromLocalFile(staged));
            didStage = true;
            continue;
          }
        }
      }
      newUrls.push_back(url);
    }
    if(didStage)
    {
      for(const QString& fmt : originalMime.formats())
        stagedMime.setData(fmt, originalMime.data(fmt));
      stagedMime.setUrls(newUrls);
    }
  }
  const QMimeData& mime = didStage ? stagedMime : originalMime;
#else
  const QMimeData& mime = originalMime;
#endif

  auto handleCustomDrop = [&](Process::ProcessDropHandler& handler) {
    auto before = res.size();
    handler.getCustomDrops(res, mime, ctx);
    auto after = res.size();
    return after != before;
  };

  // Look for drop handlers with the available MIME types
  for(const auto& fmt : mime.formats())
  {
    if(auto it = m_perMimeTypes.find(fmt.toStdString()); it != m_perMimeTypes.end())
    {
      auto& handler = *it->second;

      // First check if a custom drop is in order, which handles everything.
      if(handleCustomDrop(handler))
        return res;

      // Then fall back to the normal mime data drop
      handler.getMimeDrops(res, mime, fmt, ctx);
    }
  }

  if(!res.empty())
  {
    // qDebug() << "handled through getMimeDrops";
    return res;
  }

  // Look for drop handlers with the available file extensions
  for(const auto& url : mime.urls())
  {
    auto path = url.toLocalFile();

    QFileInfo f{path};
    if(f.exists())
    {
      auto ext = f.suffix().toLower();
      if(auto it = m_perFileExtension.find(ext.toStdString());
         it != m_perFileExtension.end())
      {
        const score::FilePath p{
            .absolute = path,
            .relative = score::relativizeFilePath(path, ctx),
            .filename = f.fileName(),
            .basename = f.baseName()};

        for(auto* h : it->second)
        {
          auto& handler = *h;

          // First check if a custom drop is in order, which handles everything.
          if(handleCustomDrop(handler))
          {
            // qDebug() << "handled through getCustomDrops";
            return res;
          }

          // Then fall back to the normal mime data drop
          handler.getFileDrops(res, mime, p, ctx);
        }
      }
    }
  }

  // TODO Fix Sound::DropHandler::drop so that we don't need to do that
  // and remove the custom drop mechanism above (problem is that customData is empty)
  /*
  {
    auto comp = [](auto& lhs, auto& rhs) {
      return lhs.creation.customData < rhs.creation.customData;
    };
    ossia::remove_duplicates(res, comp);
  }
  if(!res.empty())
  {
    qDebug() << "handled through getFileDrops";
    return res;
  }
  */
  return res;
}

std::optional<TimeVal> ProcessDropHandlerList::getMaxDuration(
    const std::vector<ProcessDropHandler::ProcessDrop>& res)
{
  using drop_t = Process::ProcessDropHandler::ProcessDrop;
  SCORE_ASSERT(!res.empty());

  auto max_t
      = std::max_element(res.begin(), res.end(), [](const drop_t& l, const drop_t& r) {
          return l.duration < r.duration;
        });

  return max_t->duration;
}

void ProcessDropHandlerList::initCaches() const
{
  if(m_lastCacheSize != this->size())
  {
    m_perMimeTypes.clear();
    m_perFileExtension.clear();

    for(auto& handler : *this)
    {
      for(const auto& ext : handler.fileExtensions())
      {
        m_perFileExtension[ext.toLower().toStdString()].push_back(&handler);
      }

      for(const auto& ext : handler.mimeTypes())
      {
        m_perMimeTypes[ext.toLower().toStdString()] = &handler;
      }
    }
  }
}
}

1	#include <Process/Drop/ProcessDropHandler.hpp>
2
3	#include <score/tools/File.hpp>
4
5	#include <ossia/detail/algorithms.hpp>
6
7	#include <QDebug>
8	#include <QFile>
9	#include <QFileInfo>
10	#include <QSet>
11	#include <QUrl>
12	namespace Process
13	{
14
15	ProcessDropHandler::ProcessDropHandler() { }	66,079 ✔
16
17	ProcessDropHandler::~ProcessDropHandler() { }	66,058 ✔
18
19	void ProcessDropHandler::getCustomDrops(	43 ✔
20	std::vector<ProcessDropHandler::ProcessDrop>& drops, const QMimeData& mime,
21	const score::DocumentContext& ctx) const noexcept
22	{
23	// dropCustom is no longer noexcept (some overrides invoke parsers that
24	// can throw on malformed input — see ProcessDropHandler.hpp). Catch
25	// here so a throwing handler never escapes through the noexcept
26	// public API and tears down the editor.
27	try
28	{
29	dropCustom(drops, mime, ctx);	43 ✔
30	}	43 ✔
31	catch(const std::exception& e)
32	{
33	qWarning() << "ProcessDropHandler::dropCustom threw:" << e.what();	1 ✔
34	}	1 ✔
35	catch(...)
36	{
37	qWarning() << "ProcessDropHandler::dropCustom threw an unknown exception";	1 ✔
38	}	2 ✔
39	}	45 ✔
40
41	void ProcessDropHandler::getMimeDrops(	18 ✔
42	std::vector<ProcessDropHandler::ProcessDrop>& drops, const QMimeData& mime,
43	const QString& fmt, const score::DocumentContext& ctx) const noexcept
44	{
45	qDebug() << fmt << mime.data(fmt);	18 ✔
46	auto df = DroppedFile{{}, mime.data(fmt)};	18 ✔
47	dropData(drops, df, ctx);	18 ✔
48	}	18 ✔
49
50	void ProcessDropHandler::getFileDrops(	21 ✔
51	std::vector<ProcessDropHandler::ProcessDrop>& drops, const QMimeData& mime,
52	const score::FilePath& path, const score::DocumentContext& ctx) const noexcept
53	{
54	// Check for handling through paths
55	auto old_sz = drops.size();	21 ✔
56	dropPath(drops, path, ctx);	21 ✔
57	if(drops.size() != old_sz)	21 ✔
58	return;	11 ✔
59
60	// Fall back to manual handling
61	if(QFile file{path.absolute}; file.open(QIODevice::ReadOnly))	20 ✔
62	{
63	dropData(drops, {path, file.readAll()}, ctx);	10 ✔
64	}	10 ✔
65	}	21 ✔
66
67	QSet<QString> ProcessDropHandler::mimeTypes() const noexcept	41,236 ✔
68	{
69	return {};	41,236 ✔
70	}
71
72	QSet<QString> ProcessDropHandler::fileExtensions() const noexcept	6,345 ✔
73	{
74	return {};	6,345 ✔
75	}
76
77	void ProcessDropHandler::dropCustom(	13 ✔
78	std::vector<ProcessDropHandler::ProcessDrop>&, const QMimeData& data,
79	const score::DocumentContext& ctx) const
80	{
81	}	13 ✔
82
83	void ProcessDropHandler::dropPath(	×
84	std::vector<ProcessDropHandler::ProcessDrop>&, const score::FilePath& data,
85	const score::DocumentContext& ctx) const noexcept
86	{
87	}	×
88
89	void ProcessDropHandler::dropData(	28 ✔
90	std::vector<ProcessDropHandler::ProcessDrop>&, const DroppedFile& data,
91	const score::DocumentContext& ctx) const noexcept
92	{
93	}	28 ✔
94
95	ProcessDropHandlerList::~ProcessDropHandlerList() { }	6,290 ✔
96
97	std::vector<ProcessDropHandler::ProcessDrop> ProcessDropHandlerList::getDrop(	26 ✔
98	const QMimeData& originalMime, const score::DocumentContext& ctx) const noexcept
99	{
100	std::vector<ProcessDropHandler::ProcessDrop> res;	26 ✔
101
102	initCaches();	26 ✔
103
104	#if defined(__EMSCRIPTEN__)
105	// On wasm, Qt writes dropped files to a transient /qt/tmp/ dir and deletes
106	// them immediately after this callback returns. Move each dropped file into
107	// score's persistent import area up front and rewrite the URLs, so BOTH the
108	// custom-drop path (which re-reads mime.urls() itself, e.g. Sound) and the
109	// file-extension path see a path that survives the drop and can be re-opened
110	// later (undo/redo, reload of the process).
111	QMimeData stagedMime;
112	bool didStage = false;
113	{
114	QList<QUrl> newUrls;
115	for(const QUrl& url : originalMime.urls())
116	{
117	// On the JSPI build (which we use), Qt hands dropped files a
118	// "weblocalfile:/N/name" URL backed by the JS File object; QUrl::toLocalFile()
119	// is empty but QFile can read it through QWasmFileEngine. On non-asyncify
120	// builds files land at /qt/tmp instead. In both cases read the bytes here
121	// (while the source is alive) and copy them into a real, persistent MEMFS
122	// path so the fopen-based decoders (ffmpeg / sndfile) can open them later.
123	QString src;
124	if(const QString local = url.toLocalFile();
125	!local.isEmpty() && QFileInfo::exists(local))
126	src = local;
127	else if(url.scheme() == QLatin1String("weblocalfile"))
128	src = url.toString();
129
130	if(!src.isEmpty())
131	{
132	if(QFile f{src}; f.open(QIODevice::ReadOnly))
133	{
134	const QByteArray bytes = f.readAll();
135	f.close();
136	QString name = url.fileName();
137	if(name.isEmpty())
138	name = QFileInfo{src}.fileName();
139	if(QString staged = score::stageImportedFile(name, bytes); !staged.isEmpty())
140	{
141	newUrls.push_back(QUrl::fromLocalFile(staged));
142	didStage = true;
143	continue;
144	}
145	}
146	}
147	newUrls.push_back(url);
148	}
149	if(didStage)
150	{
151	for(const QString& fmt : originalMime.formats())
152	stagedMime.setData(fmt, originalMime.data(fmt));
153	stagedMime.setUrls(newUrls);
154	}
155	}
156	const QMimeData& mime = didStage ? stagedMime : originalMime;
157	#else
158	const QMimeData& mime = originalMime;	26 ✔
159	#endif
160
161	auto handleCustomDrop = [&](Process::ProcessDropHandler& handler) {	66 ✔
162	auto before = res.size();	40 ✔
163	handler.getCustomDrops(res, mime, ctx);	40 ✔
164	auto after = res.size();	40 ✔
165	return after != before;	40 ✔
166	};
167
168	// Look for drop handlers with the available MIME types
169	for(const auto& fmt : mime.formats())	59 ✔
170	{
171	if(auto it = m_perMimeTypes.find(fmt.toStdString()); it != m_perMimeTypes.end())	33 ✔
172	{
173	auto& handler = *it->second;	18 ✔
174
175	// First check if a custom drop is in order, which handles everything.
176	if(handleCustomDrop(handler))	18 ✔
177	return res;	×
178
179	// Then fall back to the normal mime data drop
180	handler.getMimeDrops(res, mime, fmt, ctx);	18 ✔
181	}	18 ✔
182	}
183
184	if(!res.empty())	26 ✔
185	{
186	// qDebug() << "handled through getMimeDrops";
187	return res;	×
188	}
189
190	// Look for drop handlers with the available file extensions
191	for(const auto& url : mime.urls())	45 ✔
192	{
193	auto path = url.toLocalFile();	19 ✔
194
195	QFileInfo f{path};	19 ✔
196	if(f.exists())	19 ✔
197	{
198	auto ext = f.suffix().toLower();	15 ✔
199	if(auto it = m_perFileExtension.find(ext.toStdString());	15 ✔
200	it != m_perFileExtension.end())	15 ✔
201	{
202	const score::FilePath p{	42 ✔
203	.absolute = path,	14 ✔
204	.relative = score::relativizeFilePath(path, ctx),	14 ✔
205	.filename = f.fileName(),	14 ✔
206	.basename = f.baseName()};	14 ✔
207
208	for(auto* h : it->second)	35 ✔
209	{
210	auto& handler = *h;	22 ✔
211
212	// First check if a custom drop is in order, which handles everything.
213	if(handleCustomDrop(handler))	22 ✔
214	{
215	// qDebug() << "handled through getCustomDrops";
216	return res;	1 ✔
217	}
218
219	// Then fall back to the normal mime data drop
220	handler.getFileDrops(res, mime, p, ctx);	21 ✔
221	}
222	}	14 ✔
223	}	15 ✔
224	}	19 ✔
225
226	// TODO Fix Sound::DropHandler::drop so that we don't need to do that
227	// and remove the custom drop mechanism above (problem is that customData is empty)
228	/*
229	{
230	auto comp = [](auto& lhs, auto& rhs) {
231	return lhs.creation.customData < rhs.creation.customData;
232	};
233	ossia::remove_duplicates(res, comp);
234	}
235	if(!res.empty())
236	{
237	qDebug() << "handled through getFileDrops";
238	return res;
239	}
240	*/
241	return res;	25 ✔
242	}	26 ✔
243
244	std::optional<TimeVal> ProcessDropHandlerList::getMaxDuration(	×
245	const std::vector<ProcessDropHandler::ProcessDrop>& res)
246	{
247	using drop_t = Process::ProcessDropHandler::ProcessDrop;
248	SCORE_ASSERT(!res.empty());	×
249
250	auto max_t
251	= std::max_element(res.begin(), res.end(), [](const drop_t& l, const drop_t& r) {	×
252	return l.duration < r.duration;	×
253	});
254
255	return max_t->duration;	×
256	}
257
258	void ProcessDropHandlerList::initCaches() const	26 ✔
259	{
260	if(m_lastCacheSize != this->size())	26 ✔
261	{
262	m_perMimeTypes.clear();	26 ✔
263	m_perFileExtension.clear();	26 ✔
264
265	for(auto& handler : *this)	572 ✔
266	{
267	for(const auto& ext : handler.fileExtensions())	3,068 ✔
268	{
269	m_perFileExtension[ext.toLower().toStdString()].push_back(&handler);	2,522 ✔
270	}
271
272	for(const auto& ext : handler.mimeTypes())	702 ✔
273	{
274	m_perMimeTypes[ext.toLower().toStdString()] = &handler;	156 ✔
275	}
276	}
277	}	26 ✔
278	}	26 ✔
279	}

ossia / score / 36873490647

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous