martino/MARTe-Integrated-Components
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: martino/MARTe-Integrated-Components:dd7dd22cb046815d70cfd87301223d05d249af77
Branches Tags
martino/MARTe-Integrated-Components:main martino/MARTe-Integrated-Components:feature/udpscope martino/MARTe-Integrated-Components:feature/stress-report-integration
...
compare: martino/MARTe-Integrated-Components:feature/udpscope
Branches Tags
martino/MARTe-Integrated-Components:main martino/MARTe-Integrated-Components:feature/udpscope martino/MARTe-Integrated-Components:feature/stress-report-integration
105 Commits
dd7dd22cb0 ... feature/udpscope
Author SHA1 Message Date
Martino FerrariandClaude Opus 4.6 deabd257e5 fix(udps): stop packets being dated from an earlier time base 
Reported as samples sporadically carrying a previous packet's timestamp:
holes on one side of the stream and collisions on the other, in both the
Go and the MARTe2 receiver. That it appeared in both is what located it
-- the shared cause is upstream of either client. Four independent
defects, all of which end in a packet's values being placed at a time
that is not theirs.

Reassembly slot exhaustion (the "Reassembly slots full; evicting oldest"
flood). Chunk size was learnt only from fragment 0, so an out-of-order
burst destroyed a packet whose bytes had all arrived and left the slot
occupied until the 2 s GC. Slots were keyed on the counter alone, but
DATA and CONFIG number independently, so equal counters merged the two
streams. The 32-byte received-mask covered 256 of the 512 fragments the
client accepts, so a duplicate above 255 was counted as new and the
packet was delivered with a hole of stale bytes in it. And one datagram
was read per Execute(), which cannot drain a fast producer. Fixed with a
pendingTail deferral, (counter, type) keying, a 64-byte mask, a
256-datagram drain, counter-age slot reclamation, and a 1 Hz aggregated
warning in place of the per-eviction flood.

UDPStreamer dropping whole Accumulate batches. EventSem::ResetWait is
Reset-then-Wait, so a Post() landing while the sender thread was inside
ServiceClients()/SendData() was destroyed by the next Reset. The batch
was then skipped with dataReady false, readyFill was never cleared, and
the following flush overwrote it: an entire run of RT cycles never
reached the wire. The record of pending work now lives in the buffers
rather than in the semaphore edge, which also removes up to
UDPS_DATA_WAIT_MS of latency; genuine backpressure overwrites are
counted and reported. Against the unfixed code the new test sees
2999/3000 batches never consumed.

Period inflation after loss. Accumulated scalars carry no SamplingRate,
so the receiver derives dt from the sender-clock gap -- but dividing it
by the previous packet's sample count is only right while nothing is
lost. One loss doubles the reported period, which spreads a batch a full
batch past its own end and into the range the next packet claims. That
is the hole and the collision, exactly. Inferring the cycle count from
the estimate's own period is not a way out: it has a stable fixed point
wherever gap/dt is an integer, so a real rate change locks it at the old
one for good (AccumDtGTest.FollowsSustainedRateChange).

The packet counter removes the ambiguity, so all three receivers now
order on it: a DATA packet that does not advance the counter is dropped
rather than delivered, because its values are older than data already
handed over. Ordering is on the signed difference so it survives the
uint32 wrap, and the sequence resets on reconnect, where the producer's
counter restarts independently of ours. The loss count that falls out of
the same delta feeds the period estimate as cycles = prevN * (1 + lost),
which reduces exactly to gap/prevN when nothing is lost and therefore
still tracks a genuine rate change. UDPSClient::AcceptDataCounter (C++),
udpsprotocol.SequenceGate (Go), decode_data (C).

The C client's existing gap counter was wrap-unsafe and let a stale
packet rewind last_counter, which made every subsequent gap wrong; it
uses the same code now. Docs/Protocol.md gains an Ordering DATA section
stating the requirement for any receiver, including ones outside this
repository.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-09-02 01:14:40 +02:00
Martino Ferrari 13fac79400 fixed flickering 2026-09-01 09:51:07 +02:00
Martino Ferrari 0398434c61 fixed and improved ui 2026-08-29 23:18:36 +02:00
Martino Ferrari 6b3056c612 fixed and improved ui 2026-08-29 23:18:00 +02:00
Martino Ferrari ec0a0cdb12 fixed and improved ui 2026-08-29 23:17:41 +02:00
Martino Ferrari 044ce57ba3 fixed issue on udpstreamer trigger logic 2026-08-28 16:53:17 +02:00
Martino FerrariandClaude Opus 4.6 1c61e814c0 fix(udpscope): keep the packet counter in lockstep with the tick reference 
The counter is the denominator of the very period lastAccHrt is the
numerator of, so any packet that cannot move the tick reference must not
move the counter either. Two paths were violating that: a reordered
datagram rolled the counter back while the reference correctly held
(next burst drawn 0.048x too narrow at distance 20, 83.3% worst spacing
error under 2% sustained reordering), and a stray hrt == 0 packet
advanced the counter from the warm-up branch without a tick to match
(+22.5 ms of future-dating per stray packet).

Rules 1 and 2 now record a counter too. The duplicate-datagram guard is
keyed on one, so an array rule that recorded none was exempt and plotted
every doubly-delivered update twice.

Also: rule 2 divides by the count the anchor actually spans and falls
back to the last period it derived; the counter-gap test is wrap-safe so
2^32 rollover reads as no information rather than 2e9 lost packets.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-08-28 06:41:47 +02:00
Martino FerrariandClaude Opus 4.6 f97fd825c4 fix(udpscope): stop a wrong hrtDt from displacing the trace permanently 
On the hrt branch the derived period is not just a spacing: it is the
burst width ClockOffset latches against, so a wrong one shifts the whole
trace by an amount that is usually too small for kRecalibThresholdS to
ever heal. Three routes to a wrong period were open.

Packet loss. elapsed spans every packet since the last one seen, but it
was divided by prevAccCount alone, so a lost datagram scaled the period
by the whole counter gap. Since a burst is anchored on its LAST element,
too wide means it ends in the FUTURE: +22.5 ms for one loss, +225 ms for
ten, at 10 samples per 25 ms packet, mis-spacing 2.7% of all samples at
1% loss. The declared branch already reads the counter for exactly this;
the hrt branch now does too.

Producer restart and reorder. Both leave elapsed at zero, so no period
can be measured -- and the restart packet is also the one that re-latches
after offset.reset(). Falling back to kDefaultDt is only right at 1 kHz;
measured standing displacement was +13.5 ms at 10 samples per 25 ms and
-89 ms at 100 per 10 ms. Remember the last measured period instead.

A stray hrt == 0 packet re-enters the warm-up branch, which spans from
packetBurst's lastPacketWall -- a field the hrt branch never wrote, so it
still held the start of the session. After 153 packets that emitted a
burst 3.8 s in the past, worse the longer the scope had run.

Also: rule 2 with no declared rate stacked every element of the array on
one instant (as UDPSourceSession.cpp:522 does, harmlessly, for a
host-local consumer). Spread it from consecutive time-signal anchors,
which measure the burst on the producer's own clock.

Reverts the previous commit's wallElapsed <= 0 change: it was measurably
inert -- the step floor two lines below already yields the same number --
and its comment claimed a divergence it did not stop.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-08-28 06:11:45 +02:00
Martino FerrariandClaude Opus 4.6 3add2c42b9 fix(udpscope): carry warm-up state across the hrt handover 
An undeclared-rate accumulated scalar is served by packetBurst until
HrtRateFit is ready, then by the hrt branch. The two place a burst
differently -- packetBurst ends it at wallNow, the hrt branch at
wallNow - (nElems-1)*hrtDt -- and the warm-up left no state behind, so
the handover packet skipped the monotonic clamp and stepped the signal
backwards by up to a burst width (-6.5 ms at 10 samples per 2.5 ms
packet, -0.99 s at 1000 samples per 10 ms).

Seeding lastEmitted* alone would only restore ordering. Without
lastAccHrt/prevAccCount the first hrt packet also has no tick delta to
measure, falls back to kDefaultDt and latches ClockOffset against a
burst width that is wrong whenever the cadence is not 1 kHz -- 89 ms of
permanent displacement at 100 samples per 10 ms, below the
recalibration threshold that would otherwise heal it. Seed both.

Also close the wallElapsed <= 0 bypass in both branches: skipping the
bleed cap when the wall has not moved hands back the full proportional
advance, letting a run of same-tick arrivals gain lead while no wall
time passes at all.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-08-28 05:49:01 +02:00
Martino Ferrari 440b805afd fix(udpscope): make rule 3 converge in both branches and survive reordering 
Eight review findings on FrameDecoder's accumulated-scalar rule.

The squeeze that pulls a leading timeline back was expressed as a fraction of
the NOMINAL burst width, which cannot converge: inside one timestamps() call
the wall clock is frozen, so any positive step raises the lead measured at that
instant, and the lead only falls because the wall advances between packets. At
the kMinBleedFactor floor the timeline still gained 0.05 * nominal per packet,
so a declared SamplingRate of 30 against a producer really flushing 10 samples
at 1 kHz ran away without bound (667 s of lead after 1000 s of stream). Cap the
burst's total advance at half the wall time really elapsed since this signal's
previous burst instead, and the lead strictly falls for any declared rate.
SigState gained lastEmittedWall for that reference; lastPacketWall could not be
reused because it belongs to packetBurst.

The hrt branch contributed zero elapsed for a late datagram but still wrote the
hrt reference back to it, so the next packet's delta spanned two intervals and
fabricated a whole extra packet of producer time — permanently, since the
monotonic clamp discards the correction ClockOffset would have made. Reordering
is reachable in production: udps_client.c only counts counter gaps. Simply
never regressing the reference is not the fix either, because a producer restart
would then freeze the signal forever, so the two are now separated by the size
of the backward jump.

The hrt branch's clamp was also one-directional, reintroducing on that branch
exactly the defect the declared branch's squeeze exists to prevent: a backward
wall step (NTP, suspend/resume) left a permanent lead. It now shares the same
wall-elapsed cap.

Also: anchor an hrt-branch burst's LAST element on arrival, matching the
declared branch, so two accumulated scalars in one scope do not sit a burst
apart on the shared X axis; treat a non-finite samplingRate off the wire as
undeclared, since +inf produced a 0.0/0.0 factor the floor could not catch and
turned every stamp NaN; write lastCounter on the hrt branch so duplicate
datagrams are dropped there too; and correct two comments that argued for the
current code with claims that are false (a counter-gap clamp reaches the
opposite outcome, not the same one earlier, and the squeeze's steady state is a
sawtooth, not a fixed offset).

Seven new tests, each proven non-vacuous by sabotage; 54 pass. Plan document
Task 4 re-synced and its stale test count and "agree on the same stream" claim
corrected.
 2026-08-27 22:43:27 +02:00
Martino FerrariandClaude Opus 4.6 a2efc142c3 fix(udpscope): keep the accumulated-scalar timeline monotonic and bounded 
Round 4 of Task 4 review. Four defects in FrameDecoder's rule 3:

- The undeclared-rate (hrt) path positioned each burst at an ABSOLUTE
  hrt/ticksPerSecond(). hrt counts from the producer's boot, so it is ~1e11
  ticks by the time a scope attaches, and the rate is refitted every packet
  with a few parts in 1e4 of wobble. The product is tens of milliseconds of
  jitter in BOTH directions -- not merely imprecise, non-monotonic. Integrate
  short tick deltas into accProdSec instead and let ClockOffset latch the
  epoch that leaves behind.
- The lead bleed used a fixed 0.9 factor, which converges only while the
  declared rate is within ~10%. Squeeze proportionally to the excess instead
  (floored at kMinBleedFactor), settling it in a single burst.
- A single-sample flush fell through to the plain-scalar rule, dating it from
  arrival and leaving lastCounter stale so the next real burst reinstated a
  hole that never existed. Accumulate mode flushes on a timer, so a short
  cycle legitimately yields one sample; keep it on the chain.
- kMaxCounterGap was inert: an absurd gap yields an absurd prediction that the
  arrival backstop already rejects, and no input can distinguish the two
  rules. Removed rather than left implying a behaviour it did not have.

FrameDecoder.h now states the deliberate divergence from StreamHub -- which
converts hrt with the LOCAL MARTe timer frequency, valid only because it runs
on the producer's host -- and why a remote scope's drift is irreducible.

Three new tests, each sabotage-proven non-vacuous: producer restart, short
flushes staying on the chain, and a 20000-packet undeclared run after a
day of producer uptime that asserts SPACING as well as ordering (the
monotonic guard alone restores order while leaving positions wrong).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-08-27 22:16:11 +02:00
Martino FerrariandClaude Opus 4.6 3270284cfe fix(udpscope): bound the reconstructed timeline against the wall clock 
Round 3 of the Task 4 review. Three defects, all in FrameDecoder rule 3.

The resync backstop was one-directional. `predicted` is never below
lastEmittedEnd + dt, so rejecting a correction that would step backwards
meant only a LAGGING chain could ever be pulled back; a chain running fast
drifted ahead without bound. Two hosts' crystals differ by tens of ppm, so a
declared SamplingRate is always slightly wrong in one direction or the other
and this is certain on a long session. A leading timeline cannot be corrected
in one burst without going backwards -- lastEmittedEnd is by definition past
arrival -- so the excess is bled off by drawing each burst 10 % narrower until
the timeline is back inside the threshold.

A repeated packet counter was treated as a normal packet. The C client
de-duplicates fragments only, so an unfragmented update reaching a host that
joined the group on two interfaces was emitted twice, doubling the values and
advancing the timeline by a burst that never existed.

The samplingRate == 0 path differenced two HrtRateFit::toSeconds() results.
toSeconds() divides an absolute tick count -- ~1e11 on a producer that has
been up a day -- by a rate refitted on every packet, so its few-parts-in-1e4
wobble arrives multiplied by the whole elapsed epoch: tens of milliseconds of
jitter on a value whose consecutive difference is a few milliseconds. Raw
ticks are differenced instead, anchored on the first usable packet so the
wobble applies only to the interval since attach.

The existing hrt-gap test could not have caught the last one: its 10 ms
producer period made the expected answer exactly kDefaultDt, so a decoder
that derived nothing passed. It now uses 25 ms.

Four tests added, all sabotage-proven. The plan is updated to match.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-08-27 21:55:33 +02:00
Martino FerrariandClaude Opus 4.6 7102412a9f fix(udpscope): reconstruct lost accumulated bursts from the packet counter 
Review found the decoder was estimating something the wire states exactly.
FrameView::counter increments once per update, so a gap of g means g-1 lost
datagrams; reinstating their duration restores the hole precisely, with no
threshold and no dependence on arrival time. The arrival-anchor comparison
survives only as a backstop for what the counter cannot express — a producer
restart, a counter stuck at zero, a wrong declared rate — and can no longer
step a signal's timestamps backwards, which the ring and trigger forbid.

Also from review: guard the time-signal lookup against a frame carrying more
signals than the installed table, and give FrameBuilder a counter parameter.
Leaving it at zero had hidden the counter rules from every test, and made the
hrt-gap test vacuous — under uniform arrivals the hrt path and packetBurst
agree by construction, so it could not tell which branch answered. Its
arrivals now carry zero-mean jitter.

Each new assertion was proven non-vacuous by sabotage: dropping the gap term,
the backward guard, or the hrt branch fails exactly its own test.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-08-27 20:16:52 +02:00
Martino FerrariandClaude Opus 4.6 892e3eae28 fix(udpscope): bound accumulated-burst chaining so packet loss cannot displace the trace 
Forward-chaining each accumulated burst onto the previous one suppresses
arrival jitter, but an unchecked chain never recovers: one lost datagram, or a
declared sampling rate that differs from the producer's real one, dates every
later sample early for the rest of the run. The chain is now a prediction,
compared each packet against the arrival anchor and abandoned beyond
kBurstResyncThresholdS, which bounds the error instead of accumulating it.

Plan amended so the hrt-fit fallback (unusable here: the fit needs 32 packets
and is itself corrupted by bursty arrivals) cannot come back.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-08-27 20:08:05 +02:00
Martino FerrariandClaude Sonnet 4.6 5a8479cda9 feat(udpscope): per-element timestamp reconstruction from UDPS frames 
Implements FrameDecoder with five timing rules that mirror
UDPSourceSession.cpp: FullArray (per-element time signal), FirstSample
and LastSample (rate-spread from anchor), accumulated scalar with
declared rate (forward-chain anchoring, immune to arrival jitter), and
PACKET burst (backward-span from previous arrival). 9 new tests, 38
pass total.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-27 20:01:30 +02:00
Martino FerrariandClaude Opus 4.6 c89decef8e docs: say that HrtRateFit::toSeconds returns producer-epoch, not wall, seconds 
The fit keeps the slope and discards the intercept, so the result counts from
the producer's boot. Tasks 4 and 7 compose it with ClockOffset::map, which is
correct, but the bare name invites passing it straight to a plot axis.

Also unwrapped the stalled-clock assertion from behind `if (fit.ready())` —
that branch never runs, so the test confirmed nothing.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-08-27 19:55:24 +02:00
Martino FerrariandClaude Opus 4.6 e4817dd284 fix(udpscope): keep the clock-offset recalibration threshold symmetric 
The jitter test fed a receive timestamp that went backwards (1001.02 then
1000.97), putting the second reading 1.03 s from the prediction — twice the
threshold, so not jitter under any reading. That is a digit slip for 1001.97.

It had been worked around by making the threshold one-sided, which passes the
test but never fires when the producer's clock steps forward: the prediction
stays ahead of the wall clock, the error stays negative, and the trace sits in
the future for the rest of the run. Restored std::fabs, corrected the test data,
and added the forward-jump case that the one-sided version silently failed.

Plan amended so the bad data does not come back.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-08-27 19:52:41 +02:00
Martino FerrariandClaude Sonnet 4.6 41ab151a2f feat(udpscope): producer-clock calibration and hrt tick-rate fit 
Adds TimeBase.h/cpp with ClockOffset (latched wall-clock offset with
one-sided recalibration on positive drift only, so early-arriving packets
do not wobble the trace) and HrtRateFit (sliding-window OLS that recovers
an unknown hrt tick rate from receive timestamps). Also adds
TimeSignalScale() which maps UDPS type codes to seconds-per-count.
9 new tests, all 28 pass.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-27 19:50:24 +02:00
Martino FerrariandClaude Opus 4.6 ea9689591d test: add coverage for closeLeaf's two untested branches 
Gap 1: closeLeaf was only tested closing the first sibling; added test
closing the second sibling to cover the else branch of parent->a.get()==leaf.
The test verifies the correct sibling survives with its signal intact.

Gap 2: closeLeaf was only tested at depth 1 (root's direct children);
added test with depth-2 leaf (in right subtree) to exercise findParent's
recursive search in both subtrees. Tests that the correct leaf is promoted
and remaining signals are preserved.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-08-27 19:46:29 +02:00
Martino FerrariandClaude Sonnet 4.6 0e5d103e73 feat(udpscope): BSP pane tree with split, close and hit-testing 
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-27 19:42:09 +02:00
Martino FerrariandClaude Opus 4.6 c1029a25df fix(udpscope): make the time-order test actually exercise the swap, guard the font copy 
The ramp data in EmitsPointsInTimeOrder never produced a bucket whose maximum
preceded its minimum, so an implementation ordering the emitted pair by value
instead of by time would have passed. Replaced with an explicit two-bucket case
whose second bucket reverses the order.

file(COPY) is a hard configure error on a missing source, so a checkout without
the sibling StreamHub resources failed to configure despite the ASCII-icon
fallback the block above had just selected.

Plan amended to match on both points.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-08-27 19:39:14 +02:00
Martino FerrariandClaude Sonnet 4.6 fba4360c80 feat(udpscope): build scaffold and min/max envelope decimation 
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-27 17:27:41 +02:00
Martino FerrariandClaude Opus 4.6 2d62e1808b docs: fix six cross-task defects found in the UDPScope plan pre-flight 
Each of these would have surfaced as a compile/link failure or a reviewer
rejection mid-execution, when the implementer holding the task has no view of
the neighbouring task that contradicts it.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-08-27 17:07:08 +02:00
Martino FerrariandClaude Opus 4.6 cf815e1d3f docs: implementation plan for the UDPScope direct-UDPS oscilloscope 
Eighteen TDD tasks covering the build scaffold, pane tree, time base, frame
decoding, trigger FSM, threading, UI, persistence and export, so the scope can
be built task-by-task with a reviewable deliverable at each step.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-08-27 16:35:41 +02:00
Martino FerrariandClaude Opus 4.6 52958cf8bc docs: design for UDPScope, a direct-to-streamer ImGui oscilloscope 
A bench scope that attaches straight to one UDPStreamer through the
standalone C client, so it can be dropped on a machine with no StreamHub,
no Go and no browser. Records the decisions that are easy to get wrong:
the time-base rules must follow UDPSourceSession rather than the C
library's arrival-time estimate, decimation must be min/max rather than
LTTB so glitches survive, and the ring must be sized past the trigger
window by an explicit harvest margin.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-08-27 11:28:54 +02:00
Martino FerrariandClaude Opus 4.6 7c5eb31a52 feat: standalone C/C++ UDPS client library 
Consuming a UDPStreamer feed so far meant either linking MARTe2 (UDPSClient)
or writing Go (Common/Client/go/udpsprotocol). Common/Client/c fills the gap
for plain C/C++ integrators: two files depending on nothing but libc and BSD
sockets, covering the whole receive path — CONNECT, fragment reassembly,
CONFIG/DATA decoding with dequantisation, keepalives and silence-triggered
reconnect. No threads are spawned; udps_client_poll() does all the work and
runs every callback, so it drops into an existing event loop unsynchronised.

Verified against run_udp_producer.sh at 1 Msps: unicast (120 MiB, no loss) and
multicast with 12-fragment cycles (116k datagrams, no loss).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-08-22 16:51:40 +02:00
Martino Ferrari e03c60db25 Implemented and fixed many issues 2026-08-21 23:24:48 +02:00
Martino FerrariandClaude Sonnet 4.6 14d5351a81 fix: UDPSClient uses two-arg Join so multicast receiver lands on the right interface 
UDPSClient::ConnectMulticast was calling the single-arg BasicUDPSocket::Join,
which forwards NULL as the local interface and lets the kernel bind to
INADDR_ANY.  On a multi-homed host (or when the server sends on loopback via
Interface = "127.0.0.1") the client joins the wrong interface and silently
receives nothing.

Fix: read the optional Interface key inside the useMulticast block in
UDPSClient::Initialise; in ConnectMulticast call the two-arg
Join(group, interface) when Interface is set, and fall back to the one-arg
call otherwise to preserve the existing INADDR_ANY behaviour for configs that
omit it.

Forward the new optional Interface key through UDPStreamerClient (read from
DataSource config, written into the UDPSClient ConfigurationDatabase only
when non-empty).  Extend the "Joined multicast group" log to report the
interface name or "default".

Regression test TestExecute_MulticastReceivesDataOnInterface: mock TCP
control listener + multicast UDP DATA socket with IP_MULTICAST_IF set to
127.0.0.1, verifying a uint32 value of 424242 reaches DataSource signal
memory.  Confirmed FAILED without the Join fix and PASSED with it.

Suite: 133/133 (was 132/132 before this commit).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-17 08:23:41 +02:00
Martino FerrariandClaude Opus 4.6 61a2aa3988 docs: Interface takes an interface IP, not an interface name 
UDPSServer parses Interface with inet_addr() to set IP_MULTICAST_IF, so
a name like "eth0" yields INADDR_NONE and Initialise fails. Every
example in UDPStreamer.md used "eth0", so anyone following the docs hit
that failure; the .cfg files in Test/ already used a dotted-quad.

Replace the examples with 192.168.1.10, state the dotted-quad
requirement in the parameter table and the Multicast section, and note
that receivers must join on the matching interface or they silently
receive nothing.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-08-17 08:09:21 +02:00
Martino FerrariandClaude Opus 4.6 c827ecefff test: fix UDPStreamer multicast tests broken by mandatory Interface 
Commit 3e0a481 made Interface mandatory for multicast in both
UDPStreamer::Initialise and UDPSServer::Initialise and updated
Docs/UDPStreamer.md, but left the GTest configs untouched. All four
multicast tests have failed since.

Add Interface to the five multicast configs. The field is parsed with
inet_addr(), so it takes a dotted-quad, not an interface name; 127.0.0.1
keeps the tests self-contained and off the LAN.

TestInitialise_MulticastMode_InvalidDataPort was passing for the wrong
reason: UDPStreamer.cpp rejected it on the missing Interface before the
DataPort == Port check could run. It now proves what its name claims.

TestExecute_MulticastConnectDataDisconnect additionally needed the
two-argument Join(): the single-argument form passes INADDR_ANY, so the
reader joined the default-route interface while the server sent on
loopback via IP_MULTICAST_IF, and the DATA datagram never arrived.

GTest: 132/132 (was 128/132), multicast subset stable over 3 runs.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-08-17 08:06:35 +02:00
Martino FerrariandClaude Opus 4.6 72c286db33 chore: untrack SDD scratch reports 
These subagent handoff artifacts were committed before
.superpowers/sdd/.gitignore took effect. They are ephemeral
scratch, not project content.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-08-17 08:01:09 +02:00
Martino Ferrari 7aba1260be Merge branch 'feature/signal-calibration-config' 
Per-signal data calibration (value = raw * scale + offset) with an optional
unit override, plus sources+calibration persistence in a single config file,
implemented identically in the Go hub and the C++ StreamHub.
 2026-08-17 08:00:09 +02:00
Martino FerrariandClaude Sonnet 4.6 1f8592f854 fix: address all 9 findings from final calibration code review 
- calibration.js: fix baseSignalName('[0]') parity with Go/C++ (>= 0 not > 0)
- calibration.test.js: add assertions for '[0]' edge case in two existing tests
- app.js: remove stale typeof guard around refreshVScaleMenu (always defined)
- app.js: call refreshTrigThresholdField on trig-signal change (both assignment sites)
- index.html: drop maxlength='16' on unit input; normaliseCal is the sole enforcer
- configcheck/main.go: delete dead nextOneOf function (no callers)
- hub_calibration_test.go: delete orphaned waitBroadcast comment (function never existed)
- calibration.go: correct arrayIndexSuffix comment to document known Go/C++ difference
- Docs/StreamHub-API.md: add calibration entry count and unit byte limits to §5 table
- spec: fix configReloaded missing path field, '16 chars'→'16 UTF-8 bytes', StreamString→char[], chain scenario→configcheck program, four→five new frames

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-17 07:57:28 +02:00
Martino FerrariandClaude Sonnet 4.6 42f5a726af fix: three StreamHub C++ defects from final code review 
Finding 1 (HandleReloadConfig data loss): move ClearCalibration inside
LoadSourcesFile so the table is wiped only after a successful fread.
Adds a clearCalibration bool parameter (default false); the reload path
passes true, the startup path passes false.

Finding 2 (JSON injection via unit/source/signal): add JsonEscape()
static helper (escapes \", \\, \n \r \t, and \u00XX for other control
chars). Applied at all three emission sites: BroadcastCalibration,
HandleSaveSources, and BroadcastSources (label). Teach JsonGetString to
unescape the same set on read, so values round-trip correctly.

Finding 3 (%.17g verbosity): add ShortFloat() static helper that tries
%.15g then %.16g then %.17g, stopping at the first precision whose
strtod() output compares equal to the original. Applied at both float
emission sites. 0.1 now prints as "0.1", not "0.10000000000000001".

Minor: fix two inaccurate comments in StreamHub.h — the CalibrationEntry
rationale (not a 133 MB / address-limit issue; the real reason is no
per-entry heap churn, STL-free, trivially copyable) and "chars" to "bytes"
for the unit cap.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-17 07:50:01 +02:00
Martino FerrariandClaude Sonnet 4.6 686fc2ce7d docs: fix three review findings in calibration documentation 
- Finding 1 (Critical): replace "16 chars" with "16 UTF-8 bytes" in the
  setCalibration unit field description (StreamHub-API.md) and the Cal·Unit
  toolbar row (WebUI.md); note that multi-byte characters consume more than
  one byte and that truncation never splits a character.

- Finding 2 (Important): correct the claim that a sources broadcast after
  reloadConfig is conditional on new sources being added — that is true only
  of the Go hub. The C++ hub calls BroadcastSources() unconditionally on
  success. Both the reloadConfig command description and the configReloaded
  event description in StreamHub-API.md are updated; the Reload bullet in
  WebUI.md is updated with a brief note. Clients must tolerate an unsolicited
  sources frame after any reload.

- Finding 3 (Minor): the configSaved failure example used "no SourcesFile
  configured", which matches neither hub. Corrected to the C++ form
  "no sources file configured" and added a note that the exact error text
  is not part of the protocol contract (Go uses "no sources-file configured").

Source evidence: calibration.go (maxUnitLen, len(), rune-repair loop),
StreamHub.cpp (kMaxUnitLen, byte strncpy, HandleReloadConfig unconditional
BroadcastSources, HandleSaveSources error string).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-17 07:34:48 +02:00
Martino FerrariandClaude Sonnet 4.6 d26b78b7f6 docs: document per-signal calibration and config save/reload 
Update Docs/StreamHub-API.md (new setCalibration/reloadConfig commands,
calibration/configSaved/configReloaded events, §4 config file format),
ARCHITECTURE.md §6 (updated command/event tables and Config File Format
subsection), Docs/WebUI.md (Cal row in V-Scale Toolbar, Sources & Config
sidebar section). Also corrects the spec's Validation sentence to match
the shipped cal-invalid border behaviour instead of silent field revert.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-17 07:27:25 +02:00
Martino FerrariandClaude Sonnet 4.6 e37eec0276 webui: add the Sources & Config sidebar section 
Renames the "Add Source" section to "Sources & Config" and replaces the
fire-and-forget "Save list" button with Save and Reload, plus a one-line
status area that renders the hub's configSaved/configReloaded ack.

onConfigAck replaces the no-op stub Task 7 left behind. It branches on the
frame type because configSaved carries a path and configReloaded does not,
and surfaces the hub's error text on failure rather than failing silently.
The status is kept outside the DOM because buildSidebar() recreates this
section on every sources broadcast.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-17 07:23:08 +02:00
Martino FerrariandClaude Sonnet 4.6 5917ab1bf2 Restore calibration parity: revert unit-stripping from normaliseCal, fix CSV quoting at export 
Finding 1: revert the comma/quote strip added in 3cb998c from
normaliseCal() in calibration.js. The strip broke byte-identical parity
with Go CalConfig.Normalise and C++ StreamHub::SetCalibrationEntry, both
of which only trim whitespace and cap at 16 UTF-8 bytes. Delete the
companion test that asserted the now-removed behaviour (suite returns to
18 tests).

Finding 2: fix the actual CSV-safety problem at the point of use in
exportAllCSV() in app.js. Header cells (time column and signal columns)
are now RFC 4180-quoted: wrapped in double quotes with any embedded
double quote doubled. This safely handles units or signal names that
contain commas or quotes without touching normaliseCal.

Finding 3: update two stale comments in app.js that called the trigger
threshold or rawFromNorm result 'raw' — Task 9 moved trig.threshold into
calibrated units throughout, so the comments now say 'calibrated'.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-17 01:15:13 +02:00
Martino FerrariandClaude Sonnet 4.6 3cb998c5da webui: calibrate CSV export, trigger threshold and unit display 
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-17 00:55:07 +02:00
Martino FerrariandClaude Sonnet 4.6 4908c039a5 fix(webui): keep cal-invalid styling on focused field during hub broadcast 
refreshVScaleMenu() was unconditionally removing the cal-invalid class
from all three calibration inputs, which silently cleared the red-border
error indicator on a field the user was editing whenever a hub
calibration broadcast arrived. Apply the same focused-element guard
already used for .value writes so a rejected value's error styling
persists until the user corrects it.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-17 00:52:04 +02:00
Martino FerrariandClaude Sonnet 4.6 4e3a90b2c6 webui: add calibration editor to the V-Scale toolbar 
Adds the Cal row (Scale / Offset / Unit / Reset) to #vscale-menu, its
CSS, and the refreshVScaleMenu() / commitCal() logic that wires it to
calTable and the hub via setCalibrationWS.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-17 00:48:39 +02:00
Martino Ferrari 0e9ec61226 webui: apply per-signal calibration to the whole display path 2026-08-17 00:43:18 +02:00
Martino FerrariandClaude Opus 4.6 7312dd0ca0 docs(calibration.js): explain why one UTF-8 repair pass suffices in JS 
TextEncoder always emits well-formed UTF-8, so truncation can strand at
most a lead byte plus three continuations — one repair pass covers it.
The C++ hub needs a loop because its input is raw bytes off the wire.
Also drops a dead variable from the byte-boundary test.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-08-17 00:41:00 +02:00
Martino FerrariandClaude Opus 4.6 48d62c1f80 fix(calibration.js): cap unit at 16 UTF-8 bytes, matching both hubs 
normaliseCal was using String.length/.slice() (UTF-16 code units), so
multi-byte characters like °, Ω, µ could slip through oversized. Now uses
TextEncoder to slice at 16 bytes, then repairs any incomplete trailing
UTF-8 sequence by walking back over continuation bytes to find the lead
byte and dropping the incomplete rune — exactly mirroring Go's
utf8.DecodeLastRuneInString loop and the C++ walk-back in
StreamHub::SetCalibrationEntry. Adds 4 new test cases covering the
non-ASCII/boundary scenarios, and corrects the canonical test command in
the task-6 report to 'cd Client/udpstreamer && node --test'.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-08-17 00:36:01 +02:00
Martino FerrariandClaude Sonnet 4.6 21d084d2ea webui: add pure calibration module with unit tests 
Implements Calib JS module (calibration.js) with affine transform primitives,
CalTable, and normaliseCal matching Go CalConfig.Normalise semantics; 14 node
--test cases all pass. Loads before app.js in index.html.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-17 00:29:53 +02:00
Martino FerrariandClaude Sonnet 4.6 b1c2a34eea test(configcheck): harden frame-strictness, sort-order, and document BroadcastSources difference 
Fix round 1 review findings:

1. Frame-matching strategy: add protocolFrameTypes set; next() now fails immediately
   on an out-of-order protocol frame instead of silently discarding it. Ambient
   frames (data, stats, triggerState, monotonicState) are logged and skipped.
   nextSkipping() accepts explicitly-listed protocol frames that legitimately differ
   in order across hubs (connect-time "sources" before "calibration" in C++).

2. BroadcastSources documented exception: the extra "sources" frame C++ emits after
   reload is accepted and logged as [KNOWN DIFFERENCE] with full rationale; the
   report recommendation to remove it has been retracted (it is required for correct
   client-side source-list updates after reload-with-new-sources).

3. Sort-order constraint exercised: three calibration entries submitted in
   reverse-sort order (src2/Beta, src1/Zeta, src1/Alpha); each broadcast and the
   saved config file are asserted to be sorted by source then signal.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-17 00:26:12 +02:00
Martino FerrariandClaude Sonnet 4.6 73ba725d8f test: add cross-hub calibration and config-persistence parity checker 
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-17 00:14:15 +02:00
Martino FerrariandClaude Sonnet 4.6 bdc74f5fd2 StreamHub: loop UTF-8 tail repair to match Go CalConfig.Normalise() 
The single-pass repair left invalid bytes when the candidate lead byte
had class 0 (illegal 0xF8-0xFF bytes, or a bare continuation byte
reached after the 3-byte backward-scan cap). Convert to a loop with a
`cut` flag mirroring Go's loop: each iteration either makes no cut
(exits) or strictly reduces ulen by >= 1 byte (terminates in <= 16
iterations). Also treat expected==0 as a cut target, matching Go's
behaviour of stripping any byte that decodes as an invalid one-byte
sequence.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-17 00:06:45 +02:00
Martino FerrariandClaude Sonnet 4.6 93e00d0c21 fix(StreamHub): correct UTF-8 tail repair to run only after truncation 
The previous walk-back in SetCalibrationEntry was unconditional, corrupting
short valid units ending in multi-byte characters (e.g. Omega, mu, degree).
Also failed to drop an orphaned lead byte left after stripping continuation
bytes. Restructured to use a 256-byte staging buffer so truncation can be
detected, then repair runs only in the truncation branch. Algorithm now
matches Go CalConfig.Normalise() exactly: scan back over continuation bytes
(up to 3), find the lead byte, derive expected sequence length, cut if
incomplete. Covers all cases: orphaned continuation, orphaned lead, cut on
lead byte.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-17 00:02:33 +02:00
Martino FerrariandClaude Sonnet 4.6 2f9b135c62 task-4-report: append Fix round 1 section 
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-16 23:55:49 +02:00
Martino FerrariandClaude Sonnet 4.6 957be793ae StreamHub: fix calibration trim, UTF-8 unit truncation, and sort order 
Finding 1: Add TrimInPlace helper; apply trim→strip-[i]→empty-check order
in SetCalibrationEntry (matching Go Normalise()), so whitespace-padded
source/signal from WS clients normalise identically to config-file loads.

Finding 2: Trim unit before truncating to kMaxUnitLen, then walk back
continuation bytes (0x80-0xBF) to avoid leaving a partial UTF-8 rune,
matching Go's utf8.DecodeLastRuneInString loop.

Finding 3: BroadcastCalibration and HandleSaveSources now emit entries
sorted by source then signal (insertion sort over an index array, no STL),
producing byte-identical calibration frames and config files to the Go hub.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-16 23:55:46 +02:00
Martino FerrariandClaude Sonnet 4.6 cdafb877a3 StreamHub: per-signal calibration, config reload, whitespace-tolerant JSON 
- Add CalibrationEntry (heap-allocated array[256], char[] fields to stay within
  the 133 MB struct's canonical address limit) plus calibrationMutex_ and
  numCalibration_.
- Implement SetCalibrationEntry/ClearCalibration, BroadcastCalibration,
  BroadcastConfigAck, HandleSetCalibration, HandleReloadConfig.
- Wire setCalibration and reloadConfig into OnWSCommand dispatch.
- Broadcast calibration to each newly connected client after triggerState.
- Fix JSON round-trip bug: replace JsonGetString/JsonGetBool helpers with a
  shared whitespace-tolerant JsonFindValue (tolerates "key" : "value" as
  written by HandleSaveSources); add JsonIsFinite (no <cmath>).
- Extend LoadSourcesFile(bool skipActive) to also parse calibration blocks;
  SourceIsActive checks live sessions before starting a duplicate.
- Extend HandleSaveSources to persist calibration blocks; emit configSaved ack.
- Reload semantics: calibration replaced wholesale, sources added only.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-16 19:56:44 +02:00
Martino FerrariandClaude Sonnet 4.6 ffe7cb1cc5 wshub: add setCalibration/reloadConfig frames and config acks 
Wire five new WebSocket frames into hub.go: setCalibration (client→hub),
calibration (hub→client broadcast), reloadConfig (client→hub), configSaved and
configReloaded (hub→client acks with ok/path/error). Extend hubCmd with cal
field, add buildCalibrationMsg and buildConfigAckMsg builders, send calibration
on client connect, and run Save/Reload on separate goroutines to avoid blocking
the Run() select loop.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-16 19:36:09 +02:00
Martino FerrariandClaude Sonnet 4.6 dfd257cfd9 wshub: persist calibration alongside sources; add config reload 
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-16 19:27:23 +02:00
Martino FerrariandClaude Sonnet 4.6 66efd74dd5 wshub: fix CalConfig.Normalise parity gaps vs C++ twin and JS client 
Finding 1: strip trailing [digits] array-element suffix from Signal so one
calibration entry covers an entire array signal, matching the C++ strchr
truncation and the JS equivalent.

Finding 2: after the 16-byte Unit truncation, drop any trailing partial UTF-8
rune so json.Marshal never emits replacement characters; keeps byte limit in
sync with C++ strncpy(u, unit, kMaxUnitLen).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-08-16 19:21:41 +02:00
Martino Ferrari 47f1567a26 wshub: add per-signal calibration store and flat config-file codec 2026-08-16 19:16:22 +02:00
Martino Ferrari 6d26e8191c docs: implementation plan for per-signal calibration and persistent hub config 2026-08-16 19:14:34 +02:00
Martino FerrariandClaude Opus 4.6 5ab1721df5 docs: spec per-signal calibration and persistent hub config 
Design for a per-signal affine calibration (scale/offset/unit) applied
client-side and stored server-side alongside the source list, so signals in
raw units can be read in engineering units and the setup survives a reload.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-08-16 18:17:07 +02:00
Martino Ferrari 2370848994 added trigger 2026-08-13 10:28:56 +02:00
Martino Ferrari ff5ad22447 included jitter correction on client 2026-08-13 10:28:43 +02:00
Martino Ferrari a49ab5ba25 Added silence timeout as floating point 2026-08-10 17:18:50 +02:00
Martino Ferrari 1ddb4fe356 Implemented hearthbit client side + tests 2026-08-09 18:51:51 +02:00
Martino Ferrari 915a192b16 fixed multicast updated tests 2026-07-25 16:46:25 +02:00
Martino Ferrari 3e0a481c13 added interface and added join to multicast 2026-07-25 12:26:51 +02:00
Martino Ferrari 2d5ca20ae4 minor changes and addeed debug tests 2026-07-02 16:27:40 +02:00
Martino Ferrari f2042d624b Implemented full e2e testing 2026-07-02 10:10:57 +02:00
Martino FerrariandClaude Opus 4.6 f8c79131c9 docs: refresh run_e2e.sh flag list in AGENTS.md 
Task 7 added --skip-coverage/--skip-stress/--skip-datasources/
--skip-recorder/--skip-debug/--skip-tcplogger but the AGENTS.md table row
was never updated to mention them; it also still listed a --stress flag
that has never existed. Sync with the script's actual --help output.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-07-02 00:04:22 +02:00
Martino FerrariandClaude Opus 4.6 28d149f536 fix(e2e): assert real FORCE/TRACE/BREAK acks in the debug scenario 
The final whole-branch review found runDebugScript only checked
mc.IsConnected() after sending FORCE/TRACE/BREAK/UNFORCE -- a liveness
check that would PASS even if DebugService silently no-op'd every command
(e.g. a signal-name/wire-format bug), undercutting the design's stated
rationale for this scenario ("catching wire-format/serialization bugs the
in-process suite cannot"). This mirrors the tautology already fixed for
the tcplogger scenario in an earlier task, but had not been applied here.

Added waitForAck(), which polls the sink's recorded "text_line" events for
DebugServiceBase::HandleCommand's real "OK <TOKEN> <count>\n" reply and
requires count > 0 -- HandleCommand prints this for every one of
FORCE/UNFORCE/TRACE/BREAK regardless of enable/disable direction, and
count is always "number of signals actually matched", so count==0 means
the signal path was never resolved. Verified with a real negative control
(temporarily pointing all commands at a nonexistent signal name): the
scenario now correctly FAILs, then reverted and reconfirmed PASS against
the real signal.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-07-02 00:03:47 +02:00
Martino FerrariandClaude Opus 4.6 9a39cf923a fix(e2e): isolate coverage-pass WORK dir; filter chain-only e2e report section 
The final whole-branch review (post Task 10) found two real cross-task
integration bugs:

- run_e2e.sh's coverage-instrumented scenario re-run only rebound OUT_DIR
  in its subshell, not WORK. proc_perf.py/plots.py write perf_*.json and
  wave_*.png into WORK, so every --cpp-coverage run (the default) silently
  clobbered the primary pass's perf/waveform data with the instrumented
  re-run's numbers before report_build.py read them -- defeating the
  "uncontaminated performance metrics" goal of the coverage-double-run
  design. Fixed by rebinding WORK the same way OUT_DIR already was.

- report_build.py's build_e2e() iterated all results["scenarios"] with no
  kind filter, so the direct/recorder/debug/tcplogger scenarios (already
  covered by their own dedicated report sections since Task 8) also leaked
  into the chain-only Scenarios/Performance sections and headline e2e
  pass/fail count as degenerate rows. Fixed by filtering to kind=="chain".

Verified end-to-end with a full ./run_e2e.sh run: coverage pass now writes
to /tmp/chain_e2e/coverage_pass/ (confirmed via log), and report_data.json's
e2e section now reports 51 (chain-only) scenarios instead of all 56.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-07-01 23:59:54 +02:00
Martino FerrariandClaude Opus 4.6 07b6b4898a fix(e2e): rebuild test binaries when restoring non-instrumented build 
The post-coverage restore step ran `make clean` (which also wipes
Test/GTest, Test/Integration and Test/Components/*) but only rebuilt
`core apps`, leaving MainGTest.ex/IntegrationTests.ex deleted after
every --cpp-coverage run instead of restored to their plain (non-gcov)
form.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-07-01 22:55:48 +02:00
Martino Ferrari 03c7a95e9b docs: fix stale run_combined_test.sh comment in combined_test.cfg 
Minor follow-up from Task 9's retirement review.
 2026-07-01 22:08:21 +02:00
Martino Ferrari 45dcb9a71f docs: fix remaining dangling references to retired run_e2e_test.sh 
README.md and Docs/StreamHub-Developer.md still pointed at the deleted
run_e2e_test.sh / Test/E2E/streamhub Go client after their removal in the
previous commit; repoint at Test/E2E/suite/run_e2e.sh.
 2026-07-01 22:05:29 +02:00
Martino Ferrari 4286ea4539 chore(e2e): retire streamhub/datasources/recorder standalone scripts superseded by run_e2e.sh 2026-07-01 22:04:08 +02:00
Martino FerrariandClaude Opus 4.6 8337d678be feat(e2e): render direct/recorder/debug/tcplogger/stress sections in the unified report 
Extends report_build.py with build_by_kind() (per-scenario-kind pass/fail
rollup) and a ported build_stress()/stress_headline()/stress_plots() (scaling
curves per stress axis), wires both into the headline KPIs, regression
tracking, and report_data.json. E2E_Report.typ renders the four new
per-kind tables plus a Stress Tests section (per-axis case tables + scaling
plots, gracefully degrading to placeholders when a kind/stress data is
absent). run_e2e.sh now passes --stress-results so the report actually
receives real stress data instead of silently omitting it.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-07-01 21:57:11 +02:00
Martino Ferrari b65ac06ce2 feat(e2e): instrument-first coverage flow with double-run + new skip flags; port stress multi-fragment sizing 2026-07-01 21:07:03 +02:00
Martino FerrariandClaude Opus 4.6 83d0a060fe feat(e2e): add debug/tcplogger E2E scenario kinds using debugclient 
Adds a trimmed debug_e2e.cfg (DebugService on 8080/8081, TcpLogger on
9090) and two new scenarios (s55_debug_force_trace_break, kind=debug;
s56_tcplogger_delivery, kind=tcplogger) reusing it, with matching
run_e2e.sh scenario-list/dispatch wiring and debugclient build steps.

Also fixes a real bug found while wiring s56: debugclient's tcplogger
check was tautological (it matched MarteController's own local
"CMD"-level echo of the outgoing command, which contains the same text
as the triggered event, instead of a line actually delivered over the
real TCPLogger TCP socket) and its trigger command (an invalid FORCE)
never reaches DebugServiceBase's REPORT_ERROR at all. Switched the
trigger to a MSG-to-missing-destination command (which does call
REPORT_ERROR) and the match to require the real log text
("not found in ORD"), recorded only after a connect-settle baseline —
verified with a positive run (real Warning-level TCPLogger line
received) and a negative control (LogPort=0 disables TcpLogger and the
scenario correctly FAILs).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-07-01 19:36:47 +02:00
Martino Ferrari efb4ea48fb feat(e2e): add debugclient Go tool for DebugService/TCPLogger E2E scenarios 
Standalone headless client that drives a running MARTeApp.ex's
DebugService (TCP 8080 commands, UDP 8081 trace) and TCPLogger (TCP
9090) via marte2debugger/controller's NewHeadlessMarteController, for
the upcoming Test/E2E/suite "debug"/"tcplogger" scenario kinds. Scripts
FORCE/TRACE/BREAK for -mode debug, and triggers+waits for a TCPLogger
log event for -mode tcplogger; reports PASS/FAIL as
result_<scenario>.json/status_<scenario>.txt in -out.
 2026-07-01 19:18:34 +02:00
Martino Ferrari f0f83110a4 fix(debugger): extract MarteController into an importable controller package 
Client/debugger was entirely package main, which Go forbids importing from
another module ("is a program, not an importable package") -- discovered
while wiring the new debugclient E2E tool against NewHeadlessMarteController.
Move martecontrol.go and its test into a new marte2debugger/controller
subpackage (package controller) and update Client/debugger/main.go to call
controller.NewMarteController/controller.DangerousCommandsEnabled. No
behavioral change to the browser-facing server.
 2026-07-01 19:18:08 +02:00
Martino Ferrari 269b2c4d97 refactor(debugger): extract MarteController sink so it can run headless 
Add a sink func(v any) field so MarteController's event stream can be
routed somewhere other than the browser WebSocket hub. NewMarteController
now sets sink to broadcast through the hub as before; a new
NewHeadlessMarteController(sink) constructor builds an instance with
hub == nil for the upcoming debugclient E2E tool. Direct m.hub.* calls
(SetSourceState/UpdateConfigForSource/PushDataForSource) are now guarded
with nil checks so a headless controller doesn't panic.
 2026-07-01 19:12:41 +02:00
Martino FerrariandClaude Opus 4.6 1d78b45963 feat(e2e): dispatch direct/recorder scenario kinds in run_e2e.sh 
Extends the scenario-list builder and main loop to actually execute
s52_direct_unicast/s53_direct_multicast (self-contained single-MARTeApp
FileReader->UDPStreamer->UDPStreamerClient->FileWriter round trip) and
s54_recorder (StreamHub BinaryRecorder round trip, ported from
run_recorder_e2e.sh) alongside the existing chain scenarios, and tags
each results.json record with its scenario kind.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-07-01 19:06:30 +02:00
Martino Ferrari ef58553c63 feat(e2e): add kind discriminator + direct/recorder scenario definitions 2026-07-01 18:51:18 +02:00
Martino Ferrari 69e52af20b refactor(e2e): rename Test/E2E/chain -> Test/E2E/suite, run_chain_e2e.sh -> run_e2e.sh 2026-07-01 18:42:33 +02:00
Martino Ferrari 1fcc4e4e6d fix(streamhub-test): unblock make test by fixing BoundsCheckTest C++98 build and registering both orphaned GTest files 2026-07-01 18:34:16 +02:00
Martino FerrariandClaude Opus 4.6 462b05b71a docs(testing): implementation plan for unified test/E2E/reporting/coverage pipeline 
Plan derived from the approved 2026-07-01 design spec; covers scenario
kind unification (chain/direct/recorder/debug/tcplogger), instrument-first
double-run coverage, and DebugService/TCPLogger E2E via debugclient.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-07-01 18:29:29 +02:00
Martino FerrariandClaude Opus 4.6 dcaa466736 docs(testing): design for unified test/E2E/reporting/coverage pipeline 
Consolidates the fragmented chain/stress/streamhub/datasources/recorder
E2E suites, unit-test collection, and coverage into one entry point and
one report, adds new DebugService/TCPLogger E2E coverage, and fixes the
Test/Applications/StreamHub build break blocking `make test`.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-07-01 18:14:09 +02:00
Martino Ferrari 0bea41f866 Implemented better testing and fixed skipepd frames 2026-07-01 16:39:34 +02:00
Martino FerrariandClaude Sonnet 4.6 7a326c5d78 test(gtest): wire DebugServiceGTest into the shared MainGTest binary 
Add DebugServiceGTest.cpp (TraceRingBuffer, DebugSignalInfo, BreakOp
regression coverage for the HI-4/HI-9 fixes) to Test/GTest's OBJSX so it
builds and runs as part of ./Build/x86-linux/GTest/MainGTest.ex alongside
the rest of the unit suite. 17/17 tests pass.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
 2026-07-01 09:34:20 +02:00
Martino FerrariandClaude Opus 4.6 036dd4a656 docs(e2e-stress): implementation plan for stress suite report integration 
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-06-26 09:11:19 +02:00
Martino Ferrari 4702d0a217 Implemented qt port + e2e 2026-06-26 09:11:10 +02:00
Martino FerrariandClaude Opus 4.6 0d7d8f396b docs(e2e-stress): design for stress suite report integration 
Track the existing (untracked) stress matrix, extend the signal-size axis
into the multi-fragment regime now that the UDPSClient reassembly cap is
1 MiB, and wire stress results into the E2E PDF report via an opt-in
--stress flag (table + per-axis scaling curves + regression vs prior run).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-06-26 09:05:21 +02:00
Martino FerrariandClaude Opus 4.6 f256a4def5 test(e2e-chain): orchestrator + end-to-end fixes (Task 7) 
Full-chain orchestrator (run_chain_e2e.sh) now runs the starter set green
(3 pass). Fixes found bringing the chain up end-to-end:

- client: gorilla/websocket cannot survive a read deadline (next ReadMessage
  panics "repeated read on failed connection"); replace the poll-with-deadline
  loop with a background reader goroutine + mutex-guarded state.
- orchestrator: guard env.sh's unbound LD_LIBRARY_PATH under set -u.
- scenarios/gen_data: centralize NUM_ROWS/ROW_DT and enforce sine freq to be a
  multiple of the buffer fundamental (LOOP_HZ=5 Hz) so the looped FileReader
  buffer is a seamless waveform; align starter freqs (5/5/10 Hz).
- gen_cfg: FileReader allows exactly one consuming Function, so route tapped
  (oracle=fed/both) sources through the DDB (ReaderGAM->DDB, then StreamGAM and
  TapGAM both read DDB) instead of a second FileReader consumer.
- validate_waveform: fidelity gates correctness (bit-exact / within one quant
  level); sine shape becomes a gross frequency-sanity gate (corr>=0.5) plus a
  tracked corr/nRMSE quality metric, since per-sample wall-clock calibration
  (Phase-A) and FULL_ARRAY packed timestamps (Phase-A4) are still pending.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-06-25 13:11:35 +02:00
Martino FerrariandClaude Opus 4.6 d4fa84d482 test(e2e-chain): report plot generation 
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-06-25 09:07:13 +02:00
Martino FerrariandClaude Opus 4.6 d35a78778e test(e2e-chain): per-effect waveform validator 
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-06-25 09:05:56 +02:00
Martino FerrariandClaude Opus 4.6 aa6679f1a7 test(e2e-chain): Go mock client (record + zoom/window/trigger) 
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-06-25 09:04:04 +02:00
Martino FerrariandClaude Opus 4.6 f146fc1016 test(e2e-chain): MARTe + StreamHub config generator 
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-06-25 09:01:20 +02:00
Martino FerrariandClaude Opus 4.6 10dec4c5d2 test(e2e-chain): deterministic typed/shaped data generator 
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-06-25 08:58:49 +02:00
Martino FerrariandClaude Opus 4.6 0ab49078cc test(e2e-chain): scenario model + starter scenarios 
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-06-25 08:56:57 +02:00
Martino FerrariandClaude Opus 4.6 f46b2dfb14 test(streamhub): add binary recorder E2E scenario 
End-to-end test streaming three float32 signals via a MARTe2 UDPStreamer
app into a standalone StreamHub with the recorder enabled, then validating
the recorded FileWriter-compatible .bin against the streamed input with
validate_binary.py. All recorded rows are byte-identical to input rows.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-06-25 01:20:16 +02:00
Martino FerrariandClaude Opus 4.6 8664b24e82 chore(streamhub): add disabled +Recorder block to run_streamhub.sh demo cfg 
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-06-25 01:13:54 +02:00
Martino FerrariandClaude Opus 4.6 19e649aa38 feat(streamhub): parse +Recorder config and add recorder WS commands 
Parse the optional +Recorder block in Initialise (Enabled/AutoStart/
Directory/MaxFileMB/KeepFiles/StagingMB/FlushIntervalSec/MinDiskFreeMB/
Signals, MB->bytes), apply it to each session before Start (static and
dynamic sources). Drive recorder disk I/O from the push loop via
RecorderFlushTick, and add recStart/recStop/recInfo WS commands plus a
recStatus broadcast/snapshot.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-06-25 01:13:23 +02:00
Martino FerrariandClaude Opus 4.6 93fc11c88f feat(streamhub): wire BinaryRecorder into UDPSourceSession 
Each session owns a BinaryRecorder. The receive thread configures the
recorder layout at CONFIG time and captures each data packet; the push
thread performs all file I/O via RecorderFlushTick. WS subset overrides
are adopted through an epoch-deferred handoff mirroring the trigger path.
Arm/disarm/flush/info are exposed for StreamHub-level control.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-06-25 01:10:27 +02:00
Martino FerrariandClaude Opus 4.6 0ae35d11ff feat(streamhub): BinaryRecorder core (header, encode, rows, flush, rotation) 
Add a FileWriter-compatible per-source binary recorder: native-type encode
and TypeDescriptor mapping, FileWriter header serialization, subset/quantized/
ACCUMULATE row serialization, and push-thread double-buffer flush with size-cap
rotation, keep-N pruning, fdatasync cadence, disk-free and staging-overflow
guards. Covered by 12 GTests; full suite (83) green.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-06-25 01:05:32 +02:00
Martino FerrariandClaude Opus 4.6 e3b458ed94 Add implementation plan for StreamHub binary recorder 
Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-06-25 00:52:54 +02:00
Martino Ferrari 0412c20edd Implemented client datasource 2026-06-25 00:45:45 +02:00
Martino FerrariandClaude Opus 4.6 dca4872976 Add design spec for StreamHub binary recorder 
Lossless packet-decode capture to FileWriter-compatible per-source binary
files with size-capped rotation, config + WS control, and double-buffered
flush on the push thread (Approach C).

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
 2026-06-25 00:45:25 +02:00
469 changed files with 108862 additions and 4805 deletions
Expand all files Collapse all files
AGENTS.md
+244
View File
@@ -0,0 +1,244 @@
# Repository Guidelines
Guide for AI assistants working in the MARTe2 Integrated Components repository.
Focuses on non-obvious facts: commands, conventions, cross-module contracts, and
gotchas that are not self-evident from a single file read.
## Project Overview
MARTe2 component library with **two independent real-time data paths** sharing
one binary wire protocol (`Common/UDP/UDPSProtocol.h`):
1. **Streaming path** — `UDPStreamer` DataSource serialises DDB signals into UDPS
binary packets on UDP → `StreamHub` (headless C++ hub: ring buffers, LTTB
decimation, trigger FSM, history writer, binary recorder) → WebSocket 8090 →
clients (browser SPA, native ImGui, native Qt).
2. **Debug path** — `DebugService` patches `ClassRegistryDatabase` at
`Initialise()` so `ConfigureApplication()` wraps all `MemoryMap*Broker` types
with `DebugBrokerWrapper<T>` — **zero application code changes**. Exposes
TCP 8080 (text commands), UDP 8081 (UDPS trace telemetry), TCP 8082
(`TcpLogger` log forward).
## Architecture & Data Flow
```
[SineArrayGAM/TimeArrayGAM] → DDB → UDPStreamer (UDPS over UDP)
├─→ UDPStreamerClient (input DS back into a MARTe2 RT app, round-trip)
└─→ StreamHub: UDPSourceSession (receive thread → SignalRingBuffer)
→ push loop @30Hz: LTTB decimate temporal sigs → WS binary frames → clients
DebugService: patches broker builders at Initialise(); TCP 8080 commands,
UDP 8081 telemetry, TcpLogger 8082 (REPORT_ERROR → "LOG <LEVEL> <desc>" lines)
```
- **Wire protocol**: `Common/UDP/UDPSProtocol.h` is the canonical spec (17-byte
packed header, magic `0x53504455` 'UDPS', 136-byte signal descriptors,
CONFIG/DATA/ACK/CONNECT/DISCONNECT packet types, quant/time/publish modes).
Deliberately MARTe2-free so Go clients reuse it. **Mirrored across four
codebases that must stay in sync**: C++ producers (UDPStreamer, DebugService),
C++ consumer (`Source/Components/Interfaces/UDPStream/UDPSClient`), Go decoder
(`Common/Client/go/udpsprotocol/protocol.go`), and JS parsers
(`Client/udpstreamer/static/`, `Client/debugger/static/`). Any protocol change
must be mirrored in all of them.
- **WS protocol** has two implementations — Go hub (`Common/Client/go/wshub`) and
C++ StreamHub — that must behave identically; every client (SPA, ImGui, Qt)
must satisfy both. JSON text frames for commands/events (`addSource`,
`removeSource`, `setTrigger`, `arm`, `zoom`, `historyZoom`, `recStart`…), binary
frames for data pushes (live v1 + trigger capture v2).
- **Threading model**: RT threads only spinlock+memcpy (`FastPollingMutexSem`);
all socket I/O, fragmentation, and reassembly lives on background
`SingleThreadService` threads. StreamHub: per-session UDPSClient receive
threads + WS accept/read threads + one push loop.
- **DebugService patching**: `PatchRegistry()` replaces the ObjectBuilder for 11
`MemoryMap*Broker` classes; runs only when `ControlPort > 0`; static guard
against double-patching; wrappers persist for process lifetime.
## Key Directories
| Path | Purpose |
|---|---|
| `Source/Components/DataSources/UDPStreamer/` | Output DataSource; UDP I/O on bg thread, RT thread only spinlock+memcpy in `Synchronise()` |
| `Source/Components/DataSources/UDPStreamerClient/` | Input DataSource (shared `UDPSClient`), double-buffered ready/scratch |
| `Source/Components/GAMs/` | `SineArrayGAM` (float32 sine, continuous phase), `TimeArrayGAM` (us-timer → per-sample timestamp array; `Anchor = FirstSample|LastSample|Continuous`, use `Continuous` for contiguous sources so a lost RT cycle cannot hole the time base) |
| `Source/Components/Interfaces/DebugService/` | Registry patching, `DebugBrokerWrapper.h`, TCP/UDP services |
| `Source/Components/Interfaces/TCPLogger/` | `LoggerConsumerI` forwarding `REPORT_ERROR` to ≤8 TCP clients |
| `Source/Components/Interfaces/UDPStream/` | Plain-C++ helpers (not MARTe2 Objects): `UDPSClient` (auto-reconnect + fragment reassembly), `UDPSServer` (not thread-safe — owner's Execute thread only) |
| `Source/Applications/StreamHub/` | Standalone app (links MARTe2 core): `StreamHub`, `UDPSourceSession`, `WSServer`, `TriggerEngine`, `HistoryWriter`, `BinaryRecorder`, `LTTB`, `SignalRingBuffer` |
| `Common/UDP/` | Canonical wire protocol (header-only, MARTe2-free) |
| `Common/Client/go/` | Go mirror: `udpsprotocol` (decoder), `wshub` (WS hub client) |
| `Client/udpstreamer/` | Go legacy direct-UDP oscilloscope web UI (connects straight to UDPStreamer, no StreamHub) |
| `Client/webui/` | Go thin static server; SPA talks WS directly to C++ StreamHub (discovers via `GET /hub`) |
| `Client/debugger/` | Go debug web UI for DebugService |
| `Client/streamhub/` | Native ImGui+SDL2+OpenGL oscilloscope (C++17, no MARTe2) |
| `Client/streamhub-qt/` | Native Qt Widgets oscilloscope (Qt6 preferred, Qt5 fallback) |
| `Test/` | GTest, legacy Integration tests, Configurations (.cfg), E2E suite |
| `Docs/` | Per-component reference: `Protocol.md`, `UDPStreamer.md`, `StreamHub-{API,UserGuide,Developer}.md`, `DebugService.md`, `WebUI.md`, `Tutorial.md`, `E2E-Suite.md` |
## Development Commands
`source env.sh` is **mandatory** before any MARTe2 build or run (sets
`MARTe2_DIR`, `MARTe2_Components_DIR`, `TARGET=x86-linux`, `LD_LIBRARY_PATH`).
The E2E scripts source it themselves; a bare `make` from a fresh shell will not
work. `run_streamhub.sh` hard-errors if `MARTe2_DIR` is unset.
```bash
source env.sh
make -f Makefile.gcc core # 7 components (UDPStream interface FIRST, then UDPStreamer, UDPStreamerClient, GAMs, TCPLogger, DebugService)
make -f Makefile.gcc apps # StreamHub standalone app → Build/x86-linux/StreamHub/StreamHub.ex
make -f Makefile.gcc test # GTest + Integration test binaries + component test libs
make -f Makefile.gcc all # core + apps + test
make -f Makefile.gcc clean
# Single component:
make -C Source/Components/GAMs/SineArrayGAM -f Makefile.gcc
```
Build output → `Build/x86-linux/` mirroring `PACKAGE` paths (both `libX.so` and
`X.so` are produced). `compile_commands.json` (repo root, gitignored) feeds
LSP/clangd; CMake clients export their own into `Client/*/build/`.
### Non-MARTe2 clients (no env.sh needed)
```bash
cd Common/Client/go && go build ./...
cd Client/debugger && go build ./...
cd Client/streamhub && cmake -B build -DCMAKE_BUILD_TYPE=Release && cmake --build build
cd Client/streamhub-qt && cmake -B build && cmake --build build
```
### Key scripts
| Script | Purpose |
|---|---|
| `./run_streamhub.sh` | Demo stack: build + launch MARTe2 app + StreamHub, optional web (`-w`) / ImGui (`-g`) clients. Flags `-m/-c` MARTe2 dirs, `-b TARGET`, `-p WS_PORT`, `-n MAX_POINTS` (actual default 1000000, header says 10000), `-s` skip build. Generates temp hub cfg with `+History`/`+Recorder` blocks in `/tmp`. Ctrl-C kills all. |
| `./Test/E2E/suite/run_e2e.sh` | Full E2E: 57-scenario matrix + stress + unit suites + gcov coverage + Typst PDF report. Flags: `--skip-build`, `--only <id>`, `--pdf-only`, `--skip-coverage`, `--skip-stress`, `--skip-datasources`, `--skip-recorder`, `--skip-debug`, `--skip-tcplogger` |
| `./Test/E2E/suite/run_stress.sh` | Capacity harness: sweeps one load axis at a time (`--axis`), hard gates survival+liveness, soft gates RSS+zoom-p95 |
## Code Conventions & Common Patterns
- **No STL in `Source/Components/**` (and StreamHub)**: use `StreamString` (not
`std::string`), `FastPollingMutexSem`/`EventSem` (not `std::mutex`/threads),
fixed arrays / MARTe2 `Vector<T>` (not `std::vector`), `REPORT_ERROR` /
`REPORT_ERROR_STATIC` macros (no exceptions). C stdlib is fine. Heap
`new`/`delete[]` is normal. STL/C++17 is fine in `Client/streamhub/` and
`Client/streamhub-qt/`.
- **RT hot-path rule**: `FastPollingMutexSem` on real-time hot paths, never OS
mutexes; RT cycle must not block on the scheduler.
- **Class registration**: `CLASS_REGISTER_DECLARATION()` in the class `public:`
section of the header; `CLASS_REGISTER(Name, "1.0")` at the end of the `.cpp`
inside `namespace MARTe`. Every component `.cpp` ends with it.
- **EUPL v1.1 license headers** on all C++ sources and `Makefile.inc` — preserve
on new files.
- **Per-component build**: each dir has one-line `Makefile.gcc` wrapper
(`include Makefile.inc`) + `Makefile.inc` declaring `OBJSX`, `PACKAGE`,
`ROOT_DIR`, `INCLUDES` (re-declared per file, ~12 MARTe2 layer dirs),
`LIBRARIES`, including `MakeStdLibDefs.$(TARGET)` then
`MakeStdLibRules.$(TARGET)`. Generated `depends.x86-linux` (gcc -MM) is
committed but **never hand-edited** — delete to regenerate.
- **Qt client**: `QT_NO_KEYWORDS` is required (reused `Protocol.h` structs have
members named `signals`); Qt classes use `Q_SIGNALS`/`Q_SLOTS`/`Q_EMIT`. Run
with long options: `--host HOST --port 8090` (single-dash misparsed). Single
GUI thread, 60 Hz QTimer repaint.
- **StreamHub config** is *not* a MARTe2 `RealTimeApplication`: `Hub = { WSPort
MaxPoints PushRate MaxPushPoints RingTemporal RingScalar RingMaxMB AllowedOrigins
+Recorder{...} Sources={id={Label Addr Port}} }`. `AllowedOrigins` is the
WebSocket Origin allowlist — without it a browser serving the SPA from a
different port than the hub is rejected 403.
`+History` keys: `Directory` (required),
`DurationHours` (1), `Decimation` (1), `FlushIntervalSec` (5),
`MinDiskFreeMB` (500). `.shist` files: 64-byte header ('SHR1') + circular
(t,v) float64 pairs.
- **UDPStreamer config**: `Port` (44500; multicast data = `DataPort`, default
`Port+1`), `MaxPayloadSize` (1400), `PublishingMode` `Strict`/`Accumulate`,
per-signal `Signals={Name={Type,Unit,NumberOfDimensions,NumberOfElements,
TimeMode}}` with `TimeMode` `PacketTime`/`FirstSample`/`LastSample`/`FullArray`;
multicast needs `MulticastGroup` + `Interface`.
## Important Files
- `env.sh` — environment; source first, always.
- `Makefile.gcc` / `Makefile.inc` (root) — build orchestration.
- `Common/UDP/UDPSProtocol.h` — canonical wire format; changing it triggers the
4-way mirror checklist above.
- `Source/Applications/StreamHub/main.cpp` — hub entry (`[-cfg file.cfg]
[-port N] [-maxPoints N]`); hub **must be heap-allocated** (~128 MB, exceeds
the 8 MB stack).
- `Test/Configurations/*.cfg` — MARTe2 app configs (`$App = { Class =
RealTimeApplication }` with `+Functions`, `+DataSources`, `+States`, `+Timings`
blocks); `streamhub_demo.cfg` and `TestApp.cfg` are good templates.
- `Test/E2E/suite/{scenarios,gen_data,gen_cfg,validate_waveform,stress}.py` —
declarative scenario matrix and generators consumed identically by the Go
chain-client and validators.
- `Client/debugger/main.go` — `-addr :7777` default, `-enable-dangerous-commands`
safety gate (CR-4) for FORCE/PAUSE/RESUME/STEP/BREAK/MSG.
## Runtime/Tooling Preferences
- **OS**: Linux x86_64 (`TARGET=x86-linux`). External deps live outside this
repo: `MARTe2_DIR` (default `~/workspace/MARTe2`) and
`MARTe2_Components_DIR` (default `~/workspace/MARTe2-components`) — edit
`env.sh` if they differ. `env.sh`'s `LD_LIBRARY_PATH` does **not** cover
UDPStreamerClient/UDPStream lib dirs.
- **C++**: MARTe2 `Makefile.gcc` wrapper system, gtest-1.7.0 for tests.
- **Go**: `go 1.21`; modules use `replace marte2/common => ../../Common/Client/go`
(`gorilla/websocket` v1.5.1). Go binaries are gitignored.
- **ImGui client**: needs SDL2; CMake FetchContent pins Dear ImGui **v1.91.8** +
ImPlot **v0.17** (`implot_items.cpp` is a slow -O3 TU, ~2 min rebuild).
- **Qt client**: Qt6 preferred, Qt5 fallback, Widgets + WebSockets, custom
QPainter plotting (no QtCharts).
- **E2E report**: `typst compile E2E_Report.typ`; Python 3 + numpy for the suite.
- Remove `vgore.*` core dumps when you see them; they are not gitignored.
## Testing & QA
Four test layers; `env.sh` + built stack required for all but the standalone
ones. Only `tests_py.py`, Go tests, and the built C++ test binaries run
standalone.
```bash
./Build/x86-linux/GTest/MainGTest.ex --gtest_filter='Name*' # C++ GTest
./Build/x86-linux/Test/Integration/Integration/IntegrationTests.ex # legacy DebugService runtime tests
cd Test/E2E/suite/client && go test ./... # Go chain-client unit tests
cd Test/E2E/suite && python3 -m unittest tests_py # framework logic, standalone
```
- **GTest**: `MainGTest.ex` currently holds only `DebugServiceGTest`
(TraceRingBuffer SPSC, DebugSignalInfo, BreakOp). Component GTests
(`UDPStreamerGTest.cpp` ~46 cases, `StreamHubTest.a`, `UDPStreamerClientTest.a`)
compile **as libraries only — no standalone executable**.
- **Legacy IntegrationTests.ex**: 9 printf-narrated DebugService runtime tests,
always returns 0; `collect.py` parses stdout blocks.
- **E2E suite** (`run_e2e.sh`): 57 curated scenarios (s01–s57) across kinds
`chain`/`direct`/`recorder`/`debug`/`debug_pause_resume`/`tcplogger`, driven
against live MARTeApp.ex + StreamHub.ex + Go chain-client. `scenarios.py` is a
curated covering set: **every configurable UDPStreamer option value appears in
≥1 scenario** — add a scenario when adding an option.
- **Oracle gates** (`validate_waveform.py`): **fidelity** (every received value
within `tol` of ground truth; 0 for un-quantised ints, float epsilon for
un-quantised floats, `quant_step/2 + 1e-6·range` for quantised) is the
**correctness gate**. **Shape** is a *gross* sanity gate + tracked metric
(`corr >= 0.5`, `nRMSE <= 0.30` relaxed by quant step, frequency searched
±5% band); a correct sinusoid yields corr ~0.82–0.98, wrong frequency
collapses to ~0.00. Do **not** tighten shape into a correctness gate —
timestamp calibration (Phase-A) is pending.
- **Stress** (`run_stress.sh`): 7 axes (signal size/count/fan-out/sources/WS
clients/zoom rate), hard gates survival+liveness, soft gates RSS+zoom-p95.
- **Coverage**: `--cpp-coverage` rebuilds with gcov, captures via `lcov`
restricted to `Source/*` + `Test/*`, then restores a clean build.
- Artifacts → `Build/x86-linux/E2E/chain/`: `results.json` (XFAIL/XPASS for
`known_issue` markers), `report_data.json`, `history.jsonl`, `trend_*.png`,
`E2E_Report.pdf`; stress → `stress/stress_results.json`.
## Ports Reference (defaults)
| Port | Protocol | Component | Purpose |
|---|---|---|---|
| 44500 | UDP | UDPStreamer | scalar signals (unicast control + data) |
| 44501/44502 | UDP | UDPStreamer | packed arrays (FirstSample/LastSample, FullArray) |
| 44503 | UDP | UDPStreamer | multicast data (group 239.0.0.1) |
| 8080 | TCP | DebugService | text command channel (one client at a time, newline-terminated) |
| 8081 | UDP | DebugService | trace telemetry (UDPS format) |
| 8082 | TCP | TcpLogger | REPORT_ERROR log forward |
| 8090 | TCP/WS | StreamHub | WebSocket (commands + binary data) |
| 7777 | TCP | Client/debugger | debug web UI (older docs say 9090; current flag is `-addr`) |
| 8080 | TCP | Client/udpstreamer, Client/webui | web UI listen (collides with DebugService in combined demos — scripts adjust) |
ARCHITECTURE.md
+127 -4
View File
@@ -314,7 +314,7 @@ Hub-side trigger with the web client's semantics (config: signal key
```
IDLE →[arm]→ ARMED
ARMED →[edge crossing]→ COLLECTING (latches trigTime, pre/postSec)
COLLECTING →[post window + margin elapsed]→ TRIGGERED (broadcast binary v2 capture)
COLLECTING →[every source produced past the window]→ TRIGGERED (broadcast binary v2 capture)
TRIGGERED →[auto-rearm (normal, ~200 ms) | rearm (single)]→ ARMED
any →[disarm]→ IDLE
```
@@ -325,6 +325,30 @@ sample of the configured signal. The capture is assembled in the push loop from
LTTB-capped at 20 000 points/signal, and broadcast as a binary version-2 frame.
A `stopped` flag (`trigStop`) freezes auto-rearm.
COLLECTING is left on the **data's** clock, not `clock_gettime()`: `trigTime`
comes from sample timestamps, and a source that free-runs on its own clock sits
seconds away from wall time, so a wall-clock deadline chops exactly that offset
off every capture's tail. `UDPSourceSession::ProducerNewestTime()` reports how
far a source has produced — counting only signals actually timestamped from a
time signal, since PACKET-timed ones (the time array itself included) are
stamped on arrival and would just report "now".
Sources are harvested **one at a time**, each as soon as *it* passes
`trigTime + postSec + 0.15 s` (`BeginTriggerCapture` / `HarvestTriggerCapture` /
`FinishTriggerCapture`, the frame accumulating across push ticks). Making every
source wait for the slowest lets the leaders' rings roll past the pre-trigger
region before it is ever read. A 2 s wall-clock watchdog per capture bounds the
wait for a source that stopped advancing; it is harvested short, with a warning
naming the source and how far it got.
Because `RingTemporal` only holds ~1 s at 1 MSps, `setTrigger` publishes the
requested window and the push loop calls `GrowRingsForTrigger()`: each ring
measures its own rate (`Count() / TimeSpan()` — UDPS sources usually report
`samplingRate = 0`) and is grown in place to `rate × (window + 0.5 s) × 1.2`,
clamped per signal to `RingMaxMB`. `SignalRingBuffer::Grow()` preserves
contents *and* `totalWritten`, so live push cursors stay valid. Without this a
long window only ever captures its tail.
### Configuration File (MARTe2 cfg format)
```
@@ -334,9 +358,11 @@ Hub = {
PushRate = 30 // push loop Hz
MaxPushPoints = 50 // LTTB cap per signal per tick
StatsRate = 1 // stats broadcast Hz
RingTemporal = 1000000 // ring capacity (points) for multi-element signals
RingTemporal = 1000000 // initial ring capacity (points) for multi-element signals
RingScalar = 100000 // ring capacity (points) for scalar signals
RingMaxMB = 128 // per-signal ceiling when a trigger window grows a ring
SourcesFile = "streamhub_sources.json" // dynamic-source persistence
AllowedOrigins = "http://127.0.0.1:8099,http://localhost:8099" // see below
Sources = {
App1 = {
Label = "MARTe2 App 1"
@@ -358,6 +384,16 @@ Sources added at runtime (`addSource`) get generated ids `s1, s2, …`;
`saveSources` persists them to `SourcesFile` (JSON array of
`{label, addr, multicastGroup?, dataPort?}`), reloaded at start-up.
`AllowedOrigins` is a comma/space-separated allowlist of `scheme://host[:port]`
values accepted in the WebSocket `Origin` header (max 8 entries, 128 chars
each), matching the Go hub's option. Without it the handshake only accepts an
`Origin` whose host matches the request `Host` — so a browser that loaded the
SPA from a *different* port than the hub (the `run_streamhub.sh` layout, SPA on
8099 and hub on 8090) is rejected with 403. Non-browser clients send no `Origin`
and are unaffected. This is the CSWSH guard of RFC 6455 §10.2: browsers attach
cookies to cross-origin WebSocket handshakes, so `Origin` is the only thing
distinguishing a legitimate page from an attacker's.
### Build
```bash
@@ -380,7 +416,9 @@ binary frames carry data push payloads.
| `ping` | — | Hub replies `{"type":"pong"}` |
| `addSource` | `label`, `addr` (`"host:port"`), `multicastGroup?`, `dataPort?` | Connect to a new UDPS source; hub assigns id `s1, s2, …` |
| `removeSource` | `id` | Disconnect and remove a source |
| `saveSources` | — | Persist the current dynamic source list to `SourcesFile` (JSON) |
| `saveSources` | — | Persist the dynamic source list **and** the calibration table to `SourcesFile`; replies `configSaved` |
| `setCalibration` | `source` (label), `signal` (base name), `scale`, `offset`, `unit` | Record `value = raw × scale + offset` for one signal; metadata only, the hub never applies it. Identity entries are deleted. Replies with a `calibration` broadcast |
| `reloadConfig` | — | Re-read `SourcesFile`: calibration replaced wholesale, missing sources added, live sources never touched; replies `configReloaded` |
| `getSources` | — | Trigger `sources` broadcast |
| `getConfig` | `sourceId` | Trigger `config` broadcast for one source |
| `getStats` | — | Trigger `stats` broadcast |
@@ -399,11 +437,33 @@ binary frames carry data push payloads.
| `sources` | `sources:[{id, label, addr:"host:port", state}]` | On connect; after add/remove/getSources; on first CONFIG |
| `config` | `sourceId`, `publishMode`, `signals:[{name, typeCode, quantType, numDimensions, numRows, numCols, rangeMin, rangeMax, timeMode, samplingRate, timeSignalIdx, unit}]` | After CONFIG received from source |
| `stats` | `sources:{id:{state, totalReceived, totalLost, rateHz, rateStdHz, fragsPerCycle, bytesPerCycle, cycleAvgMs, cycleStdMs, cycleMinMs, cycleMaxMs, cycleHistMin, cycleHistMax, cycleHist:[20]}}` | At `StatsRate` Hz |
| `triggerState` | `state` (`"idle"`\|`"armed"`\|`"collecting"`\|`"triggered"`), `mode`, `stopped`, `trigTime?` | On any trigger FSM transition |
| `triggerState` | `state` (`"idle"`\|`"armed"`\|`"collecting"`\|`"triggered"`), `mode`, `stopped`, `trigTime?`, `preSec?`, `postSec?` | On any trigger FSM transition |
| `zoom` | `reqId`, `signals:{"src:sig":{t:[…], v:[…]}}` (`t` printed `%.17g`, `v` `%.9g`) | Unicast reply to `zoom` |
| `maxPointsUpdated` | `maxPoints` | After ring buffer resize |
| `calibration` | `cal:[{source, signal, scale, offset, unit}]` | On connect; after an accepted `setCalibration`; after a successful `reloadConfig` |
| `configSaved` | `ok`, `path`, `error?` | In reply to `saveSources` |
| `configReloaded` | `ok`, `path`, `error?` | In reply to `reloadConfig` |
| `pong` | — | In reply to `ping` |
### Config File Format
`SourcesFile` is a flat JSON array of flat objects; `addr` marks a source,
`signal` marks a calibration entry.
```json
[
{"label": "wave", "addr": "127.0.0.1:44500"},
{"source": "wave", "signal": "Adc", "scale": 0.00030518, "offset": -1.25, "unit": "V"}
]
```
Flatness is a hard constraint: `StreamHub::LoadSourcesFile` scans from each `{`
to the next `}`, so a nested object would truncate the parse. Both hubs read and
write this format identically, and pre-calibration files load unchanged.
Calibration is applied **client-side only**. Rings, history, `zoom` replies, both
binary frames and the trigger comparator are all in raw units.
### Binary Push Frame (version 1, hub → client, binary WS frame)
Little-endian throughout. Sent at `PushRate` Hz per source; contains **only
@@ -498,6 +558,69 @@ cmake --build build -j$(nproc)
---
## 7b. Qt Desktop Client
`Client/streamhub-qt/` is a **native Qt Widgets desktop oscilloscope** — a
feature/UX-equivalent alternative to the ImGui client, speaking the identical
StreamHub WebSocket protocol. It targets deployments that prefer a system Qt
runtime over bundled ImGui/SDL2/OpenGL, and it builds against either Qt6
(preferred) or Qt5 for old-Linux back-compatibility.
### Technology Stack
| Component | Library | Notes |
|-----------|---------|-------|
| UI framework | Qt Widgets | Autodetect Qt6 → Qt5 via `find_package(QT NAMES Qt6 Qt5 ...)`, then `Qt${QT_VERSION_MAJOR}::` targets |
| Time-series plots | Custom `QPainter` (`PlotWidget`) | No QtCharts/QCustomPlot — for ImPlot parity, zero extra deps, EUPL-clean |
| WebSocket client | `QtWebSockets` `QWebSocket` (`WsClient`) | Signals delivered on the GUI thread |
| Wire layer | Reused verbatim from `../streamhub/` | `Protocol.{h,cpp}`, `SignalBuffer.h` (framework-free C++17) |
### Threading & keyword model
- **Single GUI thread.** `QWebSocket` text/binary signals arrive on the GUI
thread, so no locks are needed (unlike the ImGui client's background receive
thread + drain). A 60 Hz `QTimer` (16 ms) drives repaint and panel refresh.
- **`QT_NO_KEYWORDS`.** The reused `Protocol.h`/`Model.h` structs have members
named `signals` (e.g. `ZoomResponse::signals`), which collide with Qt's
`signals`/`slots`/`emit` macros. The build defines `QT_NO_KEYWORDS`; all Qt
classes here use `Q_SIGNALS:` / `Q_SLOTS:` / `Q_EMIT` instead. This keeps the
shared wire layer unmodified.
### Components
| File | Responsibility |
|------|----------------|
| `Hub.{h,cpp}` | Domain model + command builders; owns `WsClient`; re-emits parsed events as Qt signals |
| `WsClient.{h,cpp}` | `QWebSocket` wrapper; auto-reconnect (3 s timer) |
| `PlotWidget.{h,cpp}` | One QPainter plot; live/stored/trigger modes, cursors, zoom cache |
| `PlotGrid.{h,cpp}` | Persistent pool of 8 `PlotWidget`s mounted into nested `QSplitter`s per layout |
| `SourceSidebar.{h,cpp}` | `QTreeWidget` of sources/signals; drag source = mime `application/x-shq-signal` carrying `qint32[2]` {srcIdx, sigIdx} (LittleEndian) |
| `TriggerBar.{h,cpp}` | Trigger config/arm controls + state badge |
| `StatsDialog.{h,cpp}` | Per-source stats table + 20-bin QPainter histogram |
| `HistoryBar.{h,cpp}` | Live / pan / jump-ago / show-all history navigation |
| `MainWindow.{h,cpp}` | Toolbars, docks, layout menu, connection controls, 60 Hz tick |
### Build & run
```bash
cd Client/streamhub-qt
cmake -B build # autodetects Qt6, falls back to Qt5
cmake --build build -j$(nproc)
# Produces: build/StreamHubQtClient
# Run (StreamHub must already be running on port 8090)
./build/StreamHubQtClient --host 127.0.0.1 --port 8090
```
> Use long `--host`/`--port` (or short `-H`/`-p`). A single-dash `-host` is
> misparsed by `QCommandLineParser` as clustered short flags.
Verified: builds and links cleanly against both Qt6 (6.11) and Qt5 (5.15); the
Qt6 binary connects to a live StreamHub (server logs *"WebSocket client
connected"*) and runs without error.
---
## 8. Go Client Packages
### `Common/Client/go/udpsprotocol`
BUG_FIX_PLAN.md
+221
View File
@@ -0,0 +1,221 @@
# Bug Fix Plan — Security & Correctness Remediation
**Date:** 2026-06-26
**Based on:** `BUG_REPORT.md`
**Scope:** `Source/` and `Client/`
This plan organizes the ~60 findings from the audit into prioritized, dependency-ordered phases. Each phase is independently shippable. Phases are ordered by risk reduction: Critical remote-exploitable issues first, then High crash/OOB issues, then Medium robustness/DoS, then Low hardening.
---
## Guiding principles
1. **Fix root causes, not symptoms.** The integer-overflow-in-bounds-check pattern appears in 6+ places — fix the pattern, not each instance ad hoc. Introduce a shared `boundsCheck(off, count, elemBytes, bufLen)` helper (C++) and a `validateCount(count, elemSize, bufLen)` helper (Go) and use them everywhere.
2. **Defense in depth.** Origin checks + auth + input validation — not just one layer.
3. **No regressions.** After each phase, run the existing test suites (`make -f Makefile.gcc test`, `python3 -m unittest tests_py`, `go test ./...` in each Go module) and the E2E suite (`./Test/E2E/chain/run_chain_e2e.sh --skip-build`).
4. **Minimal blast radius.** Each fix is surgical to the file/function listed in the bug report. No refactors beyond what the fix requires.
---
## Phase 1 — Critical remote-exploitable fixes (ship first)
**Goal:** Eliminate drive-by takeover and remote heap corruption. All fixes are small and localized.
| # | Bug | File(s) | Fix | Est. effort | Depends on |
|---|-----|---------|-----|-------------|------------|
| 1.1 | CR-1: 1-byte heap OOB write in WS frame NUL-term | `WSServer.cpp:251` | Change `kRecvBuf = WS_MAX_RECV_PAYLOAD + 14u` → `+ 14u + 1u` | 5 min | — |
| 1.2 | CR-2: XSS via unescaped `src.addr` | `Client/udpstreamer/static/app.js:3503`; `Client/debugger/static/app.js:3549` | Wrap `src.addr` with existing `escHtml()` in `_statsKV` calls (or inside `_statsKV` itself) | 10 min | — |
| 1.3 | CR-3: WebSocket CSRF (Origin check disabled) | `Common/Client/go/wshub/hub.go:128`; `Source/Applications/StreamHub/WSServer.cpp:186-239` | **Go:** Replace `CheckOrigin: func(r *http.Request) bool { return true }` with a same-origin check (compare `Origin` header host to `Host` header). Add a configurable allowlist env var for non-local deployments. **C++:** Parse `Origin` header in `UpgradeHTTP`; reject if present and host doesn't match the listen address. | 30 min | — |
| 1.4 | CR-4: Unauthenticated command injection to MARTe2 | `Client/debugger/martecontrol.go:217-263` | Add an allowlist of permitted MARTe2 commands (`DISCOVER`, `TREE`, `INFO`, `LS`, `VALUE`, `TRACE`, `UNTRACE`); reject `FORCE`, `UNFORCE`, `PAUSE`, `RESUME`, `STEP`, `BREAK`, `MSG` unless an explicit `--enable-dangerous-commands` flag is set. Log all forwarded commands. | 1 h | 1.3 |
| 1.5 | CR-5: No auth on DebugService TCP | `DebugService.cpp:276` | (a) Bind TCP server to localhost by default (add `BindAddress` config key, default `127.0.0.1`). (b) Add an optional `AuthToken` config key; if set, require the first line from a client to be `AUTH <token>` before accepting commands. | 2 h | — |
**Validation:** `bash -n` on shell scripts; `go build ./...` in each Go module; `make -f Makefile.gcc core apps`; manual test: open browser console on a cross-origin page and confirm WS to `localhost:8090` is rejected; confirm a crafted 65536-byte WS frame no longer corrupts.
**Commit:** `fix(security): critical remote-exploitable fixes (CR-1..CR-5)`
---
## Phase 2 — High-severity crash / OOB / UAF fixes
**Goal:** Eliminate remote crash and memory-corruption vectors. These are the integer-overflow and concurrency bugs.
### 2A — Integer-overflow bounds checks (uniform pattern)
| # | Bug | File(s) | Fix |
|---|-----|---------|-----|
| 2A.1 | HI-1: DATA bounds check overflow | `UDPSourceSession.cpp:358`; `UDPStreamerClient.cpp:520` | Replace `off + elemsToRead * wireElemBytes > size` with 64-bit arithmetic. Add a `validateBounds(off, count, elemBytes, size)` static helper in `UDPSProtocol.h` and use it in both files. |
| 2A.2 | HI-2: Go unbounded allocations | `protocol.go:121, 229, 325` | Add `validateCount(count, elemSize, bufLen)` in `protocol.go`; call before every `make([]T, n)` that uses a network-derived count. Cap `NumElements()` at 1M. |
| 2A.3 | HI-3: `accumFill` overflow + size calc | `UDPStreamer.cpp:700, 738, 757, 857-860` | (a) Add `if (accumFill >= maxBatchCount) { flush; }` before the write at line 857. (b) Use `uint64` for `maxBatchCount * totalSrcBytes` size calculations. |
| 2A.4 | MD-4: `numRows * numCols` overflow | `UDPSourceSession.cpp:240, 346`; `protocol.go:121` | Use `static_cast<uint64>(numRows) * static_cast<uint64>(numCols)`; cap at 1M. |
| 2A.5 | MD-15: `pairCount * 16u` overflow | `Client/streamhub/Protocol.cpp:77, 117` | Check `pairCount > (len - off) / 16` before multiplication; use `ull` suffix. |
| 2A.6 | HI-6: `FD_SET` overflow | `UDPSServer.cpp:273, 308`; `UDPSClient.cpp:383` | Add `if (fd < FD_SETSIZE)` guard before each `FD_SET`; otherwise skip that client this cycle (or switch to `poll()`, which the codebase already uses elsewhere). |
**Est. effort:** 3 h (pattern is repetitive once the helper exists)
### 2B — Use-after-free and concurrency
| # | Bug | File(s) | Fix |
|---|-----|---------|-----|
| 2B.1 | HI-5: Broadcast vs FreeSlot UAF | `WSServer.cpp:345-366, 432-445` | `FreeSlot` must acquire `clients[idx].writeMutex` before setting `active=false` and deleting `sock`. This ensures `BroadcastText`/`BroadcastBinary` cannot dereference a freed socket. |
| 2B.2 | HI-9: TraceRingBuffer not thread-safe | `DebugCore.h:79-142` | Replace `volatile uint32 readIndex/writeIndex` with `Atomic<uint32>` (MARTe2 `Atomic::Load`/`Atomic::Store`). Ensure `Push` writes data before storing `writeIndex` (release ordering); `Pop` loads `writeIndex` before reading data (acquire ordering). |
| 2B.3 | HI-4: `ProcessSignal` unclamped memcpy + `forcedMask` OOB | `DebugServiceBase.cpp:310, 313-318` | (a) Clamp `size` to `sizeof(signalInfo->forcedValue)` (1024). (b) Cap the array-forcing loop at `min(nEl, 256)`. (c) Validate `nEl <= 256` in `RegisterSignal`. |
| 2B.4 | HI-7: Weak PRNG for WS handshake | `WSClient.cpp:29-31` | Replace `srand(time(nullptr))` + `rand()` with `std::random_device` or `getrandom()`/`/dev/urandom` read. |
| 2B.5 | HI-8: Global registry patching | `DebugServiceBase.cpp:217-242` | (a) Save original builders before patching (`item->GetObjectBuilder()`); store in a static array for restore on destruction. (b) Add a `PatchRegistry` config flag (default `true` for back-compat; document the implication). (c) Guard against double-patching (skip if already patched). |
**Est. effort:** 4 h
**Validation:** `make -f Makefile.gcc test` + `./Build/x86-linux/GTest/MainGTest.ex` + `./Build/x86-linux/Test/Integration/Integration/IntegrationTests.ex` + `python3 -m unittest tests_py` (in `Test/E2E/chain/`) + `go test ./...` (in each Go module). Craft a UDP packet with `numSamples=0x20000001` and confirm no crash. Run the E2E suite: `./Test/E2E/chain/run_chain_e2e.sh --skip-build`.
**Commit:** `fix(security): high-severity crash/OOB/UAF fixes (HI-1..HI-9)`
---
## Phase 3 — Medium-severity robustness / DoS / parser fixes
**Goal:** Harden input validation, fix reassembly logic, and improve WS RFC compliance.
### 3A — UDPS protocol hardening
| # | Bug | File(s) | Fix |
|---|-----|---------|-----|
| 3A.1 | MD-1: `recvMask` too small | `UDPSClient.cpp:544, 592-594` | Enlarge `recvMask` to 64 bytes (512 bits) to match the `totalFragments <= 512` cap. |
| 3A.2 | MD-2: No type matching in reassembly | `UDPSClient.cpp:548-555` | Add `type` field to `ReassemblySlot`; key on `counter && type`. |
| 3A.3 | MD-3: Signal name not null-terminated | `UDPSourceSession.cpp:219-223` | After `memcpy`, force `name[63]='\0'` and `unit[31]='\0'`. |
| 3A.4 | MD-6: No auth on UDP CONNECT | `UDPSServer.cpp:655-723` | Document trust boundary in `Docs/Protocol.md`. Optional: add a `ConnectToken` config key. |
| 3A.5 | MD-13: Reassembler unbounded map growth (Go) | `reassembler.go:41-89` | Add `maxSets = 1024` cap; reject new sets when full. |
| 3A.6 | LO-1: `totalFrags` overflow | `UDPSServer.cpp:541-542` | Validate `payloadSize <= maxPayloadSize * 65535` before the calculation. |
| 3A.7 | LO-17: `bufMutex.Create` unchecked | `UDPStreamer.cpp:119`; `UDPStreamerClient.cpp:149` | Check return value; `REPORT_ERROR` on failure. |
| 3A.8 | LO-19: Reassembler ticker panic | `reassembler.go:93` | Guard `if r.expiry <= 0 { r.expiry = 2 * time.Second }`. |
**Est. effort:** 2 h
### 3B — WebSocket and JSON robustness (C++ clients)
| # | Bug | File(s) | Fix |
|---|-----|---------|-----|
| 3B.1 | MD-16: `readU16`/`readU32` silent failure | `Client/streamhub/Protocol.cpp:21-38` | Change `readU16`/`readU32`/`readF64` to return `bool` (or set an `ok` flag); `ParseBinaryFrame` fails fast on any truncated read. |
| 3B.2 | MD-17: JSON injection in command builders | `Client/streamhub/Protocol.cpp:183-213` | Add a `jsonEscape(str)` helper; use it for all `%s` string interpolations. Switch to `std::string` to avoid truncation. |
| 3B.3 | MD-18: `strstr`-based JSON parsing | `Client/streamhub/Protocol.cpp:296-310, 495, 510` | Migrate `ParseSources`, `ParseZoom`, `ParseStats` to a real JSON parser. **ImGui:** add a minimal JSON parser or vendor a single-header library (e.g. nlohmann/json). **Qt:** use `QJsonDocument`. |
| 3B.4 | MD-19: WS RFC 6455 violations | `WSClient.cpp:204-223` | (a) Reject control frames with `payloadLen > 125`. (b) Implement `CONTINUATION` opcode reassembly (or at least log and drop with a clear message). (c) Echo `CLOSE` frame. |
| 3B.5 | MD-20: Handshake no timeout | `WSClient.cpp:290-301` | Set `SO_RCVTIMEO` to 5s on the socket before the handshake loop. |
| 3B.6 | MD-5: SHA1 latent overflow | `SHA1.h:50`; `WSFrame_client.h:113` | Add `if (len > 119u) return;` guard; use `uint64_t bitLen`; use `std::vector` instead of `new[]`/`delete[]`. |
| 3B.7 | MD-24: `parseCapture` panic | `Test/E2E/chain/client/main.go:140-171` | Add bounds checks before each read, mirroring `parsePush`. |
**Est. effort:** 4 h (3B.3 is the largest item — JSON parser migration)
### 3C — Go hub and debugger hardening
| # | Bug | File(s) | Fix |
|---|-----|---------|-----|
| 3C.1 | MD-10: No WS client cap | `hub.go:367-377` | Track `len(h.clients)`; reject above configurable max (default 32). |
| 3C.2 | MD-11: Silent data loss | `hub.go:346-358` | Add a `droppedCount` atomic counter per channel; expose via `Snapshot()`. |
| 3C.3 | MD-12: SSRF via `addSource` | `hub.go:83-96`; `sources.go:62-67` | Validate `addr` against a configurable allowlist (default: localhost + private RFC1918 ranges; reject link-local/metadata endpoints like `169.254.169.254`). |
| 3C.4 | MD-14: Index panic | `martecontrol.go:543` | Use `strings.TrimPrefix(line, "OK SERVICE_INFO ")` with a length check. |
| 3C.5 | LO-14: `stopCh` double-close | `martecontrol.go:182-189` | Use `sync.Once` for closing `stopCh`. |
| 3C.6 | LO-10: `unsafe.Pointer` aliasing | `hub.go:588-594` | Replace `float64ToBytes` with `binary.LittleEndian` put operations. |
| 3C.7 | LO-11: `+Inf` in JSON | `stats.go:115-116` | Guard `if avg > 0 { si.RateHz = 1.0 / avg } else { si.RateHz = 0 }`. |
**Est. effort:** 2 h
### 3D — TcpLogger and DebugService fixes
| # | Bug | File(s) | Fix |
|---|-----|---------|-----|
| 3D.1 | MD-7: `StringHelper::Copy` overflow | `TcpLogger.cpp:87` | Replace with `strncpy(entry.description, description, MAX_ERROR_MESSAGE_SIZE-1); entry.description[MAX_ERROR_MESSAGE_SIZE-1]='\0';` |
| 3D.2 | MD-8: `volatile` indices + lost wakeup | `TcpLogger.cpp:83-153, 157-158` | Use `Atomic::Load`/`Store` for `writeIdx`/`readIdx`; use `eventSem.ResetWait()` instead of `Wait`+`Reset`. |
| 3D.3 | MD-9: `printf` on RT thread | `TcpLogger.cpp:75-76` | Add a `MirrorToStdout` config key (default `false`); guard the `printf`/`fflush` behind it. |
| 3D.4 | MD-21: Stack buffer + shadowed member | `DebugService.cpp:438, 489` | Remove the local `udpsSampleBuf` (use the member); heap-allocate `cfgBuf`. |
| 3D.5 | MD-23: `configValidated` read without lock | `UDPStreamerClient.cpp:463` | Mark `volatile` or acquire `bufMutex` before reading. |
| 3D.6 | MD-22: Spinlock on RT path | `UDPStreamer.cpp:856, 947-976` | Minimize the RT-side critical section: swap a pointer instead of `memcpy` under the lock. Move the `memcpy` outside the lock (double-buffer pattern). |
| 3D.7 | LO-7: JSON escaping in DISCOVER | `DebugServiceBase.cpp:900-906` | Use the existing `EscapeJson` helper for signal names. |
| 3D.8 | LO-8: `EvaluateBreak` only element 0 | `DebugBrokerWrapper.h:61-86` | Document the limitation in the function comment. |
| 3D.9 | LO-9: `fprintf(stderr)` on init | `DebugBrokerWrapper.h:195-197` | Replace with `REPORT_ERROR`. |
**Est. effort:** 3 h
**Validation:** Full test suites + E2E. For 3B.3 (JSON parser migration), add unit tests for crafted JSON inputs (nested quotes, escaped chars, truncated payloads). For 3A.1/3A.2, add a unit test that sends duplicate high-index fragments and mixed-type same-counter fragments.
**Commit:** `fix(robustness): medium-severity input validation, parser, and DoS fixes (MD-1..MD-24)`
---
## Phase 4 — Low-severity hardening and documentation
**Goal:** Clean up latent bugs, fix doc mismatches, add missing hardening. These are non-urgent but improve code health.
| # | Bug | File(s) | Fix |
|---|-----|---------|-----|
| 4.1 | LO-2: `Stop()` TOCTOU | `WSServer.cpp:104-134` | Replace `Sleep(200ms)` with thread join. |
| 4.2 | LO-3: Spinlock priority inversion | `UDPSourceSession.h`; `WSServer.h` | Document that `FastPollingMutexSem` is only for very short critical sections on same-core RT configs. Consider `MutexSem` for non-RT-contended paths. |
| 4.3 | LO-4: `SignalBuffer` mod-0 | `SignalBuffer.h:36-41` | Guard `push`/`readLast`/`readRange` against `capacity == 0`. |
| 4.4 | LO-5: Misleading "Thread-safe" comment | `SignalBuffer.h:18` | Remove the claim or add internal locking. |
| 4.5 | LO-6: GAM type validation + doc | `SineArrayGAM.cpp:81`; `TimeArrayGAM.cpp:54`; `TimeArrayGAM.h:8,27` | Add `GetSignalType` checks; update `TimeArrayGAM.h` doc from `uint32` to `uint64`. |
| 4.6 | LO-12: Directory listing | `Client/webui/main.go:26` | Disable directory listings (return 404 for directories). |
| 4.7 | LO-13: No security headers | `Client/debugger/main.go:55`; `Client/udpstreamer/main.go`; `Client/webui/main.go` | Add a middleware that sets `X-Content-Type-Options: nosniff`, `X-Frame-Options: DENY`, `Content-Security-Policy: default-src 'self'`. |
| 4.8 | LO-15: `host_`/`port_` race | `WSClient.cpp:48-58` | Protect with `sendMutex_` or make `atomic<uint16_t>` + `std::string` guarded by a small mutex. |
| 4.9 | LO-16: `ReadExactTCP` edge case | `UDPSClient.cpp:474-487` | Add a max-iterations guard. |
| 4.10 | LO-18: `RangeMin < RangeMax` validation | `UDPStreamer.cpp:403-404` | Validate when `quantType != None`; `REPORT_ERROR` if `rangeMax <= rangeMin`. |
**Est. effort:** 2 h
**Commit:** `fix(hardening): low-severity fixes, doc corrections, security headers (LO-1..LO-19)`
---
## Phase 5 — Cross-cutting refactors (optional, post-hardening)
These are not bug fixes but structural improvements that prevent the recurrence of the bug classes found in this audit.
| # | Refactor | Rationale | Est. effort |
|---|----------|-----------|-------------|
| 5.1 | Shared `validateBounds` / `validateCount` helpers | Centralizes the integer-overflow-prevention pattern; prevents future copy-paste bugs | 1 h |
| 5.2 | Real JSON parser in C++ clients (nlohmann/json or Qt's QJsonDocument) | Eliminates the entire class of `strstr`/`snprintf` JSON bugs (MD-16, MD-17, MD-18) | 4 h |
| 5.3 | `poll()`/`epoll` everywhere (replace all `select`+`FD_SET`) | Eliminates the `FD_SETSIZE` limitation entirely (HI-6) | 2 h |
| 5.4 | Auth framework for DebugService + web UIs | Token-based auth shared between the Go web UIs and the C++ DebugService; eliminates the "no auth anywhere" theme | 1 d |
| 5.5 | Fuzzing harness for UDPS protocol parsers | `libFuzzer` or `go-fuzz` harnesses that feed random bytes to `ParseConfig`/`ParseData`/`DecodeElems`/`ParseBinaryFrame`; catches future overflow variants | 1 d |
| 5.6 | Thread-sanitizer and address-sanitizer CI runs | `make CXXFLAGS="-fsanitize=address,undefined"`; `go test -race`; catches UAF and races automatically | 4 h |
---
## Verification checklist (run after each phase)
```bash
source env.sh
# C++ build + tests
make -f Makefile.gcc clean
make -f Makefile.gcc core apps test
./Build/x86-linux/GTest/MainGTest.ex
./Build/x86-linux/Test/Integration/Integration/IntegrationTests.ex
# Go tests (each module)
cd Common/Client/go && go vet ./... && go test ./... && cd -
cd Client/debugger && go vet ./... && go build ./... && cd -
cd Client/udpstreamer && go vet ./... && go build ./... && cd -
cd Test/E2E/chain/client && go vet ./... && go test ./... && cd -
# Python framework tests
cd Test/E2E/chain && python3 -m unittest tests_py && cd -
# Full E2E suite
./Test/E2E/chain/run_chain_e2e.sh --skip-build
# ASan/UBSan smoke test (after Phase 2+)
make -f Makefile.gcc clean
make -f Makefile.gcc CXXFLAGS="-fsanitize=address,undefined -g" core apps
./Build/x86-linux/GTest/MainGTest.ex
```
---
## Timeline summary
| Phase | Scope | Est. effort | Risk reduction |
|-------|-------|-------------|----------------|
| 1 | Critical remote-exploitable (CR-1..CR-5) | ~4 h | Eliminates drive-by takeover + heap corruption |
| 2 | High crash/OOB/UAF (HI-1..HI-9) | ~7 h | Eliminates remote crash + memory corruption |
| 3 | Medium robustness/DoS/parser (MD-1..MD-24) | ~11 h | Hardens input validation + RFC compliance |
| 4 | Low hardening/doc (LO-1..LO-19) | ~2 h | Code health + defense in depth |
| 5 | Cross-cutting refactors (optional) | ~3 d | Prevents recurrence of bug classes |
**Total (Phases 1-4):** ~24 h of focused work. Phase 5 is optional and can be scheduled separately.
BUG_REPORT.md
+1011
View File
File diff suppressed because it is too large Load Diff
CLAUDE.md
+44 -3
View File
@@ -30,11 +30,50 @@ make -C Source/Components/DataSources/UDPStreamer -f Makefile.gcc
cd Common/Client/go && go build ./...
cd Client/debugger && go build ./...
# Standalone C UDPS client library (no MARTe2, libc + BSD sockets only)
cd Common/Client/c && make && make cxxcheck
# ImGui desktop client (not a MARTe2 component; needs SDL2)
cd Client/streamhub && cmake -B build -DCMAKE_BUILD_TYPE=Release && cmake --build build
# Qt desktop client (not a MARTe2 component; needs Qt5 or Qt6 Widgets + WebSockets)
cd Client/streamhub-qt && cmake -B build && cmake --build build
```
End-to-end demo scripts (build + launch full stack, see headers for ports/options): `./run_combined_test.sh`, `./run_streamhub.sh`.
End-to-end demo script (build + launch full stack, see header for ports/options): `./run_streamhub.sh`.
**Streaming-chain E2E suite** (`Test/E2E/suite/`):
```bash
./Test/E2E/suite/run_e2e.sh [flags]
```
Flags:
| Flag | Effect |
|---|---|
| `--skip-build` | Skip C++ component rebuild |
| `--only <id>` | Run a single scenario by ID |
| `--pdf-only` | Just compile the Typst PDF report |
| `--cpp-coverage` | Instrumented gcov rebuild + lcov capture (on by default) |
| `--skip-coverage` | Disable the coverage pass |
| `--skip-stress` | Skip the stress matrix |
| `--skip-datasources` | Skip `direct` scenarios |
| `--skip-recorder` | Skip `recorder` scenarios |
| `--skip-debug` | Skip `debug` and `debug_pause_resume` scenarios |
| `--skip-tcplogger` | Skip `tcplogger` scenarios |
Scenario kinds (defined in `scenarios.py`):
- **chain** — full streaming pipeline: MARTe2 → UDPStreamer → StreamHub → Go `chain-client` (live/zoom/window/trigger). Validates recorded waveform against analytic/fed oracle (`validate_waveform.py`: fidelity gates correctness, sine shape-fit is a gross-sanity gate + tracked metric).
- **direct** — MARTe2 FileReader → FileWriter round-trip, validates binary output.
- **recorder** — MARTe2 → StreamHub with history recorder, validates recorded `.bin` file.
- **debug / debug_pause_resume** — DebugService scenarios via the Go `debugclient`.
- **tcplogger** — TcpLogger scenarios via the Go `debugclient`.
After scenarios, the suite runs unit tests + coverage (`collect.py`: C++ GTest, Go, Python; coverage uses lcov restricted to `Source/*` — the `Test/` harness is excluded), consolidates everything into `report_data.json` with per-field progression/regression vs the previous run and trend plots (`report_build.py`, history in `Build/x86-linux/E2E/chain/history.jsonl`), and compiles a Typst PDF (`E2E_Report.typ`). Artifacts go to `Build/x86-linux/E2E/chain/` (report, logs, PDF) and `/tmp/chain_e2e/` (scratch). Results are aggregated into `results.json` with XFAIL/XPASS handling for known issues.
Python framework unit tests: `python3 -m unittest tests_py` (in `Test/E2E/suite/`).
Build output goes to `Build/x86-linux/` (shared libs per component, `.ex` executables).
@@ -42,10 +81,10 @@ Build output goes to `Build/x86-linux/` (shared libs per component, `.ex` execut
Two independent data paths:
1. **Streaming path**: `UDPStreamer` DataSource serialises signals each RT cycle to UDPS binary packets (UDP 44500, unicast/multicast) → `StreamHub` (`Source/Applications/StreamHub/`, headless C++ app: ring buffers, LTTB decimation, trigger FSM) → WebSocket 8090 → browser (`Client/udpstreamer`, Go) or native ImGui client (`Client/streamhub`).
1. **Streaming path**: `UDPStreamer` DataSource serialises signals each RT cycle to UDPS binary packets (UDP 44500, unicast/multicast) → `StreamHub` (`Source/Applications/StreamHub/`, headless C++ app: ring buffers, LTTB decimation, trigger FSM) → WebSocket 8090 → browser (`Client/udpstreamer`, Go), native ImGui client (`Client/streamhub`), or native Qt client (`Client/streamhub-qt`).
2. **Debug path**: `DebugService` patches the `ClassRegistryDatabase` at `Initialise()` so subsequent `ConfigureApplication()` instantiates `DebugBrokerWrapper<T>` around all `MemoryMap*Broker` types — no application changes. RT hot path goes through `DebugServiceI` (abstract singleton in `DebugServiceI.h`) for forcing/tracing/breakpoints. Exposes TCP 8080 (text commands), UDP 8081 (trace telemetry), works with `TcpLogger` on 8082. Web UI: `Client/debugger` (Go).
**Shared wire format**: `Common/UDP/UDPSProtocol.h` defines the UDPS binary protocol (17-byte packed header, 136-byte signal descriptors, little-endian). It is deliberately MARTe2-free so it's shared by C++ producers (`UDPStreamer`, `DebugService`), the C++ consumer (`Source/Components/Interfaces/UDPStream/UDPSClient`), and the Go decoder (`Common/Client/go/udpsprotocol`). Changes to the protocol must be mirrored across all of these, plus the JS client parsers.
**Shared wire format**: `Common/UDP/UDPSProtocol.h` defines the UDPS binary protocol (17-byte packed header, 136-byte signal descriptors, little-endian). It is deliberately MARTe2-free so it's shared by C++ producers (`UDPStreamer`, `DebugService`), the C++ consumer (`Source/Components/Interfaces/UDPStream/UDPSClient`), the Go decoder (`Common/Client/go/udpsprotocol`), and the standalone C client (`Common/Client/c`, which redeclares the constants rather than including this header, so it stays MARTe-free). Changes to the protocol must be mirrored across all of these, plus the JS client parsers.
**StreamHub WebSocket protocol**: JSON text frames for commands/events, binary frames for data pushes — spec in `ARCHITECTURE.md` §6. The Go hub (`Client/udpstreamer`) and C++ StreamHub implement the identical protocol; both clients (browser JS and ImGui) must stay compatible with both.
@@ -57,3 +96,5 @@ Two independent data paths:
- `FastPollingMutexSem` on RT hot paths (never OS mutexes).
- Each component dir has `Makefile.gcc` (wrapper), `Makefile.inc` (sources/includes), and `depends.x86-linux`/`dependsRaw.x86-linux` (generated dependency files).
- EUPL v1.1 license headers on C++ sources.
**Qt client** (`Client/streamhub-qt/`): native Widgets oscilloscope, feature/UX-equivalent to the ImGui client, speaking the identical StreamHub WebSocket protocol. CMake autodetects Qt6 (preferred) or Qt5 (`find_package(QT NAMES Qt6 Qt5 ...)` then `Qt${QT_VERSION_MAJOR}::` targets) for old-Linux back-compat. It reuses `../streamhub/Protocol.{h,cpp}` and `SignalBuffer.h` verbatim (framework-free C++17); those structs have members named `signals`, which collide with Qt's `signals`/`slots`/`emit` macros, so the build sets `QT_NO_KEYWORDS` and all Qt classes use `Q_SIGNALS:`/`Q_SLOTS:`/`Q_EMIT`. Single GUI thread (QWebSocket signals arrive on the GUI thread, no locks); a 60 Hz QTimer drives repaint. Plotting is custom QPainter (no QtCharts/QCustomPlot) for ImPlot parity and zero extra deps. Run: `./build/StreamHubQtClient --host HOST --port 8090` (long `--` options; single-dash `-host` is misparsed as clustered short flags).
Client/debugger/controller/cmd_gate_test.go
+54
View File
@@ -0,0 +1,54 @@
package controller
import (
"testing"
)
// TestIsDangerousCommand_Force — FORCE is dangerous.
func TestIsDangerousCommand_Force(t *testing.T) {
if !isDangerousCommand("FORCE signal 1.0") {
t.Error("FORCE should be dangerous")
}
}
// TestIsDangerousCommand_Pause — PAUSE is dangerous.
func TestIsDangerousCommand_Pause(t *testing.T) {
if !isDangerousCommand("PAUSE") {
t.Error("PAUSE should be dangerous")
}
}
// TestIsDangerousCommand_Msg — MSG is dangerous.
func TestIsDangerousCommand_Msg(t *testing.T) {
if !isDangerousCommand("MSG target func") {
t.Error("MSG should be dangerous")
}
}
// TestIsDangerousCommand_CaseInsensitive — case-insensitive.
func TestIsDangerousCommand_CaseInsensitive(t *testing.T) {
if !isDangerousCommand("force signal 1.0") {
t.Error("lowercase force should be dangerous")
}
}
// TestIsDangerousCommand_SafeCommand — DISCOVER is not dangerous.
func TestIsDangerousCommand_SafeCommand(t *testing.T) {
if isDangerousCommand("DISCOVER") {
t.Error("DISCOVER should not be dangerous")
}
}
// TestIsDangerousCommand_TraceNotDangerous — TRACE is not dangerous (read-only).
func TestIsDangerousCommand_TraceNotDangerous(t *testing.T) {
if isDangerousCommand("TRACE signal 1") {
t.Error("TRACE should not be dangerous")
}
}
// TestIsDangerousCommand_Empty — empty command is not dangerous.
func TestIsDangerousCommand_Empty(t *testing.T) {
if isDangerousCommand("") {
t.Error("empty command should not be dangerous")
}
}
Client/debugger/martecontrol.go → Client/debugger/controller/martecontrol.go
+102 -19
View File
@@ -1,4 +1,9 @@
package main
// Package controller implements MarteController, the shared TCP/UDP client
// logic that drives a running MARTe2 DebugService+TCPLogger instance. It is
// consumed both by the Client/debugger browser-facing WebSocket server
// (package main, via NewMarteController) and headlessly by the
// Test/E2E/suite/debugclient E2E test tool (via NewHeadlessMarteController).
package controller
import (
"bufio"
@@ -17,6 +22,40 @@ import (
"marte2/common/wshub"
)
// ---------------------------------------------------------------------------
// Command safety gate (CR-4)
// ---------------------------------------------------------------------------
// DangerousCommandsEnabled gates commands that mutate the RT application state
// (FORCE, PAUSE, RESUME, STEP, BREAK, MSG). Set via --enable-dangerous-commands.
var DangerousCommandsEnabled = false
// dangerousCommands is the set of MARTe2 commands that can change signal values
// or alter execution flow. Without --enable-dangerous-commands these are blocked
// from the browser WebSocket path.
var dangerousCommands = map[string]bool{
"FORCE": true,
"UNFORCE": true,
"PAUSE": true,
"RESUME": true,
"STEP": true,
"BREAK": true,
"UNBREAK": true,
"MSG": true,
"LOAD": true,
"UNLOAD": true,
}
// isDangerousCommand returns true if the command's first word is in the
// dangerous set (case-insensitive).
func isDangerousCommand(cmd string) bool {
parts := strings.Fields(cmd)
if len(parts) == 0 {
return false
}
return dangerousCommands[strings.ToUpper(parts[0])]
}
// ---------------------------------------------------------------------------
// Signal metadata (populated by DISCOVER)
// ---------------------------------------------------------------------------
@@ -48,6 +87,7 @@ func broadcastHub(hub *wshub.Hub, v any) {
type MarteController struct {
hub *wshub.Hub
sink func(v any)
mu sync.Mutex
tcpConn net.Conn
@@ -101,6 +141,7 @@ func NewMarteController(hub *wshub.Hub) *MarteController {
forcedState: make(map[string]string),
stopCh: make(chan struct{}),
}
mc.sink = func(v any) { broadcastHub(mc.hub, v) }
// Register the new-client hook so connection + forced/traced state is
// replayed to any browser that connects (or reconnects) while the server
// already holds a live MARTe2 TCP session.
@@ -108,6 +149,20 @@ func NewMarteController(hub *wshub.Hub) *MarteController {
return mc
}
// NewHeadlessMarteController creates a MarteController with no WebSocket hub,
// routing all events through sink instead (used by the debugclient E2E test tool).
func NewHeadlessMarteController(sink func(v any)) *MarteController {
mc := &MarteController{
hub: nil,
signals: make(map[uint32]*SignalMeta),
tracedNames: make(map[string]bool),
forcedState: make(map[string]string),
stopCh: make(chan struct{}),
}
mc.sink = sink
return mc
}
func (m *MarteController) IsConnected() bool {
return atomic.LoadInt32(&m.connected) == 1
}
@@ -166,10 +221,13 @@ func (m *MarteController) Connect(host string, cmdPort, udpPort, logPort int) {
m.stopCh = make(chan struct{})
m.mu.Unlock()
// Update source state so the browser shows "connecting".
// Update source state so the browser shows "connecting". No-op headless
// (m.hub == nil for NewHeadlessMarteController instances).
if m.hub != nil {
m.hub.SetSourceState("debug", "connecting")
}
broadcastHub(m.hub, map[string]any{
m.sink(map[string]any{
"type": "log", "time": time.Now().Format("15:04:05.000"),
"level": "INFO", "message": fmt.Sprintf("Connecting to %s cmd=%d udp=%d log=%d", host, cmdPort, udpPort, logPort),
})
@@ -198,7 +256,9 @@ func (m *MarteController) Disconnect() {
m.baseTsSet = false
m.basesMu.Unlock()
m.discoverAcc = nil
if m.hub != nil {
m.hub.SetSourceState("debug", "disconnected")
}
}
func (m *MarteController) stopped() bool {
@@ -256,11 +316,26 @@ func (m *MarteController) HandleBrowserCommand(msg []byte) {
return
}
cmd, _ := data["cmd"].(string)
if cmd != "" {
if cmd == "" {
return
}
// Gate dangerous commands (FORCE/UNFORCE/PAUSE/RESUME/STEP/BREAK/MSG)
// behind an explicit opt-in flag. Without it, only read-only commands
// (DISCOVER, TREE, INFO, LS, VALUE, TRACE, UNTRACE, STEP_STATUS) are
// forwarded to the MARTe2 TCP control connection.
if isDangerousCommand(cmd) {
if !DangerousCommandsEnabled {
m.sink(map[string]any{
"type": "log", "time": time.Now().Format("15:04:05.000"),
"level": "WARNING",
"message": fmt.Sprintf("Blocked dangerous command (requires --enable-dangerous-commands): %s", cmd),
})
return
}
}
m.trackForcedCmd(cmd)
m.SendCommand(cmd)
}
}
}
// ---------------------------------------------------------------------------
@@ -272,7 +347,7 @@ func (m *MarteController) runTCP(host string, port int) {
for !m.stopped() {
conn, err := net.DialTimeout("tcp", addr, 5*time.Second)
if err != nil {
broadcastHub(m.hub, map[string]any{
m.sink(map[string]any{
"type": "log", "time": time.Now().Format("15:04:05.000"),
"level": "WARNING", "message": fmt.Sprintf("TCP %s: %v — retrying…", addr, err),
})
@@ -287,7 +362,7 @@ func (m *MarteController) runTCP(host string, port int) {
m.mu.Unlock()
atomic.StoreInt32(&m.connected, 1)
broadcastHub(m.hub, map[string]any{"type": "connected"})
m.sink(map[string]any{"type": "connected"})
// Send SERVICE_INFO to auto-discover ports
m.writeCmd("SERVICE_INFO")
@@ -297,7 +372,7 @@ func (m *MarteController) runTCP(host string, port int) {
m.readLoop(conn)
atomic.StoreInt32(&m.connected, 0)
broadcastHub(m.hub, map[string]any{"type": "disconnected"})
m.sink(map[string]any{"type": "disconnected"})
m.mu.Lock()
m.tcpConn = nil
@@ -323,7 +398,7 @@ func (m *MarteController) writeCmd(cmd string) {
silent := cmd == "STEP_STATUS" || cmd == "INFO"
if !silent {
log.Printf("[→MARTe] %s", cmd)
broadcastHub(m.hub, map[string]any{
m.sink(map[string]any{
"type": "log", "time": time.Now().Format("15:04:05.000"),
"level": "CMD", "message": fmt.Sprintf("→ %s", cmd),
})
@@ -465,7 +540,7 @@ func (m *MarteController) handleJSONResponse(tag, data string) {
silent := tag == "STEP_STATUS" || tag == "INFO"
if !silent {
log.Printf("[←MARTe] %s %d bytes", tag, len(data))
broadcastHub(m.hub, map[string]any{
m.sink(map[string]any{
"type": "log", "time": time.Now().Format("15:04:05.000"),
"level": "RESP", "message": fmt.Sprintf("← %s (%d B)", tag, len(data)),
})
@@ -500,25 +575,27 @@ func (m *MarteController) handleJSONResponse(tag, data string) {
raw := m.rawSigs
m.rawSigsMu.RUnlock()
if len(raw) > 0 {
if m.hub != nil {
m.hub.UpdateConfigForSource("debug", m.translateSignalNames(raw))
}
} else {
m.synthesizeHubConfig(all)
}
// Re-marshal the merged list so the browser gets a single consistent blob.
merged, _ := json.Marshal(discoverResp{Signals: all})
broadcastHub(m.hub, map[string]any{
m.sink(map[string]any{
"type": "response", "tag": "DISCOVER", "data": string(merged),
})
return
case "TREE":
broadcastHub(m.hub, map[string]any{
m.sink(map[string]any{
"type": "tree_node",
"data": data,
})
return
}
broadcastHub(m.hub, map[string]any{
m.sink(map[string]any{
"type": "response",
"tag": tag,
"data": data,
@@ -537,13 +614,13 @@ func (m *MarteController) handleTextLine(line string) {
fmt.Sscanf(p[8:], "%d", &newLog)
}
}
broadcastHub(m.hub, map[string]any{
m.sink(map[string]any{
"type": "response",
"tag": "SERVICE_INFO",
"data": line[len("OK SERVICE_INFO "):],
})
if newUDP > 0 || newLog > 0 {
broadcastHub(m.hub, map[string]any{
m.sink(map[string]any{
"type": "service_config",
"udp_port": newUDP,
"log_port": newLog,
@@ -567,7 +644,7 @@ func (m *MarteController) handleTextLine(line string) {
}
}
}
broadcastHub(m.hub, map[string]any{
m.sink(map[string]any{
"type": "text_line",
"data": line,
})
@@ -774,7 +851,9 @@ func (m *MarteController) synthesizeHubConfig(sigs []discoverSignalJSON) {
// buffer and limiting live streaming to the fraction of a second that
// accumulated before the DISCOVER response arrived.
translated := m.translateSignalNames(sigInfos)
if m.hub != nil {
m.hub.UpdateConfigForSource("debug", translated)
}
}
// ---------------------------------------------------------------------------
@@ -801,7 +880,7 @@ func (m *MarteController) runDebugUDP(host string, port int) {
if err != nil {
msg := fmt.Sprintf("UDP bind on %s failed: %v — rebuild DebugService C++ and restart", addr, err)
log.Printf("[debug-udp] %s", msg)
broadcastHub(m.hub, map[string]any{
m.sink(map[string]any{
"type": "log", "time": time.Now().Format("15:04:05.000"),
"level": "ERROR", "message": msg,
})
@@ -812,7 +891,7 @@ func (m *MarteController) runDebugUDP(host string, port int) {
conn.SetReadBuffer(10 * 1024 * 1024)
log.Printf("[debug-udp] listening on %s for UDPS packets", addr)
broadcastHub(m.hub, map[string]any{
m.sink(map[string]any{
"type": "log", "time": time.Now().Format("15:04:05.000"),
"level": "INFO", "message": fmt.Sprintf("UDP listener bound on %s", addr),
})
@@ -865,8 +944,10 @@ func (m *MarteController) runDebugUDP(host string, port int) {
sigs = m.translateSignalNames(sigs)
currentSigs = sigs
currentPublishMode = pm
if m.hub != nil {
m.hub.UpdateConfigForSource("debug", sigs)
m.hub.SetSourceState("debug", "connected")
}
case udpsprotocol.PktData:
if len(currentSigs) == 0 {
@@ -888,11 +969,13 @@ func (m *MarteController) runDebugUDP(host string, port int) {
log.Printf("[debug-udp] parse data: %v", err)
continue
}
if m.hub != nil {
for _, s := range samples {
m.hub.PushDataForSource("debug", s)
}
}
}
}
log.Printf("[debug-udp] stopped")
}
@@ -923,7 +1006,7 @@ func (m *MarteController) runLog(host string, port int) {
}
level := rest[:idx]
msg := rest[idx+1:]
broadcastHub(m.hub, map[string]any{
m.sink(map[string]any{
"type": "log",
"time": time.Now().Format("15:04:05.000"),
"level": level,
Client/debugger/main.go
+5 -1
View File
@@ -10,6 +10,8 @@ import (
"net/http"
"os"
"marte2debugger/controller"
"marte2/common/wshub"
)
@@ -21,13 +23,15 @@ var staticFiles embed.FS
func main() {
addr := flag.String("addr", ":7777", "HTTP listen address")
sourcesFile := flag.String("sources-file", "", "JSON file for persistent source list")
flag.BoolVar(&controller.DangerousCommandsEnabled, "enable-dangerous-commands", false,
"Allow FORCE/PAUSE/RESUME/STEP/BREAK/MSG commands from the browser (CR-4 safety gate)")
flag.Parse()
hub := wshub.NewHub()
sm := wshub.NewSourceManager(hub, *sourcesFile)
hub.SetSourceManager(sm)
ctrl := NewMarteController(hub)
ctrl := controller.NewMarteController(hub)
go hub.Run()
Client/debugger/static/app.js
+1 -1
View File
@@ -3511,7 +3511,7 @@ function _fmtHz(v) { return v != null && isFinite(v) && v > 0 ? v.toFixed(2) + '
function _fmtKB(v) { return v != null && isFinite(v) ? (v / 1024).toFixed(2) + ' KB' : '—'; }
function _statsKV(label, value, cls) {
return `<div class="stats-kv"><span class="stats-k">${label}</span><span class="stats-v${cls ? ' ' + cls : ''}">${value}</span></div>`;
return `<div class="stats-kv"><span class="stats-k">${escHtml(label)}</span><span class="stats-v${cls ? ' ' + cls : ''}">${escHtml(value)}</span></div>`;
}
function _histHTML(si) {
Client/qscope/.qtcreator/project.json
+6
View File
@@ -0,0 +1,6 @@
{
"$schema": "https://download.qt.io/official_releases/qtcreator/latest/installer_source/jsonschemas/project.json",
"files.exclude": [
".qtcreator/project.json.user"
]
}
Client/qscope/.qtcreator/project.json.user
+209
View File
@@ -0,0 +1,209 @@
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE QtCreatorProject>
<!-- Written by QtCreator 20.0.1, 2026-08-28T12:02:58. -->
<qtcreator>
<data>
<variable>EnvironmentId</variable>
<value type="QByteArray">{38f50a4f-8398-4158-8e56-9848fa0d5468}</value>
</data>
<data>
<variable>ProjectExplorer.Project.ActiveTarget</variable>
<value type="qlonglong">0</value>
</data>
<data>
<variable>ProjectExplorer.Project.EditorSettings</variable>
<valuemap type="QVariantMap">
<value type="bool" key="EditorConfiguration.AutoDetect">true</value>
<valuemap type="QVariantMap" key="EditorConfiguration.CodeStyle.0">
<value type="QString" key="language">Cpp</value>
<valuemap type="QVariantMap" key="value">
<value type="QByteArray" key="CurrentPreferences">CppGlobal</value>
</valuemap>
</valuemap>
<valuemap type="QVariantMap" key="EditorConfiguration.CodeStyle.1">
<value type="QString" key="language">QmlJS</value>
<valuemap type="QVariantMap" key="value">
<value type="QByteArray" key="CurrentPreferences">QmlJSGlobal</value>
</valuemap>
</valuemap>
<value type="qlonglong" key="EditorConfiguration.CodeStyle.Count">2</value>
<value type="QByteArray" key="EditorConfiguration.Codec">UTF-8</value>
<value type="int" key="EditorConfiguration.IndentSize">4</value>
<value type="int" key="EditorConfiguration.PaddingMode">1</value>
<value type="bool" key="EditorConfiguration.SpacesForTabs">true</value>
<value type="int" key="EditorConfiguration.TabSize">8</value>
<value type="bool" key="EditorConfiguration.UseGlobal">true</value>
</valuemap>
</data>
<data>
<variable>ProjectExplorer.Project.PluginSettings</variable>
<valuemap type="QVariantMap">
<valuemap type="QVariantMap" key="AutoTest.ActiveFrameworks">
<value type="bool" key="AutoTest.Framework.Boost">true</value>
<value type="bool" key="AutoTest.Framework.CTest">false</value>
<value type="bool" key="AutoTest.Framework.Catch">true</value>
<value type="bool" key="AutoTest.Framework.GTest">true</value>
<value type="bool" key="AutoTest.Framework.QtQuickTest">true</value>
<value type="bool" key="AutoTest.Framework.QtTest">true</value>
</valuemap>
<value type="bool" key="AutoTest.ApplyFilter">false</value>
<valuemap type="QVariantMap" key="AutoTest.CheckStates"/>
<valuelist type="QVariantList" key="AutoTest.PathFilters"/>
<value type="int" key="AutoTest.RunAfterBuild">0</value>
<value type="bool" key="AutoTest.UseGlobal">true</value>
<valuemap type="QVariantMap" key="ClangTools">
<valuelist type="QVariantList" key="ClangTools.SelectedDirs"/>
<valuelist type="QVariantList" key="ClangTools.SelectedFiles"/>
<valuelist type="QVariantList" key="ClangTools.SuppressedDiagnostics"/>
<value type="bool" key="ClangTools.UseGlobalSettings">true</value>
</valuemap>
<value type="int" key="RcSync">0</value>
</valuemap>
</data>
<data>
<variable>ProjectExplorer.Project.Target.0</variable>
<valuemap type="QVariantMap">
<value type="QString" key="DeviceType">Desktop</value>
<value type="bool" key="HasPerBcDcs">true</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Desktop</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Desktop</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">{38553647-cfbc-4a75-8c5b-c589d0770ea7}</value>
<value type="qlonglong" key="ProjectExplorer.Target.ActiveBuildConfiguration">0</value>
<value type="qlonglong" key="ProjectExplorer.Target.ActiveDeployConfiguration">0</value>
<value type="qlonglong" key="ProjectExplorer.Target.ActiveRunConfiguration">0</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.BuildConfiguration.0">
<value type="QString" key="ProjectExplorer.BuildConfiguration.BuildDirectory">/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/qscope/build</value>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<value type="qlonglong" key="ProjectExplorer.BuildStepList.StepsCount">0</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Build</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Build</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Build</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.1">
<value type="qlonglong" key="ProjectExplorer.BuildStepList.StepsCount">0</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Clean</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Clean</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Clean</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">2</value>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ClearSystemEnvironment">false</value>
<valuelist type="QVariantList" key="ProjectExplorer.BuildConfiguration.CustomParsers"/>
<value type="bool" key="ProjectExplorer.BuildConfiguration.ParseStandardOutput">false</value>
<value type="UnknownType" key="ProjectExplorer.BuildConfiguration.UserEnvironmentChanges"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Default</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">WorkspaceProject.BuildConfiguration</value>
<value type="qlonglong" key="ProjectExplorer.Target.ActiveDeployConfiguration">0</value>
<value type="qlonglong" key="ProjectExplorer.Target.ActiveRunConfiguration">0</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.DeployConfiguration.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<value type="qlonglong" key="ProjectExplorer.BuildStepList.StepsCount">0</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Deploy</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Deploy</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Deploy</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">1</value>
<valuemap type="QVariantMap" key="ProjectExplorer.DeployConfiguration.CustomData"/>
<value type="bool" key="ProjectExplorer.DeployConfiguration.CustomDataEnabled">false</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.DefaultDeployConfiguration</value>
</valuemap>
<value type="qlonglong" key="ProjectExplorer.Target.DeployConfigurationCount">1</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.RunConfiguration.0">
<value type="bool" key="Analyzer.Perf.Settings.UseGlobalSettings">true</value>
<value type="bool" key="Analyzer.QmlProfiler.Settings.UseGlobalSettings">true</value>
<value type="int" key="Analyzer.Valgrind.Callgrind.CostFormat">0</value>
<value type="bool" key="Analyzer.Valgrind.Settings.UseGlobalSettings">true</value>
<valuelist type="QVariantList" key="Analyzer.Valgrind.SuppressionFiles"/>
<valuelist type="QVariantList" key="CustomOutputParsers"/>
<value type="int" key="PE.EnvironmentAspect.Base">2</value>
<value type="UnknownType" key="PE.EnvironmentAspect.Changes"></value>
<value type="bool" key="PE.EnvironmentAspect.PrintOnRun">false</value>
<value type="QString" key="PerfRecordArgsId">-e cpu-cycles --call-graph dwarf,4096 -F 250</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.CustomExecutableRunConfiguration</value>
<value type="QString" key="ProjectExplorer.RunConfiguration.BuildKey"></value>
<value type="bool" key="ProjectExplorer.RunConfiguration.Customized">false</value>
<value type="QString" key="ProjectExplorer.RunConfiguration.UniqueId"></value>
<value type="bool" key="RunConfiguration.UseCppDebuggerAuto">true</value>
<value type="bool" key="RunConfiguration.UseQmlDebuggerAuto">true</value>
<value type="QString" key="RunConfiguration.WorkingDirectory.default">%{RunConfig:Executable:Path}</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.RunConfiguration.1">
<value type="bool" key="Analyzer.Perf.Settings.UseGlobalSettings">true</value>
<value type="bool" key="Analyzer.QmlProfiler.Settings.UseGlobalSettings">true</value>
<value type="int" key="Analyzer.Valgrind.Callgrind.CostFormat">0</value>
<value type="bool" key="Analyzer.Valgrind.Settings.UseGlobalSettings">true</value>
<valuelist type="QVariantList" key="Analyzer.Valgrind.SuppressionFiles"/>
<valuelist type="QVariantList" key="CustomOutputParsers"/>
<value type="QString" key="PerfRecordArgsId">-e cpu-cycles --call-graph dwarf,4096 -F 250</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">RemoteDebugger.RunConfig</value>
<value type="QString" key="ProjectExplorer.RunConfiguration.BuildKey"></value>
<value type="bool" key="ProjectExplorer.RunConfiguration.Customized">false</value>
<value type="QString" key="ProjectExplorer.RunConfiguration.UniqueId"></value>
<value type="bool" key="RunConfiguration.UseCppDebuggerAuto">true</value>
<value type="bool" key="RunConfiguration.UseQmlDebuggerAuto">true</value>
</valuemap>
<value type="qlonglong" key="ProjectExplorer.Target.RunConfigurationCount">2</value>
</valuemap>
<value type="qlonglong" key="ProjectExplorer.Target.BuildConfigurationCount">1</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.DeployConfiguration.0">
<valuemap type="QVariantMap" key="ProjectExplorer.BuildConfiguration.BuildStepList.0">
<value type="qlonglong" key="ProjectExplorer.BuildStepList.StepsCount">0</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DefaultDisplayName">Deploy</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName">Deploy</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.BuildSteps.Deploy</value>
</valuemap>
<value type="int" key="ProjectExplorer.BuildConfiguration.BuildStepListCount">1</value>
<valuemap type="QVariantMap" key="ProjectExplorer.DeployConfiguration.CustomData"/>
<value type="bool" key="ProjectExplorer.DeployConfiguration.CustomDataEnabled">false</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.DefaultDeployConfiguration</value>
</valuemap>
<value type="qlonglong" key="ProjectExplorer.Target.DeployConfigurationCount">1</value>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.RunConfiguration.0">
<value type="bool" key="Analyzer.Perf.Settings.UseGlobalSettings">true</value>
<value type="bool" key="Analyzer.QmlProfiler.Settings.UseGlobalSettings">true</value>
<value type="int" key="Analyzer.Valgrind.Callgrind.CostFormat">0</value>
<value type="bool" key="Analyzer.Valgrind.Settings.UseGlobalSettings">true</value>
<valuelist type="QVariantList" key="Analyzer.Valgrind.SuppressionFiles"/>
<valuelist type="QVariantList" key="CustomOutputParsers"/>
<value type="int" key="PE.EnvironmentAspect.Base">2</value>
<value type="UnknownType" key="PE.EnvironmentAspect.Changes"></value>
<value type="bool" key="PE.EnvironmentAspect.PrintOnRun">false</value>
<value type="QString" key="PerfRecordArgsId">-e cpu-cycles --call-graph dwarf,4096 -F 250</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">ProjectExplorer.CustomExecutableRunConfiguration</value>
<value type="QString" key="ProjectExplorer.RunConfiguration.BuildKey"></value>
<value type="bool" key="ProjectExplorer.RunConfiguration.Customized">false</value>
<value type="QString" key="ProjectExplorer.RunConfiguration.UniqueId"></value>
<value type="bool" key="RunConfiguration.UseCppDebuggerAuto">true</value>
<value type="bool" key="RunConfiguration.UseQmlDebuggerAuto">true</value>
<value type="QString" key="RunConfiguration.WorkingDirectory.default">%{RunConfig:Executable:Path}</value>
</valuemap>
<valuemap type="QVariantMap" key="ProjectExplorer.Target.RunConfiguration.1">
<value type="bool" key="Analyzer.Perf.Settings.UseGlobalSettings">true</value>
<value type="bool" key="Analyzer.QmlProfiler.Settings.UseGlobalSettings">true</value>
<value type="int" key="Analyzer.Valgrind.Callgrind.CostFormat">0</value>
<value type="bool" key="Analyzer.Valgrind.Settings.UseGlobalSettings">true</value>
<valuelist type="QVariantList" key="Analyzer.Valgrind.SuppressionFiles"/>
<valuelist type="QVariantList" key="CustomOutputParsers"/>
<value type="QString" key="PerfRecordArgsId">-e cpu-cycles --call-graph dwarf,4096 -F 250</value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.DisplayName"></value>
<value type="QString" key="ProjectExplorer.ProjectConfiguration.Id">RemoteDebugger.RunConfig</value>
<value type="QString" key="ProjectExplorer.RunConfiguration.BuildKey"></value>
<value type="bool" key="ProjectExplorer.RunConfiguration.Customized">false</value>
<value type="QString" key="ProjectExplorer.RunConfiguration.UniqueId"></value>
<value type="bool" key="RunConfiguration.UseCppDebuggerAuto">true</value>
<value type="bool" key="RunConfiguration.UseQmlDebuggerAuto">true</value>
</valuemap>
<value type="qlonglong" key="ProjectExplorer.Target.RunConfigurationCount">2</value>
</valuemap>
</data>
<data>
<variable>ProjectExplorer.Project.TargetCount</variable>
<value type="qlonglong">1</value>
</data>
<data>
<variable>Version</variable>
<value type="int">22</value>
</data>
</qtcreator>
Client/qscope/QScope/.gitignore
+84
View File
@@ -0,0 +1,84 @@
# This file is used to ignore files which are generated
# ----------------------------------------------------------------------------
*~
*.autosave
*.a
*.core
*.moc
*.o
*.obj
*.orig
*.rej
*.so
*.so.*
*_pch.h.cpp
*_resource.rc
*.qm
.#*
*.*#
core
!core/
tags
.DS_Store
.directory
*.debug
Makefile*
*.prl
*.app
moc_*.cpp
ui_*.h
qrc_*.cpp
Thumbs.db
*.res
*.rc
/.qmake.cache
/.qmake.stash
**/.qmlls.ini
# qtcreator generated files
*.pro.user*
*.qbs.user*
CMakeLists.txt.user*
# xemacs temporary files
*.flc
# Vim temporary files
.*.swp
# Visual Studio generated files
*.ib_pdb_index
*.idb
*.ilk
*.pdb
*.sln
*.suo
*.vcproj
*vcproj.*.*.user
*.ncb
*.sdf
*.opensdf
*.vcxproj
*vcxproj.*
# MinGW generated files
*.Debug
*.Release
# Python byte code
*.pyc
# Binaries
# --------
*.dll
*.exe
# Directories with generated files
.moc/
.obj/
.pch/
.rcc/
.uic/
/build*/
/.qtcreator/
Client/qscope/QScope/CMakeLists.txt
+77
View File
@@ -0,0 +1,77 @@
cmake_minimum_required(VERSION 3.16)
project(QScope VERSION 0.1 LANGUAGES CXX)
set(CMAKE_AUTOUIC ON)
set(CMAKE_AUTOMOC ON)
set(CMAKE_AUTORCC ON)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
find_package(QT NAMES Qt6 Qt5 REQUIRED COMPONENTS Widgets LinguistTools)
find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS Widgets LinguistTools)
set(TS_FILES QScope_en_001.ts)
set(PROJECT_SOURCES
main.cpp
qscopemainwindow.cpp
qscopemainwindow.h
qscopemainwindow.ui
${TS_FILES}
)
if(${QT_VERSION_MAJOR} GREATER_EQUAL 6)
qt_add_executable(QScope
MANUAL_FINALIZATION
${PROJECT_SOURCES}
)
# Define target properties for Android with Qt 6 as:
# set_property(TARGET QScope APPEND PROPERTY QT_ANDROID_PACKAGE_SOURCE_DIR
# ${CMAKE_CURRENT_SOURCE_DIR}/android)
# For more information, see https://doc.qt.io/qt-6/qt-add-executable.html#target-creation
qt_create_translation(QM_FILES ${CMAKE_SOURCE_DIR} ${TS_FILES})
else()
if(ANDROID)
add_library(QScope SHARED
${PROJECT_SOURCES}
)
# Define properties for Android with Qt 5 after find_package() calls as:
# set(ANDROID_PACKAGE_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/android")
else()
add_executable(QScope
${PROJECT_SOURCES}
)
endif()
qt5_create_translation(QM_FILES ${CMAKE_SOURCE_DIR} ${TS_FILES})
endif()
target_link_libraries(QScope PRIVATE Qt${QT_VERSION_MAJOR}::Widgets)
# Qt for iOS sets MACOSX_BUNDLE_GUI_IDENTIFIER automatically since Qt 6.1.
# If you are developing for iOS or macOS you should consider setting an
# explicit, fixed bundle identifier manually though.
if(${QT_VERSION} VERSION_LESS 6.1.0)
set(BUNDLE_ID_OPTION MACOSX_BUNDLE_GUI_IDENTIFIER com.example.QScope)
endif()
set_target_properties(QScope PROPERTIES
${BUNDLE_ID_OPTION}
MACOSX_BUNDLE_BUNDLE_VERSION ${PROJECT_VERSION}
MACOSX_BUNDLE_SHORT_VERSION_STRING ${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}
MACOSX_BUNDLE TRUE
WIN32_EXECUTABLE TRUE
)
include(GNUInstallDirs)
install(TARGETS QScope
BUNDLE DESTINATION .
LIBRARY DESTINATION ${CMAKE_INSTALL_LIBDIR}
RUNTIME DESTINATION ${CMAKE_INSTALL_BINDIR}
)
if(QT_VERSION_MAJOR EQUAL 6)
qt_finalize_executable(QScope)
endif()
Client/qscope/QScope/QScope_en_001.ts
+3
View File
@@ -0,0 +1,3 @@
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE TS>
<TS version="2.1" language="en_001"></TS>
Client/qscope/QScope/main.cpp
+23
View File
@@ -0,0 +1,23 @@
#include "qscopemainwindow.h"
#include <QApplication>
#include <QLocale>
#include <QTranslator>
int main(int argc, char *argv[])
{
QApplication a(argc, argv);
QTranslator translator;
const QStringList uiLanguages = QLocale::system().uiLanguages();
for (const QString &locale : uiLanguages) {
const QString baseName = "QScope_" + QLocale(locale).name();
if (translator.load(":/i18n/" + baseName)) {
a.installTranslator(&translator);
break;
}
}
QScopeMainWindow w;
w.show();
return QApplication::exec();
}
Client/qscope/QScope/qscopemainwindow.cpp
+14
View File
@@ -0,0 +1,14 @@
#include "qscopemainwindow.h"
#include "./ui_qscopemainwindow.h"
QScopeMainWindow::QScopeMainWindow(QWidget *parent)
: QMainWindow(parent)
, ui(new Ui::QScopeMainWindow)
{
ui->setupUi(this);
}
QScopeMainWindow::~QScopeMainWindow()
{
delete ui;
}
Client/qscope/QScope/qscopemainwindow.h
+23
View File
@@ -0,0 +1,23 @@
#ifndef QSCOPEMAINWINDOW_H
#define QSCOPEMAINWINDOW_H
#include <QMainWindow>
QT_BEGIN_NAMESPACE
namespace Ui {
class QScopeMainWindow;
}
QT_END_NAMESPACE
class QScopeMainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit QScopeMainWindow(QWidget *parent = nullptr);
~QScopeMainWindow() override;
private:
Ui::QScopeMainWindow *ui;
};
#endif // QSCOPEMAINWINDOW_H
Client/qscope/QScope/qscopemainwindow.ui
+51
View File
@@ -0,0 +1,51 @@
<?xml version="1.0" encoding="UTF-8"?>
<ui version="4.0">
<class>QScopeMainWindow</class>
<widget class="QMainWindow" name="QScopeMainWindow">
<property name="geometry">
<rect>
<x>0</x>
<y>0</y>
<width>800</width>
<height>600</height>
</rect>
</property>
<property name="windowTitle">
<string>QScopeMainWindow</string>
</property>
<widget class="QWidget" name="centralwidget"/>
<widget class="QStatusBar" name="statusbar"/>
<widget class="QDockWidget" name="dockWidget">
<attribute name="dockWidgetArea">
<number>1</number>
</attribute>
<widget class="QWidget" name="dockWidgetContents">
<layout class="QVBoxLayout" name="verticalLayout">
<item>
<widget class="QTreeView" name="treeView"/>
</item>
<item>
<widget class="QPushButton" name="pushButton">
<property name="text">
<string>PushButton</string>
</property>
</widget>
</item>
</layout>
</widget>
</widget>
<widget class="QToolBar" name="toolBar">
<property name="windowTitle">
<string>toolBar</string>
</property>
<attribute name="toolBarArea">
<enum>TopToolBarArea</enum>
</attribute>
<attribute name="toolBarBreak">
<bool>false</bool>
</attribute>
</widget>
</widget>
<resources/>
<connections/>
</ui>
Client/streamhub-qt/CMakeLists.txt
+68
View File
@@ -0,0 +1,68 @@
cmake_minimum_required(VERSION 3.16)
project(StreamHubQtClient CXX)
set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_AUTOMOC ON)
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
# The reused, framework-free Protocol.h / Model.h structs have members named
# "signals" (e.g. ZoomResponse::signals). Qt's default "signals"/"slots"/"emit"
# keyword macros would clobber them, so disable the macros and use the
# Q_SIGNALS / Q_SLOTS / Q_EMIT spellings in our own Qt classes instead.
add_compile_definitions(QT_NO_KEYWORDS)
# ── Qt5/Qt6 autodetect (prefer Qt6, fall back to Qt5) ─────────────────────────
find_package(QT NAMES Qt6 Qt5 REQUIRED COMPONENTS Widgets WebSockets)
find_package(Qt${QT_VERSION_MAJOR} REQUIRED COMPONENTS Widgets WebSockets)
message(STATUS "StreamHubQtClient: building against Qt${QT_VERSION_MAJOR} "
"(${QT_VERSION})")
# ── Reuse the wire layer from the ImGui client (single source of truth) ───────
set(REF_CLIENT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../streamhub)
set(SOURCES
main.cpp
Theme.cpp
Hub.cpp
WsClient.cpp
PlotWidget.cpp
PlotGrid.cpp
SourceSidebar.cpp
TriggerBar.cpp
StatsDialog.cpp
HistoryBar.cpp
MainWindow.cpp
# Reused, framework-free protocol implementation:
${REF_CLIENT_DIR}/Protocol.cpp
)
set(HEADERS
Model.h
Theme.h
Hub.h
WsClient.h
PlotWidget.h
PlotGrid.h
SourceSidebar.h
TriggerBar.h
StatsDialog.h
HistoryBar.h
MainWindow.h
)
add_executable(StreamHubQtClient ${SOURCES} ${HEADERS})
target_include_directories(StreamHubQtClient PRIVATE
${CMAKE_CURRENT_SOURCE_DIR}
${REF_CLIENT_DIR} # Protocol.h, SignalBuffer.h
)
target_link_libraries(StreamHubQtClient PRIVATE
Qt${QT_VERSION_MAJOR}::Widgets
Qt${QT_VERSION_MAJOR}::WebSockets
)
target_compile_options(StreamHubQtClient PRIVATE -Wall -Wextra -Wno-unused-parameter)
install(TARGETS StreamHubQtClient DESTINATION bin)
Client/streamhub-qt/HistoryBar.cpp
+104
View File
@@ -0,0 +1,104 @@
/**
* @file HistoryBar.cpp
*/
#include "HistoryBar.h"
#include "Hub.h"
#include "PlotGrid.h"
#include "Theme.h"
#include <QHBoxLayout>
#include <QLabel>
#include <QPushButton>
#include <QDateTime>
namespace shq {
static double nowSec() {
return QDateTime::currentMSecsSinceEpoch() / 1000.0;
}
HistoryBar::HistoryBar(Hub* hub, PlotGrid* grid, QWidget* parent)
: QWidget(parent), hub_(hub), grid_(grid) {
auto* lay = new QHBoxLayout(this);
lay->setContentsMargins(6, 2, 6, 2);
lay->setSpacing(4);
auto* title = new QLabel("History", this);
title->setStyleSheet("color:#fab387; font-weight:bold;");
lay->addWidget(title);
auto* liveBtn = new QPushButton("Live", this);
connect(liveBtn, &QPushButton::clicked, this, [this]() {
grid_->goLive();
Q_EMIT liveRequested();
});
lay->addWidget(liveBtn);
rangeLbl_ = new QLabel("No range", this);
rangeLbl_->setStyleSheet("color:#a6adc8;");
rangeLbl_->setMinimumWidth(170);
lay->addWidget(rangeLbl_);
auto* left = new QPushButton("\u25c0", this); /* pan left */
left->setMaximumWidth(32);
connect(left, &QPushButton::clicked, this, [this]() { grid_->panAll(-0.75); });
lay->addWidget(left);
auto* right = new QPushButton("\u25b6", this); /* pan right */
right->setMaximumWidth(32);
connect(right, &QPushButton::clicked, this, [this]() { grid_->panAll(0.75); });
lay->addWidget(right);
/* Jump presets. */
static const double kJumpSec[] = {10, 30, 60, 300, 600, 1800, 3600};
static const char* kJumpLabel[] = {"10s","30s","1m","5m","10m","30m","1h"};
for (int j = 0; j < 7; j++) {
double sec = kJumpSec[j];
auto* b = new QPushButton(kJumpLabel[j], this);
b->setMaximumWidth(40);
connect(b, &QPushButton::clicked, this, [this, sec]() {
grid_->jumpAllAgo(sec);
});
lay->addWidget(b);
}
auto* allBtn = new QPushButton("All", this);
allBtn->setMaximumWidth(40);
connect(allBtn, &QPushButton::clicked, this, &HistoryBar::showAll);
lay->addWidget(allBtn);
lay->addStretch(1);
}
void HistoryBar::showAll() {
const auto& hi = hub_->historyInfo();
double t0 = 1e300, t1 = -1e300;
for (const auto& hs : hi.signals) {
if (hs.t0 < t0) { t0 = hs.t0; }
if (hs.t1 > t1) { t1 = hs.t1; }
}
if (t1 > t0) { grid_->setAllStoredX(t0, t1); }
}
void HistoryBar::updateReadout() {
double t0, t1;
if (!grid_->currentRange(t0, t1)) {
rangeLbl_->setText("Live");
return;
}
double span = t1 - t0;
double ago = nowSec() - t1;
QString s;
if (ago < 1.0) {
s = QString("%1 s span | now").arg(span, 0, 'g', 3);
} else if (ago < 60.0) {
s = QString("%1 s span | %2 s ago").arg(span, 0, 'g', 3).arg(ago, 0, 'f', 0);
} else if (ago < 3600.0) {
s = QString("%1 s span | %2 min ago").arg(span, 0, 'g', 3).arg(ago / 60.0, 0, 'f', 1);
} else {
s = QString("%1 s span | %2 h ago").arg(span, 0, 'g', 3).arg(ago / 3600.0, 0, 'f', 1);
}
rangeLbl_->setText(s);
}
} /* namespace shq */
Client/streamhub-qt/HistoryBar.h
+42
View File
@@ -0,0 +1,42 @@
/**
* @file HistoryBar.h
* @brief History-browsing toolbar: Live, range readout, pan, jump presets, All.
*
* Operates on the PlotGrid (sets all plots non-live and seeds their stored X
* range). Mirrors the ImGui App::renderHistoryBar. Visible only when the hub
* reports history is enabled and populated.
*/
#pragma once
#include <QWidget>
class QLabel;
namespace shq {
class Hub;
class PlotGrid;
class HistoryBar : public QWidget {
Q_OBJECT
public:
HistoryBar(Hub* hub, PlotGrid* grid, QWidget* parent = nullptr);
public Q_SLOTS:
/** Update the range readout (called by the 60 Hz tick). */
void updateReadout();
/** Jump all plots to the full available history range. */
void showAll();
Q_SIGNALS:
/** User pressed Live → MainWindow hides this bar. */
void liveRequested();
private:
Hub* hub_;
PlotGrid* grid_;
QLabel* rangeLbl_ = nullptr;
};
} /* namespace shq */
Client/streamhub-qt/Hub.cpp
+307
View File
@@ -0,0 +1,307 @@
/**
* @file Hub.cpp
*/
#include "Hub.h"
#include "Theme.h"
#include <QDateTime>
#include <algorithm>
using namespace StreamHubClient;
namespace shq {
Hub::Hub(QObject* parent) : QObject(parent) {
connect(&ws_, &WsClient::connectedChanged, this, &Hub::onConnected);
connect(&ws_, &WsClient::textReceived, this, &Hub::onText);
connect(&ws_, &WsClient::binaryReceived, this, &Hub::onBinary);
}
void Hub::start(const QString& host, uint16_t port) {
ws_.connectTo(host, port);
}
void Hub::reconnect(const QString& host, uint16_t port) {
ws_.reconnectTo(host, port);
}
/* ── connection ──────────────────────────────────────────────────────────── */
void Hub::onConnected(bool connected) {
if (connected) {
sendGetSources();
sendGetStats();
sendHistoryInfo();
}
Q_EMIT connectedChanged(connected);
}
/* ── dispatch ────────────────────────────────────────────────────────────── */
void Hub::onText(const QString& jsonQ) {
const std::string json = jsonQ.toStdString();
const std::string type = ParseType(json);
if (type == "sources") { onSources(json); }
else if (type == "config") { onConfig(json); }
else if (type == "stats") { onStats(json); }
else if (type == "triggerState") { onTriggerState(json); }
else if (type == "zoom") { onZoom(json); }
else if (type == "historyZoom") { onHistoryZoom(json); }
else if (type == "historyInfo") { onHistoryInfo(json); }
else if (type == "maxPointsUpdated") { onMaxPointsUpdated(json); }
/* pong: ignore */
}
void Hub::onBinary(const QByteArray& bytes) {
if (bytes.isEmpty()) { return; }
const uint8_t* data = reinterpret_cast<const uint8_t*>(bytes.constData());
const size_t len = static_cast<size_t>(bytes.size());
if (data[0] == 2u) { /* trigger capture frame */
CaptureFrame cf;
if (ParseCaptureFrame(data, len, cf)) {
capture_ = std::move(cf);
hasCapture_ = true;
trigger_.status = "triggered";
trigger_.trigTime = capture_.trigTime;
trigger_.hasTrigTime = true;
Q_EMIT captureReceived();
}
return;
}
DataFrame frame; /* v1 live push */
if (!ParseBinaryFrame(data, len, frame)) { return; }
int srcIdx = findSource(frame.sourceId);
if (srcIdx < 0) { return; }
Source& src = sources_[srcIdx];
for (const auto& fs : frame.signals) {
int sigIdx = findSignal(src, fs.name);
if (sigIdx < 0) { continue; }
size_t n = std::min(fs.t.size(), fs.v.size());
auto& buf = src.signals[sigIdx].buf;
for (size_t i = 0; i < n; i++) { buf.push(fs.t[i], fs.v[i]); }
}
}
/* ── JSON handlers (port of App.cpp) ─────────────────────────────────────── */
void Hub::onSources(const std::string& json) {
std::vector<SourceInfo> infos;
ParseSources(json, infos);
for (const auto& info : infos) {
int idx = findSource(info.id);
if (idx < 0) {
Source s;
s.id = info.id; s.label = info.label; s.addr = info.addr;
s.port = info.port; s.state = info.state;
sources_.push_back(std::move(s));
} else {
sources_[idx].state = info.state;
sources_[idx].label = info.label;
}
}
sources_.erase(std::remove_if(sources_.begin(), sources_.end(),
[&infos](const Source& s) {
for (const auto& i : infos) { if (i.id == s.id) { return false; } }
return true;
}), sources_.end());
/* Request config for any source not yet configured. */
for (auto& s : sources_) {
if (!s.configured) { sendGetConfig(s.id); }
}
Q_EMIT sourcesChanged();
}
void Hub::onConfig(const std::string& json) {
std::string sourceId;
int publishMode = 0;
std::vector<SignalMeta> metas;
if (!ParseConfig(json, sourceId, publishMode, metas)) { return; }
int idx = findSource(sourceId);
if (idx < 0) { return; }
Source& src = sources_[idx];
src.configured = true;
src.publishMode = publishMode;
for (size_t m = 0; m < metas.size(); m++) {
int si = findSignal(src, metas[m].name);
if (si < 0) {
SignalView sig;
sig.meta = metas[m];
sig.color = tracePalette(static_cast<int>(src.signals.size()));
src.signals.push_back(std::move(sig));
} else {
src.signals[si].meta = metas[m];
}
}
Q_EMIT configChanged(QString::fromStdString(sourceId));
}
void Hub::onStats(const std::string& json) {
std::vector<std::pair<std::string, SourceStats>> statsVec;
ParseStats(json, statsVec);
for (const auto& kv : statsVec) {
int idx = findSource(kv.first);
if (idx >= 0) {
sources_[idx].stats = kv.second;
sources_[idx].state = kv.second.state;
}
}
Q_EMIT statsChanged();
}
void Hub::onTriggerState(const std::string& json) {
TriggerStateMsg msg;
if (!ParseTriggerState(json, msg)) { return; }
trigger_.status = msg.state;
trigger_.stopped = msg.stopped;
if (msg.hasTrigTime) {
trigger_.trigTime = msg.trigTime;
trigger_.hasTrigTime = true;
}
if (msg.hasWindow) {
trigger_.firedPreS = msg.preSec;
trigger_.firedPostS = msg.postSec;
trigger_.hasFiredWin = true;
}
if (msg.state == "idle") {
trigger_.hasTrigTime = false;
trigger_.hasFiredWin = false;
}
Q_EMIT triggerStateChanged();
}
static void routeZoom(PlotZoomCache* caches, const ZoomResponse& resp,
int& outPlot) {
outPlot = -1;
for (int i = 0; i < kMaxPlotSlots; i++) {
auto& zc = caches[i];
if (zc.pending && zc.reqId == resp.reqId) {
double dataT0 = 1e300, dataT1 = -1e300;
bool anyData = false;
for (const auto& zs : resp.signals) {
for (double tv : zs.t) {
if (tv < dataT0) { dataT0 = tv; }
if (tv > dataT1) { dataT1 = tv; }
anyData = true;
}
}
if (anyData) {
zc.pts = resp.signals;
zc.t0 = dataT0; zc.t1 = dataT1; zc.valid = true;
}
zc.pending = false;
outPlot = i;
return;
}
}
}
void Hub::onZoom(const std::string& json) {
ZoomResponse resp;
if (!ParseZoom(json, resp)) { return; }
int plot = -1;
routeZoom(zoomCache_, resp, plot);
if (plot >= 0) { Q_EMIT zoomReceived(plot); }
}
void Hub::onHistoryZoom(const std::string& json) {
ZoomResponse resp;
if (!ParseZoom(json, resp)) { return; }
int plot = -1;
routeZoom(histZoomCache_, resp, plot);
if (plot >= 0) { Q_EMIT historyZoomReceived(plot); }
}
void Hub::onHistoryInfo(const std::string& json) {
ParseHistoryInfo(json, historyInfo_);
Q_EMIT historyInfoChanged();
}
void Hub::onMaxPointsUpdated(const std::string& json) {
uint32_t mp = 0;
ParseMaxPointsUpdated(json, mp);
if (mp >= 2) {
maxPoints_ = mp;
for (auto& src : sources_) {
for (auto& sig : src.signals) { sig.buf.setCapacity(mp); }
}
Q_EMIT maxPointsChanged(mp);
}
}
/* ── helpers ─────────────────────────────────────────────────────────────── */
int Hub::findSource(const std::string& id) const {
for (int i = 0; i < static_cast<int>(sources_.size()); i++) {
if (sources_[i].id == id) { return i; }
}
return -1;
}
int Hub::findSignal(const Source& src, const std::string& name) const {
for (int i = 0; i < static_cast<int>(src.signals.size()); i++) {
if (src.signals[i].meta.name == name) { return i; }
}
return -1;
}
std::string Hub::slotKey(const PlotAssignment& a) const {
if (a.sourceIdx < 0 || a.sourceIdx >= static_cast<int>(sources_.size())) {
return std::string();
}
const Source& src = sources_[a.sourceIdx];
if (a.signalIdx < 0 || a.signalIdx >= static_cast<int>(src.signals.size())) {
return std::string();
}
return src.id + ":" + src.signals[a.signalIdx].meta.name;
}
/* ── commands ────────────────────────────────────────────────────────────── */
void Hub::sendGetSources() { ws_.sendText(BuildGetSources()); }
void Hub::sendGetStats() { ws_.sendText(BuildGetStats()); }
void Hub::sendGetConfig(const std::string& id) { ws_.sendText(BuildGetConfig(id)); }
void Hub::sendHistoryInfo(){ ws_.sendText(BuildHistoryInfo()); }
void Hub::sendAddSource(const std::string& label, const std::string& addr,
const std::string& mcast, uint16_t dataPort) {
ws_.sendText(BuildAddSource(label, addr, mcast, dataPort));
}
void Hub::sendRemoveSource(const std::string& id) {
ws_.sendText(BuildRemoveSource(id));
}
void Hub::sendSaveSources() { ws_.sendText(BuildSaveSources()); }
void Hub::sendSetMaxPoints(uint32_t n) { ws_.sendText(BuildSetMaxPoints(n)); }
void Hub::sendSetTrigger(const std::string& key, const std::string& edge,
double threshold, double windowSec, double prePercent,
const std::string& mode) {
ws_.sendText(BuildSetTrigger(key, edge, threshold, windowSec, prePercent, mode));
}
void Hub::sendArm() { ws_.sendText(BuildArm()); }
void Hub::sendDisarm() { ws_.sendText(BuildDisarm()); }
void Hub::sendRearm() { ws_.sendText(BuildRearm()); }
void Hub::sendTrigStop(bool s) { ws_.sendText(BuildTrigStop(s)); }
void Hub::requestZoom(int plotIdx, double t0, double t1, const std::string& csv) {
if (plotIdx < 0 || plotIdx >= kMaxPlotSlots) { return; }
if (!ws_.isConnected() || csv.empty()) { return; }
auto& zc = zoomCache_[plotIdx];
zc.reqId = nextZoomReqId_++;
zc.reqT0 = t0; zc.reqT1 = t1; zc.pending = true;
ws_.sendText(BuildZoom(zc.reqId, t0, t1, 2400, csv));
}
void Hub::requestHistoryZoom(int plotIdx, double t0, double t1,
const std::string& csv) {
if (plotIdx < 0 || plotIdx >= kMaxPlotSlots) { return; }
if (!ws_.isConnected() || csv.empty()) { return; }
auto& hc = histZoomCache_[plotIdx];
hc.reqId = nextZoomReqId_++;
hc.reqT0 = t0; hc.reqT1 = t1; hc.pending = true;
ws_.sendText(BuildHistoryZoom(hc.reqId, t0, t1, 2400, csv));
}
} /* namespace shq */
Client/streamhub-qt/Hub.h
+125
View File
@@ -0,0 +1,125 @@
/**
* @file Hub.h
* @brief Central controller: owns the WS client, the source model, trigger
* state, capture, zoom caches and history info. Translates StreamHub WS
* messages into model updates and emits Qt signals for the UI.
*/
#pragma once
#include "Model.h"
#include "WsClient.h"
#include "Protocol.h"
#include <QObject>
#include <QString>
#include <vector>
#include <string>
#include <cstdint>
namespace shq {
/** Hi-res zoom cache (per plot; mirrors the ImGui client's PlotZoomCache). */
struct PlotZoomCache {
bool valid = false;
bool pending = false;
uint32_t reqId = 0;
double t0 = 0.0, t1 = 0.0; /* range of valid data */
double reqT0 = 0.0, reqT1 = 0.0; /* range of pending request */
std::vector<StreamHubClient::ZoomSignal> pts;
};
class Hub : public QObject {
Q_OBJECT
public:
explicit Hub(QObject* parent = nullptr);
void start(const QString& host, uint16_t port);
void reconnect(const QString& host, uint16_t port);
/* ---- Model access (GUI thread only) -------------------------------- */
std::vector<Source>& sources() { return sources_; }
const std::vector<Source>& sources() const { return sources_; }
TriggerCfgState& trigger() { return trigger_; }
const StreamHubClient::HistoryInfoMsg& historyInfo() const { return historyInfo_; }
uint32_t maxPoints() const { return maxPoints_; }
bool isConnected() const { return ws_.isConnected(); }
WsClient& ws() { return ws_; }
const StreamHubClient::CaptureFrame* capture() const {
return hasCapture_ ? &capture_ : nullptr;
}
void clearCapture() { hasCapture_ = false; }
PlotZoomCache& zoomCache(int i) { return zoomCache_[i]; }
PlotZoomCache& histZoomCache(int i) { return histZoomCache_[i]; }
int findSource(const std::string& id) const;
int findSignal(const Source& src, const std::string& name) const;
std::string slotKey(const PlotAssignment& a) const;
/* ---- Commands ------------------------------------------------------ */
void sendGetSources();
void sendGetStats();
void sendGetConfig(const std::string& sourceId);
void sendAddSource(const std::string& label, const std::string& addr,
const std::string& mcast, uint16_t dataPort);
void sendRemoveSource(const std::string& id);
void sendSaveSources();
void sendSetMaxPoints(uint32_t n);
void sendSetTrigger(const std::string& key, const std::string& edge,
double threshold, double windowSec, double prePercent,
const std::string& mode);
void sendArm();
void sendDisarm();
void sendRearm();
void sendTrigStop(bool stopped);
void requestZoom(int plotIdx, double t0, double t1, const std::string& csv);
void requestHistoryZoom(int plotIdx, double t0, double t1, const std::string& csv);
void sendHistoryInfo();
Q_SIGNALS:
void connectedChanged(bool connected);
void sourcesChanged();
void configChanged(const QString& sourceId);
void statsChanged();
void triggerStateChanged();
void captureReceived();
void zoomReceived(int plotIdx);
void historyZoomReceived(int plotIdx);
void historyInfoChanged();
void maxPointsChanged(uint32_t n);
private Q_SLOTS:
void onConnected(bool connected);
void onText(const QString& json);
void onBinary(const QByteArray& data);
private:
void onSources(const std::string& json);
void onConfig(const std::string& json);
void onStats(const std::string& json);
void onTriggerState(const std::string& json);
void onZoom(const std::string& json);
void onHistoryZoom(const std::string& json);
void onHistoryInfo(const std::string& json);
void onMaxPointsUpdated(const std::string& json);
WsClient ws_;
std::vector<Source> sources_;
TriggerCfgState trigger_;
uint32_t maxPoints_ = 1000000u;
StreamHubClient::CaptureFrame capture_;
bool hasCapture_ = false;
StreamHubClient::HistoryInfoMsg historyInfo_;
PlotZoomCache zoomCache_[kMaxPlotSlots];
PlotZoomCache histZoomCache_[kMaxPlotSlots];
uint32_t nextZoomReqId_ = 1;
double lastHistInfoReqMs_ = 0.0;
};
} /* namespace shq */
Client/streamhub-qt/MainWindow.cpp
+322
View File
@@ -0,0 +1,322 @@
/**
* @file MainWindow.cpp
*/
#include "MainWindow.h"
#include "PlotGrid.h"
#include "SourceSidebar.h"
#include "TriggerBar.h"
#include "HistoryBar.h"
#include "StatsDialog.h"
#include "Theme.h"
#include <QToolBar>
#include <QToolButton>
#include <QComboBox>
#include <QLineEdit>
#include <QLabel>
#include <QTimer>
#include <QDockWidget>
#include <QMenu>
#include <QAction>
#include <QDialog>
#include <QFormLayout>
#include <QDialogButtonBox>
#include <QIntValidator>
#include <cmath>
namespace shq {
MainWindow::MainWindow(const QString& host, uint16_t port, QWidget* parent)
: QMainWindow(parent) {
setWindowTitle("StreamHub Qt Client");
resize(1280, 800);
/* ── Central plot grid ── */
grid_ = new PlotGrid(&hub_, &gv_, this);
setCentralWidget(grid_);
/* ── Source sidebar dock ── */
sidebar_ = new SourceSidebar(&hub_, this);
sideDock_ = new QDockWidget("Sources", this);
sideDock_->setWidget(sidebar_);
sideDock_->setFeatures(QDockWidget::DockWidgetMovable |
QDockWidget::DockWidgetClosable);
addDockWidget(Qt::LeftDockWidgetArea, sideDock_);
connect(sidebar_, &SourceSidebar::addSourceRequested,
this, &MainWindow::openAddSourceDialog);
/* ── Trigger bar (hidden until toggled) ── */
trigBar_ = new TriggerBar(&hub_, this);
auto* trigTb = new QToolBar("Trigger", this);
trigTb->setMovable(false);
trigTb->addWidget(trigBar_);
addToolBarBreak();
addToolBar(Qt::TopToolBarArea, trigTb);
trigTb->setVisible(false);
/* ── History bar (hidden until toggled) ── */
histBar_ = new HistoryBar(&hub_, grid_, this);
auto* histTb = new QToolBar("History", this);
histTb->setMovable(false);
histTb->addWidget(histBar_);
addToolBarBreak();
addToolBar(Qt::TopToolBarArea, histTb);
histTb->setVisible(false);
connect(histBar_, &HistoryBar::liveRequested, this, [this, histTb]() {
histTb->setVisible(false);
histBtn_->setChecked(false);
});
/* Keep the QToolBar pointers reachable from slots. */
trigBtn_ = nullptr; /* set in buildToolbar */
buildToolbar();
/* Wire trigger/history toggle buttons to their bars. */
connect(trigBtn_, &QToolButton::toggled, trigTb, &QToolBar::setVisible);
connect(histBtn_, &QToolButton::toggled, this, [this, histTb](bool on) {
if (on) {
const auto& hi = hub_.historyInfo();
if (hi.enabled && !hi.signals.empty()) {
histTb->setVisible(true);
histBar_->showAll();
} else {
histBtn_->setChecked(false);
}
} else {
histTb->setVisible(false);
grid_->goLive();
}
});
/* ── Hub signal wiring ── */
connect(&hub_, &Hub::connectedChanged, this, &MainWindow::onConnectedChanged);
connect(&hub_, &Hub::sourcesChanged, this, &MainWindow::onSourcesChanged);
connect(&hub_, &Hub::configChanged, this, &MainWindow::onConfigChanged);
connect(&hub_, &Hub::statsChanged, this, &MainWindow::onStatsChanged);
connect(&hub_, &Hub::triggerStateChanged, this, &MainWindow::onTriggerStateChanged);
connect(&hub_, &Hub::historyInfoChanged, this, &MainWindow::onHistoryInfoChanged);
/* ── 60 Hz repaint / refresh ── */
timer_ = new QTimer(this);
timer_->setInterval(16);
connect(timer_, &QTimer::timeout, this, &MainWindow::onTick);
timer_->start();
hostEdit_->setText(host);
portEdit_->setText(QString::number(port));
hub_.start(host, port);
onConnectedChanged(false);
}
/* ── Toolbar construction ────────────────────────────────────────────────── */
void MainWindow::buildToolbar() {
auto* tb = new QToolBar("Main", this);
tb->setMovable(false);
addToolBar(Qt::TopToolBarArea, tb);
/* Sidebar toggle. */
auto* sideBtn = new QToolButton(this);
sideBtn->setText("\u2630"); /* ≡ */
sideBtn->setCheckable(true);
sideBtn->setChecked(true);
sideBtn->setToolTip("Toggle sidebar");
connect(sideBtn, &QToolButton::toggled, sideDock_, &QDockWidget::setVisible);
connect(sideDock_, &QDockWidget::visibilityChanged, sideBtn, &QToolButton::setChecked);
tb->addWidget(sideBtn);
/* Layout picker. */
auto* layoutBtn = new QToolButton(this);
layoutBtn->setText("Layout");
layoutBtn->setPopupMode(QToolButton::InstantPopup);
auto* layMenu = new QMenu(layoutBtn);
const char* const* names = layoutNames();
for (int i = 0; i < static_cast<int>(PlotLayout::kCount); i++) {
QAction* a = layMenu->addAction(QString::fromUtf8(names[i]));
PlotLayout l = static_cast<PlotLayout>(i);
connect(a, &QAction::triggered, this, [this, l]() {
grid_->setLayout(l);
});
}
layoutBtn->setMenu(layMenu);
tb->addWidget(layoutBtn);
/* Pause. */
pauseBtn_ = new QToolButton(this);
pauseBtn_->setText("Pause");
pauseBtn_->setCheckable(true);
connect(pauseBtn_, &QToolButton::clicked, this, &MainWindow::togglePause);
tb->addWidget(pauseBtn_);
/* Cursors. */
cursorBtn_ = new QToolButton(this);
cursorBtn_->setText("Cursors");
cursorBtn_->setCheckable(true);
cursorBtn_->setToolTip("Cursors A/B");
connect(cursorBtn_, &QToolButton::toggled, this, [this](bool on) {
gv_.cursorsOn = on;
});
tb->addWidget(cursorBtn_);
/* Trigger toggle. */
trigBtn_ = new QToolButton(this);
trigBtn_->setText("Trigger");
trigBtn_->setCheckable(true);
connect(trigBtn_, &QToolButton::toggled, this, [this](bool on) {
gv_.trigView = on;
});
tb->addWidget(trigBtn_);
/* History toggle. */
histBtn_ = new QToolButton(this);
histBtn_->setText("History");
histBtn_->setCheckable(true);
histBtn_->setEnabled(false);
tb->addWidget(histBtn_);
/* Window presets. */
tb->addWidget(new QLabel(" Win ", this));
winCombo_ = new QComboBox(this);
winCombo_->setEditable(true);
static const double kWin[] = {1, 5, 10, 30, 60};
static const char* kWinL[] = {"1 s", "5 s", "10 s", "30 s", "60 s"};
for (int i = 0; i < 5; i++) { winCombo_->addItem(kWinL[i], kWin[i]); }
winCombo_->setCurrentIndex(2); /* 10 s */
connect(winCombo_, QOverload<int>::of(&QComboBox::currentIndexChanged),
this, [this](int i) {
if (i >= 0) { gv_.windowSec = winCombo_->itemData(i).toDouble(); }
});
connect(winCombo_->lineEdit(), &QLineEdit::editingFinished, this, [this]() {
double v = winCombo_->currentText().split(' ').first().toDouble();
if (v >= 1e-4 && v <= 3600.0) { gv_.windowSec = v; }
});
tb->addWidget(winCombo_);
/* Spacer pushes the rest to the right. */
auto* spacer = new QWidget(this);
spacer->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
tb->addWidget(spacer);
/* Stats. */
auto* statsBtn = new QToolButton(this);
statsBtn->setText("Stats");
connect(statsBtn, &QToolButton::clicked, this, [this]() {
if (!stats_) { stats_ = new StatsDialog(&hub_, this); }
hub_.sendGetStats();
stats_->refresh();
stats_->show();
stats_->raise();
});
tb->addWidget(statsBtn);
/* Connection. */
tb->addWidget(new QLabel(" Host ", this));
hostEdit_ = new QLineEdit(this);
hostEdit_->setMaximumWidth(120);
tb->addWidget(hostEdit_);
portEdit_ = new QLineEdit(this);
portEdit_->setMaximumWidth(60);
portEdit_->setValidator(new QIntValidator(1, 65535, this));
tb->addWidget(portEdit_);
auto* connBtn = new QToolButton(this);
connBtn->setText("Connect");
connect(connBtn, &QToolButton::clicked, this, &MainWindow::doConnect);
tb->addWidget(connBtn);
ledLbl_ = new QLabel(" \u25cf Disconnected ", this);
tb->addWidget(ledLbl_);
}
/* ── Slots ───────────────────────────────────────────────────────────────── */
void MainWindow::togglePause() {
gv_.paused = pauseBtn_->isChecked();
pauseBtn_->setText(gv_.paused ? "Resume" : "Pause");
grid_->onPauseChanged();
}
void MainWindow::toggleHistory() { /* handled inline via histBtn_ toggle */ }
void MainWindow::doConnect() {
QString host = hostEdit_->text().trimmed();
uint16_t port = static_cast<uint16_t>(portEdit_->text().toUInt());
if (host.isEmpty() || port == 0) { return; }
hub_.reconnect(host, port);
}
void MainWindow::onConnectedChanged(bool connected) {
ledLbl_->setText(connected ? " \u25cf Connected " : " \u25cf Disconnected ");
ledLbl_->setStyleSheet(connected
? "color:#a6e3a1; font-weight:bold;"
: "color:#f38ba8; font-weight:bold;");
}
void MainWindow::onSourcesChanged() {
sidebar_->refresh();
trigBar_->refreshSignals();
grid_->onModelChanged();
}
void MainWindow::onConfigChanged(const QString&) {
sidebar_->refresh();
trigBar_->refreshSignals();
grid_->onModelChanged();
}
void MainWindow::onStatsChanged() {
if (stats_ && stats_->isVisible()) { stats_->refresh(); }
}
void MainWindow::onTriggerStateChanged() {
trigBar_->onTriggerStateChanged();
}
void MainWindow::onHistoryInfoChanged() {
const auto& hi = hub_.historyInfo();
histBtn_->setEnabled(hi.enabled && !hi.signals.empty());
}
void MainWindow::onTick() {
grid_->tick();
if (histBtn_->isChecked()) { histBar_->updateReadout(); }
}
/* ── Add-source dialog ───────────────────────────────────────────────────── */
void MainWindow::openAddSourceDialog() {
QDialog dlg(this);
dlg.setWindowTitle("Add Source");
auto* form = new QFormLayout(&dlg);
auto* label = new QLineEdit(&dlg);
auto* host = new QLineEdit("127.0.0.1", &dlg);
auto* port = new QLineEdit("44500", &dlg);
port->setValidator(new QIntValidator(1, 65535, &dlg));
auto* mcast = new QLineEdit(&dlg);
auto* dport = new QLineEdit("0", &dlg);
dport->setValidator(new QIntValidator(0, 65535, &dlg));
form->addRow("Label", label);
form->addRow("Host", host);
form->addRow("Port", port);
form->addRow("Multicast", mcast);
form->addRow("Data Port", dport);
auto* box = new QDialogButtonBox(
QDialogButtonBox::Ok | QDialogButtonBox::Cancel, &dlg);
form->addRow(box);
connect(box, &QDialogButtonBox::accepted, &dlg, &QDialog::accept);
connect(box, &QDialogButtonBox::rejected, &dlg, &QDialog::reject);
if (dlg.exec() != QDialog::Accepted) { return; }
QString h = host->text().trimmed();
int p = port->text().toInt();
if (h.isEmpty() || p <= 0 || p >= 65536) { return; }
std::string addr = h.toStdString() + ":" + std::to_string(p);
int dp = dport->text().toInt();
hub_.sendAddSource(label->text().toStdString(), addr,
mcast->text().toStdString(),
static_cast<uint16_t>((dp > 0 && dp < 65536) ? dp : 0));
}
} /* namespace shq */
Client/streamhub-qt/MainWindow.h
+75
View File
@@ -0,0 +1,75 @@
/**
* @file MainWindow.h
* @brief Top-level window: toolbar, source dock, plot grid, trigger/history
* bars, stats dialog. Owns the Hub, the shared GlobalView, and the
* 60 Hz repaint/refresh timer.
*/
#pragma once
#include "Hub.h"
#include "PlotWidget.h" /* GlobalView */
#include <QMainWindow>
class QToolButton;
class QComboBox;
class QLineEdit;
class QLabel;
class QTimer;
class QDockWidget;
namespace shq {
class PlotGrid;
class SourceSidebar;
class TriggerBar;
class HistoryBar;
class StatsDialog;
class MainWindow : public QMainWindow {
Q_OBJECT
public:
explicit MainWindow(const QString& host, uint16_t port,
QWidget* parent = nullptr);
private Q_SLOTS:
void onConnectedChanged(bool connected);
void onSourcesChanged();
void onConfigChanged(const QString& sourceId);
void onStatsChanged();
void onTriggerStateChanged();
void onHistoryInfoChanged();
void onTick();
void togglePause();
void toggleHistory();
void openAddSourceDialog();
void doConnect();
private:
void buildToolbar();
Hub hub_;
GlobalView gv_;
PlotGrid* grid_ = nullptr;
SourceSidebar* sidebar_= nullptr;
QDockWidget* sideDock_ = nullptr;
TriggerBar* trigBar_= nullptr;
HistoryBar* histBar_= nullptr;
StatsDialog* stats_ = nullptr;
QToolButton* pauseBtn_ = nullptr;
QToolButton* cursorBtn_ = nullptr;
QToolButton* trigBtn_ = nullptr;
QToolButton* histBtn_ = nullptr;
QComboBox* winCombo_ = nullptr;
QLineEdit* hostEdit_ = nullptr;
QLineEdit* portEdit_ = nullptr;
QLabel* ledLbl_ = nullptr;
QTimer* timer_ = nullptr;
};
} /* namespace shq */
Client/streamhub-qt/Model.h
+125
View File
@@ -0,0 +1,125 @@
/**
* @file Model.h
* @brief Domain types for the Qt StreamHub client.
*
* Mirrors the ImGui client's App.h domain model, but uses QColor instead of
* ImVec4 and adds no Qt widget dependencies (pure data).
*/
#pragma once
#include "Protocol.h" // SignalMeta, SourceStats (reused, framework-free)
#include "SignalBuffer.h" // SignalBuffer, LTTBDecimate (reused)
#include <QColor>
#include <string>
#include <vector>
#include <cstdint>
namespace shq {
using StreamHubClient::SignalMeta;
using StreamHubClient::SourceStats;
using StreamHubClient::SignalBuffer;
/** One signal as known to the client. */
struct SignalView {
SignalMeta meta;
SignalBuffer buf{1000000};
QColor color{137, 180, 250}; /* Catppuccin blue */
double lineWidth = 1.5;
int marker = -1; /* -1 = none, else MarkerStyle index */
bool visible = true;
};
/** One connected UDPStreamer source. */
struct Source {
std::string id;
std::string label;
std::string addr;
std::string state = "disconnected";
uint32_t port = 0;
bool configured = false;
int publishMode = 0;
std::vector<SignalView> signals;
SourceStats stats;
};
/** Trigger configuration + live state (hub-side trigger semantics). */
struct TriggerCfgState {
/* Config (sent to hub via setTrigger) */
std::string signalKey; /* full key "src:sig" or "src:sig[i]" */
int edge = 0; /* 0=rising 1=falling 2=both */
double threshold = 0.0;
double windowSec = 0.1; /* 100 µs .. 10 s */
double prePercent = 20.0;
bool single = false; /* false=normal true=single */
/* Live (driven by hub triggerState broadcasts) */
std::string status = "idle"; /* idle|armed|collecting|triggered */
bool stopped = false;
bool hasTrigTime = false;
double trigTime = 0.0;
/* Window the hub latched at fire time. Not the same as windowSec/prePercent
* above, which are editable and may have moved on since the trigger fired. */
bool hasFiredWin = false;
double firedPreS = 0.0;
double firedPostS = 0.0;
};
/** Per-signal vertical scale state (oscilloscope style). */
struct VScale {
int mode = 0; /* 0=auto 1=range 2=manual */
double divValue = 1.0; /* units per division (manual) */
double offset = 0.0; /* raw value at center (manual) */
double screenPos = 0.0; /* position offset in divisions from center */
bool digitalInMixed = false;
/* Resolved each frame: */
double resolvedDiv = 1.0;
double resolvedOffset = 0.0;
};
/** Assignment of one signal to a plot panel. */
struct PlotAssignment {
int sourceIdx = -1;
int signalIdx = -1;
VScale vs;
};
/*---------------------------------------------------------------------------*/
/* Plot layouts (mirror the web UI: cols×rows) */
/*---------------------------------------------------------------------------*/
enum class PlotLayout {
k1x1 = 0, k2x1, k1x2, k3x1, k1x3, k2x2, k4x1, k1x4, kCount
};
inline const char* const* layoutNames() {
static const char* const names[] = {
"1\u00d71", "2\u00d71", "1\u00d72", "3\u00d71",
"1\u00d73", "2\u00d72", "4\u00d71", "1\u00d74"
};
return names;
}
inline void layoutDims(PlotLayout l, int& cols, int& rows) {
switch (l) {
case PlotLayout::k1x1: cols = 1; rows = 1; break;
case PlotLayout::k2x1: cols = 2; rows = 1; break;
case PlotLayout::k1x2: cols = 1; rows = 2; break;
case PlotLayout::k3x1: cols = 3; rows = 1; break;
case PlotLayout::k1x3: cols = 1; rows = 3; break;
case PlotLayout::k2x2: cols = 2; rows = 2; break;
case PlotLayout::k4x1: cols = 4; rows = 1; break;
case PlotLayout::k1x4: cols = 1; rows = 4; break;
default: cols = 1; rows = 1; break;
}
}
inline int layoutSlots(PlotLayout l) {
int c, r; layoutDims(l, c, r); return c * r;
}
static const int kMaxPlotSlots = 8;
} /* namespace shq */
Client/streamhub-qt/PlotGrid.cpp
+138
View File
@@ -0,0 +1,138 @@
/**
* @file PlotGrid.cpp
*/
#include "PlotGrid.h"
#include "PlotWidget.h"
#include "Hub.h"
#include <QVBoxLayout>
#include <QSplitter>
#include <QDateTime>
namespace shq {
static double nowSec() {
return QDateTime::currentMSecsSinceEpoch() / 1000.0;
}
PlotGrid::PlotGrid(Hub* hub, GlobalView* gv, QWidget* parent)
: QWidget(parent), hub_(hub), gv_(gv) {
/* Persistent pool: one PlotWidget per slot, fixed plotIdx (== zoom cache
* index). Plots beyond the current layout are simply not mounted. */
pool_.reserve(kMaxPlotSlots);
for (int i = 0; i < kMaxPlotSlots; i++) {
auto* p = new PlotWidget(hub_, gv_, i, this);
connect(hub_, &Hub::zoomReceived, p, &PlotWidget::onZoomReceived);
connect(hub_, &Hub::historyZoomReceived, p, &PlotWidget::onHistoryZoomReceived);
connect(hub_, &Hub::captureReceived, p, &PlotWidget::onCaptureReceived);
p->setParent(nullptr);
p->hide();
pool_.push_back(p);
}
auto* lay = new QVBoxLayout(this);
lay->setContentsMargins(0, 0, 0, 0);
rebuild();
}
void PlotGrid::setLayout(PlotLayout l) {
if (l == layout_) { return; }
layout_ = l;
rebuild();
}
void PlotGrid::rebuild() {
/* Detach every pooled plot from any previous splitter. */
for (auto* p : pool_) { p->setParent(this); p->hide(); }
/* Drop the old root splitter (if any). */
QLayout* lay = this->QWidget::layout();
QLayoutItem* item;
while ((item = lay->takeAt(0)) != nullptr) {
if (QWidget* w = item->widget()) {
if (qobject_cast<QSplitter*>(w)) { w->deleteLater(); }
}
delete item;
}
int cols, rows;
layoutDims(layout_, cols, rows);
auto* outer = new QSplitter(Qt::Vertical, this);
outer->setChildrenCollapsible(false);
outer->setHandleWidth(5);
plots_.clear();
for (int r = 0; r < rows; r++) {
QSplitter* rowSplit = outer;
if (cols > 1) {
rowSplit = new QSplitter(Qt::Horizontal, outer);
rowSplit->setChildrenCollapsible(false);
rowSplit->setHandleWidth(5);
}
for (int c = 0; c < cols; c++) {
int idx = r * cols + c;
PlotWidget* p = pool_[idx];
p->setParent(rowSplit);
p->show();
if (cols > 1) { rowSplit->addWidget(p); }
else { outer->addWidget(p); }
plots_.push_back(p);
}
if (cols > 1) { outer->addWidget(rowSplit); }
}
lay->addWidget(outer);
onModelChanged();
}
void PlotGrid::onModelChanged() { for (auto* p : plots_) { p->onModelChanged(); } }
void PlotGrid::onPauseChanged() { for (auto* p : plots_) { p->onPauseChanged(); } }
void PlotGrid::tick() { for (auto* p : plots_) { p->tick(); } }
void PlotGrid::goLive() {
for (auto* p : plots_) { p->setLive(true); }
}
void PlotGrid::setAllStoredX(double t0, double t1) {
if (t1 <= t0) { return; }
for (auto* p : plots_) { p->setLive(false); p->setStoredX(t0, t1); }
}
bool PlotGrid::anyNonLive() const {
for (auto* p : plots_) { if (!p->isLive()) { return true; } }
return false;
}
bool PlotGrid::currentRange(double& t0, double& t1) const {
for (auto* p : plots_) {
if (!p->isLive()) { t0 = p->xMin(); t1 = p->xMax(); return true; }
}
return false;
}
void PlotGrid::panAll(double frac) {
const double wallNow = nowSec();
for (auto* p : plots_) {
if (p->isLive()) { continue; }
double span = p->xMax() - p->xMin();
if (span <= 0.0) { continue; }
double d = span * frac;
double mn = p->xMin() + d, mx = p->xMax() + d;
if (mx > wallNow) { mx = wallNow; mn = mx - span; }
p->setStoredX(mn, mx);
}
}
void PlotGrid::jumpAllAgo(double secAgo) {
const double wallNow = nowSec();
for (auto* p : plots_) {
double span = p->xMax() - p->xMin();
if (span <= 0.0) { span = gv_->windowSec; }
p->setLive(false);
p->setStoredX(wallNow - secAgo - span, wallNow - secAgo);
}
}
} /* namespace shq */
Client/streamhub-qt/PlotGrid.h
+61
View File
@@ -0,0 +1,61 @@
/**
* @file PlotGrid.h
* @brief Resizable grid of PlotWidgets realising the selected PlotLayout.
*
* Built from nested QSplitters (rows of columns) so cells are user-resizable,
* mirroring the ImGui draggable separators. Holds up to kMaxPlotSlots plots,
* fans out the 60 Hz tick / model / pause notifications, and drives the
* history navigation (live ⇄ stored-X) for all visible plots.
*/
#pragma once
#include "Model.h"
#include <QWidget>
#include <vector>
namespace shq {
class Hub;
struct GlobalView;
class PlotWidget;
class PlotGrid : public QWidget {
Q_OBJECT
public:
PlotGrid(Hub* hub, GlobalView* gv, QWidget* parent = nullptr);
void setLayout(PlotLayout l);
PlotLayout layout() const { return layout_; }
int numSlots() const { return layoutSlots(layout_); }
/** Visible plots (size == numSlots()). */
const std::vector<PlotWidget*>& plots() const { return plots_; }
public Q_SLOTS:
void onModelChanged();
void onPauseChanged();
void tick();
/** History navigation helpers (operate on all visible plots). */
void goLive();
void setAllStoredX(double t0, double t1);
void panAll(double frac); /* +right / -left, frac of span */
void jumpAllAgo(double secAgo); /* set window ending secAgo before now */
bool anyNonLive() const;
/** Current stored range of the first non-live plot (false if all live). */
bool currentRange(double& t0, double& t1) const;
private:
void rebuild();
Hub* hub_;
GlobalView* gv_;
PlotLayout layout_ = PlotLayout::k1x1;
std::vector<PlotWidget*> plots_; /* currently mounted (== numSlots) */
std::vector<PlotWidget*> pool_; /* all kMaxPlotSlots, persistent */
};
} /* namespace shq */
Client/streamhub-qt/PlotWidget.cpp
+1041
View File
File diff suppressed because it is too large Load Diff
Client/streamhub-qt/PlotWidget.h
+114
View File
@@ -0,0 +1,114 @@
/**
* @file PlotWidget.h
* @brief Oscilloscope plot panel (custom QPainter), one per grid cell.
*
* Mirrors the ImGui PlotPanel: fixed +/-4 division Y space, wall-clock live X
* window, LTTB decimation, normal/digital/mixed normalization, A/B cursors,
* scroll/drag zoom + pan, zoom history, hi-res WS zoom + history zoom, and a
* trigger-capture view rendered in [-pre, +post].
*/
#pragma once
#include "Model.h"
#include <QWidget>
#include <QString>
#include <vector>
#include <utility>
#include <string>
class QHBoxLayout;
class QToolButton;
class QLabel;
class QMenu;
namespace shq {
class Hub;
/** View state shared (synchronised) across all plots; owned by MainWindow. */
struct GlobalView {
double windowSec = 10.0; /* live scroll window width */
bool paused = false; /* global pause */
bool cursorsOn = false;
double cursorA = 0.0;
double cursorB = 0.0;
bool trigView = false; /* trigger bar open → render capture */
};
class PlotCanvas;
class PlotWidget : public QWidget {
Q_OBJECT
public:
PlotWidget(Hub* hub, GlobalView* gv, int plotIdx, QWidget* parent = nullptr);
std::vector<PlotAssignment>& slots() { return slots_; }
void addAssignment(int sourceIdx, int signalIdx);
/** Called by MainWindow when sources/config change so badges refresh. */
void onModelChanged();
/** Called by MainWindow when global pause toggles. */
void onPauseChanged();
/** Reset zoom/live state (e.g. when entering/leaving history mode). */
void setLive(bool live);
bool isLive() const { return live_; }
void setStoredX(double mn, double mx);
double xMin() const { return plotXMin_; }
double xMax() const { return plotXMax_; }
int plotIdx() const { return plotIdx_; }
public Q_SLOTS:
void onZoomReceived(int plotIdx);
void onHistoryZoomReceived(int plotIdx);
void onCaptureReceived();
void tick(); /* ~60 Hz repaint + throttled zoom requests */
private:
friend class PlotCanvas;
void rebuildHeader();
void buildVScaleMenu(QMenu* vs, VScale& evs);
void showUnifiedVScaleMenu(const QPoint& globalPos);
void showBadgeMenu(int slotIdx, const QPoint& globalPos);
void pushZoomHist();
void initPlotX(double tMax);
Hub* hub_;
GlobalView* gv_;
int plotIdx_;
PlotCanvas* canvas_ = nullptr;
QHBoxLayout* headerLay_ = nullptr;
QWidget* header_ = nullptr;
QLabel* cursorLbl_ = nullptr;
std::vector<PlotAssignment> slots_;
bool live_ = true;
bool paused_ = false;
double plotXMin_ = 0.0;
double plotXMax_ = 0.0;
int vMode_ = 0; /* 0 normal 1 digital 2 mixed 3 unified */
VScale uniVS_; /* the one scale every trace shares in mode 3 */
int activeSlot_ = -1;
bool trigZoomed_ = false;
std::vector<std::pair<double,double>> zoomHist_;
/* Paused view snapshot (double buffer). */
struct Snapshot {
bool valid = false;
std::vector<std::string> keys;
std::vector<std::vector<double>> t, v;
} snap_;
/* Throttle timers (ms wall clock). */
double lastLiveZoomMs_ = 0.0;
double rangeChangedMs_ = 0.0;
double lastT0_ = 0.0, lastT1_ = 0.0;
double lastHistPushMs_ = 0.0;
};
} /* namespace shq */
Client/streamhub-qt/SourceSidebar.cpp
+167
View File
@@ -0,0 +1,167 @@
/**
* @file SourceSidebar.cpp
*/
#include "SourceSidebar.h"
#include "Hub.h"
#include "Theme.h"
#include <QVBoxLayout>
#include <QTreeWidget>
#include <QHeaderView>
#include <QPushButton>
#include <QMenu>
#include <QMimeData>
#include <QDrag>
#include <QPainter>
#include <QPixmap>
#include <QIcon>
#include <QSet>
#include <QDataStream>
#include <QApplication>
namespace shq {
const char* const kMimeSignal = "application/x-shq-signal";
/* Roles for tree items. */
enum { RoleSrcIdx = Qt::UserRole + 1, RoleSigIdx, RoleSrcId };
/** QTreeWidget subclass that emits a signal drag with the qint32[2] payload. */
class SourceTree : public QTreeWidget {
public:
explicit SourceTree(QWidget* parent = nullptr) : QTreeWidget(parent) {
setDragEnabled(true);
setDragDropMode(QAbstractItemView::DragOnly);
}
protected:
void startDrag(Qt::DropActions /*supported*/) override {
QTreeWidgetItem* it = currentItem();
if (!it) { return; }
bool ok = false;
int sigIdx = it->data(0, RoleSigIdx).toInt(&ok);
if (!ok || sigIdx < 0) { return; } /* only signal leaves drag */
int srcIdx = it->data(0, RoleSrcIdx).toInt();
QByteArray payload;
{
QDataStream ds(&payload, QIODevice::WriteOnly);
ds.setByteOrder(QDataStream::LittleEndian);
ds << static_cast<qint32>(srcIdx) << static_cast<qint32>(sigIdx);
}
auto* mime = new QMimeData;
mime->setData(kMimeSignal, payload);
auto* drag = new QDrag(this);
drag->setMimeData(mime);
drag->exec(Qt::CopyAction);
}
};
SourceSidebar::SourceSidebar(Hub* hub, QWidget* parent)
: QWidget(parent), hub_(hub) {
auto* lay = new QVBoxLayout(this);
lay->setContentsMargins(4, 4, 4, 4);
lay->setSpacing(4);
tree_ = new SourceTree(this);
tree_->setHeaderHidden(true);
tree_->setColumnCount(1);
tree_->setContextMenuPolicy(Qt::CustomContextMenu);
tree_->setIndentation(12);
connect(tree_, &QTreeWidget::customContextMenuRequested,
this, &SourceSidebar::onContextMenu);
lay->addWidget(tree_, 1);
auto* addBtn = new QPushButton("+ Add Source", this);
connect(addBtn, &QPushButton::clicked, this,
&SourceSidebar::addSourceRequested);
lay->addWidget(addBtn);
auto* saveBtn = new QPushButton("Save Sources", this);
connect(saveBtn, &QPushButton::clicked, this,
[this]() { hub_->sendSaveSources(); });
lay->addWidget(saveBtn);
refresh();
}
/** Small square color swatch icon. */
static QIcon swatch(const QColor& c) {
QPixmap pm(12, 12);
pm.fill(Qt::transparent);
QPainter p(&pm);
p.setPen(Qt::NoPen);
p.setBrush(c);
p.drawRect(0, 0, 12, 12);
return QIcon(pm);
}
void SourceSidebar::refresh() {
/* Preserve expansion state by source id. */
QSet<QString> expanded;
for (int i = 0; i < tree_->topLevelItemCount(); i++) {
QTreeWidgetItem* it = tree_->topLevelItem(i);
if (it->isExpanded()) {
expanded.insert(it->data(0, RoleSrcId).toString());
}
}
tree_->clear();
const auto& sources = hub_->sources();
for (int s = 0; s < static_cast<int>(sources.size()); s++) {
const Source& src = sources[s];
QString label = QString::fromStdString(
src.label.empty() ? src.id : src.label);
bool connected = (src.state == "connected");
QString dot = connected ? QString::fromUtf8("\u25cf ")
: QString::fromUtf8("\u25cb ");
auto* top = new QTreeWidgetItem(tree_);
top->setText(0, dot + label);
top->setForeground(0, connected ? col::green() : col::red());
top->setData(0, RoleSrcIdx, s);
top->setData(0, RoleSigIdx, -1);
top->setData(0, RoleSrcId, QString::fromStdString(src.id));
top->setFlags(Qt::ItemIsEnabled);
for (int g = 0; g < static_cast<int>(src.signals.size()); g++) {
const SignalView& sig = src.signals[g];
QString name = QString::fromStdString(sig.meta.name);
if (sig.meta.numElements > 1) {
name += QString(" [%1]").arg(sig.meta.numElements);
}
if (!sig.meta.unit.empty()) {
name += " (" + QString::fromStdString(sig.meta.unit) + ")";
}
auto* leaf = new QTreeWidgetItem(top);
leaf->setText(0, name);
leaf->setIcon(0, swatch(sig.color));
leaf->setData(0, RoleSrcIdx, s);
leaf->setData(0, RoleSigIdx, g);
leaf->setData(0, RoleSrcId, QString::fromStdString(src.id));
leaf->setForeground(0, col::text());
leaf->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable |
Qt::ItemIsDragEnabled);
}
if (expanded.isEmpty() ||
expanded.contains(QString::fromStdString(src.id))) {
top->setExpanded(true);
}
}
}
void SourceSidebar::onContextMenu(const QPoint& pos) {
QTreeWidgetItem* it = tree_->itemAt(pos);
if (!it) { return; }
QString srcId = it->data(0, RoleSrcId).toString();
if (srcId.isEmpty()) { return; }
QMenu menu(this);
QAction* rm = menu.addAction("Remove source");
if (menu.exec(tree_->viewport()->mapToGlobal(pos)) == rm) {
hub_->sendRemoveSource(srcId.toStdString());
}
}
} /* namespace shq */
Client/streamhub-qt/SourceSidebar.h
+44
View File
@@ -0,0 +1,44 @@
/**
* @file SourceSidebar.h
* @brief Source browser sidebar: tree of sources → signals with drag-to-plot.
*
* Mirrors the ImGui SourcePanel. Each signal leaf is draggable; the drag
* payload is the mime type "application/x-shq-signal" carrying two qint32
* values {sourceIdx, signalIdx}, consumed by PlotWidget's drop handler.
*/
#pragma once
#include <QWidget>
class QTreeWidget;
class QTreeWidgetItem;
namespace shq {
class Hub;
/** MIME type carried by a signal drag: payload = qint32[2] {srcIdx,sigIdx}. */
extern const char* const kMimeSignal;
class SourceSidebar : public QWidget {
Q_OBJECT
public:
explicit SourceSidebar(Hub* hub, QWidget* parent = nullptr);
public Q_SLOTS:
/** Rebuild the tree from the current model (sources/config changes). */
void refresh();
Q_SIGNALS:
/** User clicked "Add Source" (MainWindow opens the dialog). */
void addSourceRequested();
private:
void onContextMenu(const QPoint& pos);
Hub* hub_;
QTreeWidget* tree_ = nullptr;
};
} /* namespace shq */
Client/streamhub-qt/StatsDialog.cpp
+162
View File
@@ -0,0 +1,162 @@
/**
* @file StatsDialog.cpp
*/
#include "StatsDialog.h"
#include "Hub.h"
#include "Theme.h"
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QTableWidget>
#include <QHeaderView>
#include <QLabel>
#include <QPushButton>
#include <QScrollArea>
#include <QPainter>
#include <cstdio>
namespace shq {
using StreamHubClient::SourceStats;
/* ── HistogramWidget ─────────────────────────────────────────────────────── */
HistogramWidget::HistogramWidget(QWidget* parent) : QWidget(parent) {
setMinimumHeight(120);
}
void HistogramWidget::setData(const SourceStats& st) {
min_ = st.cycleHistMin;
max_ = st.cycleHistMax;
valid_ = (max_ > min_);
for (int i = 0; i < 20; i++) { bins_[i] = st.cycleHist[i]; }
update();
}
void HistogramWidget::paintEvent(QPaintEvent*) {
QPainter p(this);
p.fillRect(rect(), col::mantle());
if (!valid_) { return; }
double maxCount = 0.0;
for (int i = 0; i < 20; i++) { if (bins_[i] > maxCount) { maxCount = bins_[i]; } }
if (maxCount <= 0.0) { return; }
const int L = 4, R = 4, T = 4, B = 16;
QRectF area(L, T, width() - L - R, height() - T - B);
double bw = area.width() / 20.0;
p.setPen(Qt::NoPen);
p.setBrush(col::blue());
for (int i = 0; i < 20; i++) {
double h = (bins_[i] / maxCount) * area.height();
QRectF bar(area.left() + i * bw + 1, area.bottom() - h,
bw - 2, h);
p.drawRect(bar);
}
p.setPen(col::subtext());
QFont f = p.font(); f.setPointSize(7); p.setFont(f);
p.drawText(QRectF(L, height() - B, area.width() / 2, B),
Qt::AlignLeft | Qt::AlignVCenter,
QString::number(min_, 'g', 3) + " ms");
p.drawText(QRectF(L + area.width() / 2, height() - B, area.width() / 2, B),
Qt::AlignRight | Qt::AlignVCenter,
QString::number(max_, 'g', 3) + " ms");
}
/* ── StatsDialog ─────────────────────────────────────────────────────────── */
static const char* kCols[] = {
"Source", "State", "Cycles Rx", "Lost", "Rate Hz",
"Frags/cyc", "Bytes/cyc", "Cycle ms (avg±std)", "Cycle ms (min/max)"
};
static const int kNumCols = 9;
StatsDialog::StatsDialog(Hub* hub, QWidget* parent)
: QDialog(parent), hub_(hub) {
setWindowTitle("Statistics");
resize(760, 460);
auto* lay = new QVBoxLayout(this);
table_ = new QTableWidget(this);
table_->setColumnCount(kNumCols);
QStringList headers;
for (int i = 0; i < kNumCols; i++) { headers << kCols[i]; }
table_->setHorizontalHeaderLabels(headers);
table_->verticalHeader()->setVisible(false);
table_->setEditTriggers(QAbstractItemView::NoEditTriggers);
table_->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
lay->addWidget(table_);
auto* scroll = new QScrollArea(this);
scroll->setWidgetResizable(true);
auto* histHost = new QWidget(scroll);
histLay_ = new QVBoxLayout(histHost);
scroll->setWidget(histHost);
lay->addWidget(scroll, 1);
auto* btnRow = new QHBoxLayout();
btnRow->addStretch(1);
auto* refreshBtn = new QPushButton("Refresh", this);
connect(refreshBtn, &QPushButton::clicked, this, [this]() {
hub_->sendGetStats();
refresh();
});
btnRow->addWidget(refreshBtn);
lay->addLayout(btnRow);
refresh();
}
void StatsDialog::refresh() {
const auto& sources = hub_->sources();
table_->setRowCount(static_cast<int>(sources.size()));
char buf[64];
for (int r = 0; r < static_cast<int>(sources.size()); r++) {
const Source& src = sources[r];
const SourceStats& st = src.stats;
auto set = [&](int c, const QString& s, const QColor* fg = nullptr) {
auto* it = new QTableWidgetItem(s);
if (fg) { it->setForeground(*fg); }
table_->setItem(r, c, it);
};
set(0, QString::fromStdString(src.id));
QColor stc = (st.state == "connected") ? col::green() : col::red();
set(1, QString::fromStdString(st.state), &stc);
set(2, QString::number(static_cast<qulonglong>(st.totalReceived)));
set(3, QString::number(static_cast<qulonglong>(st.totalLost)));
snprintf(buf, sizeof(buf), "%.2f \u00b1 %.2f", st.rateHz, st.rateStdHz);
set(4, buf);
snprintf(buf, sizeof(buf), "%.1f", st.fragsPerCycle); set(5, buf);
snprintf(buf, sizeof(buf), "%.0f", st.bytesPerCycle); set(6, buf);
snprintf(buf, sizeof(buf), "%.3f \u00b1 %.3f", st.cycleAvgMs, st.cycleStdMs);
set(7, buf);
snprintf(buf, sizeof(buf), "%.3f / %.3f", st.cycleMinMs, st.cycleMaxMs);
set(8, buf);
}
/* Rebuild histogram blocks. */
for (auto* w : histBlocks_) { w->deleteLater(); }
histBlocks_.clear();
hists_.clear();
for (const auto& src : sources) {
if (src.stats.cycleHistMax <= src.stats.cycleHistMin) { continue; }
auto* block = new QWidget();
auto* bl = new QVBoxLayout(block);
bl->setContentsMargins(0, 0, 0, 0);
bl->addWidget(new QLabel("Cycle time — " +
QString::fromStdString(src.id), block));
auto* h = new HistogramWidget(block);
h->setData(src.stats);
bl->addWidget(h);
histLay_->addWidget(block);
histBlocks_.push_back(block);
hists_.push_back(h);
}
}
} /* namespace shq */
Client/streamhub-qt/StatsDialog.h
+54
View File
@@ -0,0 +1,54 @@
/**
* @file StatsDialog.h
* @brief Per-source statistics table + cycle-time histograms.
*
* Mirrors the ImGui StatsPanel: a metrics table (rate, lost, frags/bytes per
* cycle, cycle ms avg/std/min/max) and a 20-bin cycle-time histogram per
* source, drawn with a small QPainter bar widget.
*/
#pragma once
#include "Protocol.h"
#include <QDialog>
class QTableWidget;
class QVBoxLayout;
namespace shq {
class Hub;
/** Small bar-chart widget for a 20-bin cycle-time histogram. */
class HistogramWidget : public QWidget {
Q_OBJECT
public:
explicit HistogramWidget(QWidget* parent = nullptr);
void setData(const StreamHubClient::SourceStats& st);
QSize sizeHint() const override { return QSize(400, 120); }
protected:
void paintEvent(QPaintEvent*) override;
private:
double bins_[20] = {};
double min_ = 0.0, max_ = 0.0;
bool valid_ = false;
};
class StatsDialog : public QDialog {
Q_OBJECT
public:
explicit StatsDialog(Hub* hub, QWidget* parent = nullptr);
public Q_SLOTS:
void refresh();
private:
Hub* hub_;
QTableWidget* table_ = nullptr;
QVBoxLayout* histLay_ = nullptr;
std::vector<HistogramWidget*> hists_;
std::vector<QWidget*> histBlocks_;
};
} /* namespace shq */
Client/streamhub-qt/Theme.cpp
+82
View File
@@ -0,0 +1,82 @@
/**
* @file Theme.cpp
*/
#include "Theme.h"
#include <QApplication>
#include <QPalette>
namespace shq {
QColor tracePalette(int idx) {
static const QColor pal[8] = {
QColor(0x89, 0xb4, 0xfa), /* blue */
QColor(0xa6, 0xe3, 0xa1), /* green */
QColor(0xf3, 0x8b, 0xa8), /* red */
QColor(0xfa, 0xb3, 0x87), /* peach */
QColor(0xcb, 0xa6, 0xf7), /* mauve */
QColor(0x94, 0xe2, 0xd5), /* teal */
QColor(0x89, 0xdc, 0xeb), /* sky */
QColor(0xb4, 0xbe, 0xfe), /* lavender */
};
if (idx < 0) idx = 0;
return pal[idx % 8];
}
void applyTheme(QApplication& app) {
app.setStyle("Fusion");
QPalette p;
p.setColor(QPalette::Window, col::base());
p.setColor(QPalette::WindowText, col::text());
p.setColor(QPalette::Base, col::mantle());
p.setColor(QPalette::AlternateBase, col::surface0());
p.setColor(QPalette::ToolTipBase, col::surface0());
p.setColor(QPalette::ToolTipText, col::text());
p.setColor(QPalette::Text, col::text());
p.setColor(QPalette::Button, col::surface0());
p.setColor(QPalette::ButtonText, col::text());
p.setColor(QPalette::BrightText, col::red());
p.setColor(QPalette::Link, col::blue());
p.setColor(QPalette::Highlight, col::blue());
p.setColor(QPalette::HighlightedText, col::crust());
p.setColor(QPalette::PlaceholderText, col::overlay0());
p.setColor(QPalette::Disabled, QPalette::Text, col::overlay0());
p.setColor(QPalette::Disabled, QPalette::ButtonText, col::overlay0());
p.setColor(QPalette::Disabled, QPalette::WindowText, col::overlay0());
app.setPalette(p);
app.setStyleSheet(QStringLiteral(R"qss(
QToolTip { color: #cdd6f4; background-color: #313244; border: 1px solid #45475a; }
QPushButton {
background-color: #313244; color: #cdd6f4;
border: 1px solid #45475a; border-radius: 5px;
padding: 4px 9px;
}
QPushButton:hover { background-color: #45475a; }
QPushButton:pressed { background-color: #585b70; }
QPushButton:checked { background-color: #3a4a6a; border-color: #89b4fa; color: #89b4fa; }
QPushButton:disabled { color: #6c7086; }
QComboBox, QSpinBox, QDoubleSpinBox, QLineEdit {
background-color: #313244; color: #cdd6f4;
border: 1px solid #45475a; border-radius: 5px; padding: 3px 6px;
}
QComboBox QAbstractItemView { background-color: #181825; color: #cdd6f4; selection-background-color: #45475a; }
QTreeWidget, QTableWidget, QListWidget {
background-color: #181825; color: #cdd6f4;
border: 1px solid #313244; border-radius: 6px;
}
QHeaderView::section { background-color: #313244; color: #cdd6f4; border: none; padding: 4px; }
QSplitter::handle { background-color: #313244; }
QToolBar { background-color: #11111b; border: none; spacing: 4px; padding: 3px; }
QMenu { background-color: #181825; color: #cdd6f4; border: 1px solid #45475a; }
QMenu::item:selected { background-color: #45475a; }
QSlider::groove:horizontal { height: 4px; background: #45475a; border-radius: 2px; }
QSlider::handle:horizontal { width: 14px; background: #89b4fa; border-radius: 7px; margin: -5px 0; }
QLabel { color: #cdd6f4; }
QDialog, QMainWindow { background-color: #1e1e2e; }
)qss"));
}
} /* namespace shq */
Client/streamhub-qt/Theme.h
+39
View File
@@ -0,0 +1,39 @@
/**
* @file Theme.h
* @brief Catppuccin-Mocha dark theme + trace color palette.
*/
#pragma once
#include <QColor>
class QApplication;
namespace shq {
/** Apply the Catppuccin-Mocha palette + stylesheet to the application. */
void applyTheme(QApplication& app);
/** Catppuccin-Mocha trace palette (8 colors, cycles). */
QColor tracePalette(int idx);
/* Named palette entries used across widgets. */
namespace col {
inline QColor crust() { return QColor(0x11, 0x11, 0x1b); }
inline QColor mantle() { return QColor(0x18, 0x18, 0x25); }
inline QColor base() { return QColor(0x1e, 0x1e, 0x2e); }
inline QColor surface0() { return QColor(0x31, 0x32, 0x44); }
inline QColor surface1() { return QColor(0x45, 0x47, 0x5a); }
inline QColor surface2() { return QColor(0x58, 0x5b, 0x70); }
inline QColor overlay0() { return QColor(0x6c, 0x70, 0x86); }
inline QColor text() { return QColor(0xcd, 0xd6, 0xf4); }
inline QColor subtext() { return QColor(0xa6, 0xad, 0xc8); }
inline QColor blue() { return QColor(0x89, 0xb4, 0xfa); }
inline QColor green() { return QColor(0xa6, 0xe3, 0xa1); }
inline QColor red() { return QColor(0xf3, 0x8b, 0xa8); }
inline QColor peach() { return QColor(0xfa, 0xb3, 0x87); }
inline QColor mauve() { return QColor(0xcb, 0xa6, 0xf7); }
inline QColor yellow() { return QColor(0xf9, 0xe2, 0xaf); }
}
} /* namespace shq */
Client/streamhub-qt/TriggerBar.cpp
+175
View File
@@ -0,0 +1,175 @@
/**
* @file TriggerBar.cpp
*/
#include "TriggerBar.h"
#include "Hub.h"
#include "Theme.h"
#include <QHBoxLayout>
#include <QComboBox>
#include <QDoubleSpinBox>
#include <QSlider>
#include <QLabel>
#include <QPushButton>
#include <QRadioButton>
#include <QButtonGroup>
#include <cmath>
namespace shq {
/* Window presets (100 us .. 10 s), mirrors the web UI. */
static const double kWinVals[] = {1e-4, 1e-3, 1e-2, 1e-1, 1.0, 10.0};
static const char* kWinLabels[] = {"100 us", "1 ms", "10 ms", "100 ms", "1 s", "10 s"};
static const int kNumWins = 6;
static const char* kEdgeWire[] = {"rising", "falling", "both"};
TriggerBar::TriggerBar(Hub* hub, QWidget* parent)
: QWidget(parent), hub_(hub) {
auto* lay = new QHBoxLayout(this);
lay->setContentsMargins(6, 2, 6, 2);
lay->setSpacing(6);
lay->addWidget(new QLabel("Trig:", this));
sigCombo_ = new QComboBox(this);
sigCombo_->setMinimumWidth(150);
lay->addWidget(sigCombo_);
edgeCombo_ = new QComboBox(this);
edgeCombo_->addItems({"Rising", "Falling", "Both"});
lay->addWidget(edgeCombo_);
lay->addWidget(new QLabel("Thr", this));
thrSpin_ = new QDoubleSpinBox(this);
thrSpin_->setRange(-1e12, 1e12);
thrSpin_->setDecimals(6);
thrSpin_->setMaximumWidth(100);
lay->addWidget(thrSpin_);
lay->addWidget(new QLabel("Win", this));
winCombo_ = new QComboBox(this);
for (int i = 0; i < kNumWins; i++) { winCombo_->addItem(kWinLabels[i]); }
winCombo_->setCurrentIndex(3); /* 100 ms */
lay->addWidget(winCombo_);
lay->addWidget(new QLabel("Pre", this));
preSlider_ = new QSlider(Qt::Horizontal, this);
preSlider_->setRange(0, 100);
preSlider_->setValue(20);
preSlider_->setMaximumWidth(90);
lay->addWidget(preSlider_);
preLbl_ = new QLabel("20%", this);
preLbl_->setMinimumWidth(34);
lay->addWidget(preLbl_);
normRadio_ = new QRadioButton("Norm", this);
singleRadio_ = new QRadioButton("1x", this);
normRadio_->setChecked(true);
auto* grp = new QButtonGroup(this);
grp->addButton(normRadio_);
grp->addButton(singleRadio_);
lay->addWidget(normRadio_);
lay->addWidget(singleRadio_);
badge_ = new QLabel("[IDLE]", this);
badge_->setMinimumWidth(90);
lay->addWidget(badge_);
armBtn_ = new QPushButton("Arm", this);
disarmBtn_ = new QPushButton("Disarm", this);
stopBtn_ = new QPushButton("Stop", this);
lay->addWidget(armBtn_);
lay->addWidget(disarmBtn_);
lay->addWidget(stopBtn_);
trigTimeLbl_ = new QLabel("", this);
trigTimeLbl_->setStyleSheet("color:#a6adc8;");
lay->addWidget(trigTimeLbl_);
lay->addStretch(1);
/* ── Wiring ── */
auto cfg = [this]() { if (!updating_) { pullFromUi(); sendConfig(); } };
connect(sigCombo_, QOverload<int>::of(&QComboBox::currentIndexChanged),
this, [cfg](int){ cfg(); });
connect(edgeCombo_, QOverload<int>::of(&QComboBox::currentIndexChanged),
this, [cfg](int){ cfg(); });
connect(thrSpin_, &QDoubleSpinBox::editingFinished, this, cfg);
connect(winCombo_, QOverload<int>::of(&QComboBox::currentIndexChanged),
this, [cfg](int){ cfg(); });
connect(preSlider_, &QSlider::valueChanged, this, [this](int v) {
preLbl_->setText(QString("%1%").arg(v));
});
connect(preSlider_, &QSlider::sliderReleased, this, cfg);
connect(normRadio_, &QRadioButton::toggled, this, [cfg](bool){ cfg(); });
connect(armBtn_, &QPushButton::clicked, this, [this]() {
pullFromUi(); sendConfig(); hub_->sendArm();
});
connect(disarmBtn_, &QPushButton::clicked, this, [this]() {
hub_->sendDisarm();
});
connect(stopBtn_, &QPushButton::clicked, this, [this]() {
auto& t = hub_->trigger();
t.stopped = !t.stopped;
hub_->sendTrigStop(t.stopped);
});
refreshSignals();
onTriggerStateChanged();
}
void TriggerBar::pullFromUi() {
auto& t = hub_->trigger();
t.signalKey = sigCombo_->currentData().toString().toStdString();
t.edge = edgeCombo_->currentIndex();
t.threshold = thrSpin_->value();
t.windowSec = kWinVals[winCombo_->currentIndex()];
t.prePercent = preSlider_->value();
t.single = singleRadio_->isChecked();
}
void TriggerBar::sendConfig() {
auto& t = hub_->trigger();
if (t.signalKey.empty()) { return; }
hub_->sendSetTrigger(t.signalKey, kEdgeWire[t.edge], t.threshold,
t.windowSec, t.prePercent,
t.single ? "single" : "normal");
}
void TriggerBar::refreshSignals() {
updating_ = true;
QString prev = sigCombo_->currentData().toString();
sigCombo_->clear();
for (const auto& src : hub_->sources()) {
for (const auto& sig : src.signals) {
QString key = QString::fromStdString(src.id + ":" + sig.meta.name);
sigCombo_->addItem(key, key);
}
}
int idx = sigCombo_->findData(prev);
if (idx >= 0) { sigCombo_->setCurrentIndex(idx); }
updating_ = false;
}
void TriggerBar::onTriggerStateChanged() {
const auto& t = hub_->trigger();
QString badge; QColor c;
if (t.status == "armed") { badge = "[ARMED]"; c = col::yellow(); }
else if (t.status == "collecting") { badge = "[COLLECTING]"; c = col::blue(); }
else if (t.status == "triggered") { badge = "[TRIGGERED]"; c = col::green(); }
else { badge = "[IDLE]"; c = col::overlay0(); }
badge_->setText(badge);
badge_->setStyleSheet(QString("color:%1; font-weight:bold;").arg(c.name()));
stopBtn_->setVisible(!t.single);
stopBtn_->setText(t.stopped ? "Run" : "Stop");
if (t.hasTrigTime && (t.status == "collecting" || t.status == "triggered")) {
trigTimeLbl_->setText(QString("t=%1").arg(t.trigTime, 0, 'f', 6));
} else {
trigTimeLbl_->clear();
}
}
} /* namespace shq */
Client/streamhub-qt/TriggerBar.h
+57
View File
@@ -0,0 +1,57 @@
/**
* @file TriggerBar.h
* @brief Trigger configuration bar (hub-side trigger semantics).
*
* Edits the trigger config (signal/edge/threshold/window/pre%/mode), sends
* setTrigger + arm/disarm/rearm/trigStop over the WS, and reflects hub
* triggerState broadcasts in a status badge. Mirrors the ImGui TriggerPanel.
*/
#pragma once
#include <QWidget>
class QComboBox;
class QDoubleSpinBox;
class QSlider;
class QLabel;
class QPushButton;
class QRadioButton;
namespace shq {
class Hub;
class TriggerBar : public QWidget {
Q_OBJECT
public:
explicit TriggerBar(Hub* hub, QWidget* parent = nullptr);
public Q_SLOTS:
/** Rebuild the signal combo from the model. */
void refreshSignals();
/** Reflect the latest hub trigger state (badge + buttons). */
void onTriggerStateChanged();
private:
void sendConfig();
void pullFromUi();
Hub* hub_;
QComboBox* sigCombo_ = nullptr;
QComboBox* edgeCombo_ = nullptr;
QDoubleSpinBox* thrSpin_ = nullptr;
QComboBox* winCombo_ = nullptr;
QSlider* preSlider_ = nullptr;
QLabel* preLbl_ = nullptr;
QRadioButton* normRadio_ = nullptr;
QRadioButton* singleRadio_= nullptr;
QLabel* badge_ = nullptr;
QPushButton* armBtn_ = nullptr;
QPushButton* disarmBtn_ = nullptr;
QPushButton* stopBtn_ = nullptr;
QLabel* trigTimeLbl_= nullptr;
bool updating_ = false;
};
} /* namespace shq */
Client/streamhub-qt/WsClient.cpp
+84
View File
@@ -0,0 +1,84 @@
/**
* @file WsClient.cpp
*/
#include "WsClient.h"
#include <QUrl>
namespace shq {
WsClient::WsClient(QObject* parent) : QObject(parent) {
connect(&socket_, &QWebSocket::connected, this, &WsClient::onConnected);
connect(&socket_, &QWebSocket::disconnected, this, &WsClient::onDisconnected);
connect(&socket_, &QWebSocket::textMessageReceived,
this, [this](const QString& s) { Q_EMIT textReceived(s); });
connect(&socket_, &QWebSocket::binaryMessageReceived,
this, [this](const QByteArray& b) { Q_EMIT binaryReceived(b); });
reconnectTimer_.setInterval(3000);
connect(&reconnectTimer_, &QTimer::timeout, this, &WsClient::onTick);
}
void WsClient::connectTo(const QString& host, uint16_t port) {
host_ = host;
port_ = port;
wantOpen_ = true;
openSocket();
reconnectTimer_.start();
}
void WsClient::reconnectTo(const QString& host, uint16_t port) {
host_ = host;
port_ = port;
wantOpen_ = true;
socket_.abort(); /* drop current; onTick / openSocket reopens */
openSocket();
if (!reconnectTimer_.isActive()) { reconnectTimer_.start(); }
}
void WsClient::close() {
wantOpen_ = false;
reconnectTimer_.stop();
socket_.close();
}
void WsClient::openSocket() {
if (!wantOpen_) { return; }
if (socket_.state() == QAbstractSocket::ConnectedState ||
socket_.state() == QAbstractSocket::ConnectingState) {
return;
}
QUrl url;
url.setScheme("ws");
url.setHost(host_);
url.setPort(port_);
url.setPath("/ws");
socket_.open(url);
}
void WsClient::onConnected() {
connected_ = true;
Q_EMIT connectedChanged(true);
}
void WsClient::onDisconnected() {
if (connected_) {
connected_ = false;
Q_EMIT connectedChanged(false);
}
}
void WsClient::onTick() {
if (wantOpen_ && socket_.state() == QAbstractSocket::UnconnectedState) {
openSocket();
}
}
void WsClient::sendText(const QString& json) {
if (socket_.state() == QAbstractSocket::ConnectedState) {
socket_.sendTextMessage(json);
}
}
} /* namespace shq */
Client/streamhub-qt/WsClient.h
+57
View File
@@ -0,0 +1,57 @@
/**
* @file WsClient.h
* @brief Thin QWebSocket wrapper with auto-reconnect.
*/
#pragma once
#include <QObject>
#include <QString>
#include <QByteArray>
#include <QWebSocket>
#include <QTimer>
#include <cstdint>
namespace shq {
class WsClient : public QObject {
Q_OBJECT
public:
explicit WsClient(QObject* parent = nullptr);
/** (Re)connect to host:port; starts the auto-reconnect loop. */
void connectTo(const QString& host, uint16_t port);
/** Switch target and reconnect immediately. */
void reconnectTo(const QString& host, uint16_t port);
void close();
bool isConnected() const { return connected_; }
QString host() const { return host_; }
uint16_t port() const { return port_; }
public Q_SLOTS:
void sendText(const QString& json);
void sendText(const std::string& json) { sendText(QString::fromStdString(json)); }
Q_SIGNALS:
void connectedChanged(bool connected);
void textReceived(const QString& json);
void binaryReceived(const QByteArray& data);
private Q_SLOTS:
void onConnected();
void onDisconnected();
void onTick();
private:
void openSocket();
QWebSocket socket_;
QTimer reconnectTimer_;
QString host_;
uint16_t port_ = 0;
bool connected_ = false;
bool wantOpen_ = false;
};
} /* namespace shq */
Client/streamhub-qt/build/.qt/QtDeploySupport.cmake
+71
View File
@@ -0,0 +1,71 @@
cmake_minimum_required(VERSION 3.16...3.21)
# These are part of the public API. Projects should use them to provide a
# consistent set of prefix-relative destinations.
if(NOT QT_DEPLOY_BIN_DIR)
set(QT_DEPLOY_BIN_DIR "bin")
endif()
if(NOT QT_DEPLOY_LIBEXEC_DIR)
set(QT_DEPLOY_LIBEXEC_DIR "libexec")
endif()
if(NOT QT_DEPLOY_LIB_DIR)
set(QT_DEPLOY_LIB_DIR "lib")
endif()
if(NOT QT_DEPLOY_PLUGINS_DIR)
set(QT_DEPLOY_PLUGINS_DIR "lib/qt6/plugins")
endif()
if(NOT QT_DEPLOY_QML_DIR)
set(QT_DEPLOY_QML_DIR "lib/qt6/qml")
endif()
if(NOT QT_DEPLOY_TRANSLATIONS_DIR)
set(QT_DEPLOY_TRANSLATIONS_DIR "share/qt6/translations")
endif()
if(NOT QT_DEPLOY_PREFIX)
set(QT_DEPLOY_PREFIX "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}")
endif()
if(QT_DEPLOY_PREFIX STREQUAL "")
set(QT_DEPLOY_PREFIX .)
endif()
if(NOT QT_DEPLOY_IGNORED_LIB_DIRS)
set(QT_DEPLOY_IGNORED_LIB_DIRS "/lib")
endif()
# These are internal implementation details. They may be removed at any time.
set(__QT_DEPLOY_SYSTEM_NAME "Linux")
set(__QT_DEPLOY_SHARED_LIBRARY_SUFFIX ".so")
set(__QT_DEPLOY_IS_SHARED_LIBS_BUILD "ON")
set(__QT_DEPLOY_TOOL "GRD")
set(__QT_DEPLOY_IMPL_DIR "/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/.qt")
set(__QT_DEPLOY_VERBOSE "")
set(__QT_CMAKE_EXPORT_NAMESPACE "Qt6")
set(__QT_LIBINFIX "")
set(__QT_DEPLOY_GENERATOR_IS_MULTI_CONFIG "0")
set(__QT_DEPLOY_ACTIVE_CONFIG "")
set(__QT_NO_CREATE_VERSIONLESS_FUNCTIONS "")
set(__QT_DEFAULT_MAJOR_VERSION "6")
set(__QT_DEPLOY_QT_ADDITIONAL_PACKAGES_PREFIX_PATH "")
set(__QT_DEPLOY_QT_INSTALL_PREFIX "/usr")
set(__QT_DEPLOY_QT_INSTALL_BINS "lib/qt6/bin")
set(__QT_DEPLOY_QT_INSTALL_DATA "share/qt6")
set(__QT_DEPLOY_QT_INSTALL_DESCRIPTIONSDIR "lib/qt6/modules")
set(__QT_DEPLOY_QT_INSTALL_LIBEXECS "lib/qt6")
set(__QT_DEPLOY_QT_INSTALL_PLUGINS "lib/qt6/plugins")
set(__QT_DEPLOY_QT_INSTALL_TRANSLATIONS "share/qt6/translations")
set(__QT_DEPLOY_TARGET_QT_PATHS_PATH "/usr/lib/qt6/bin/qtpaths6")
set(__QT_DEPLOY_MUST_ADJUST_PLUGINS_RPATH "ON")
set(__QT_DEPLOY_USE_PATCHELF "")
set(__QT_DEPLOY_PATCHELF_EXECUTABLE "")
set(__QT_DEPLOY_QT_IS_MULTI_CONFIG_BUILD_WITH_DEBUG "FALSE")
set(__QT_DEPLOY_QT_DEBUG_POSTFIX "")
# Define the CMake commands to be made available during deployment.
set(__qt_deploy_support_files
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/.qt/QtDeployTargets.cmake"
"/usr/lib/cmake/Qt6Core/Qt6CoreDeploySupport.cmake"
)
foreach(__qt_deploy_support_file IN LISTS __qt_deploy_support_files)
include("${__qt_deploy_support_file}")
endforeach()
unset(__qt_deploy_support_file)
unset(__qt_deploy_support_files)
Client/streamhub-qt/build/.qt/QtDeployTargets.cmake
+2
View File
@@ -0,0 +1,2 @@
set(__QT_DEPLOY_TARGET_StreamHubQtClient_FILE /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/StreamHubQtClient)
set(__QT_DEPLOY_TARGET_StreamHubQtClient_TYPE EXECUTABLE)
Client/streamhub-qt/build/CMakeCache.txt
+1479
View File
File diff suppressed because it is too large Load Diff
Client/streamhub-qt/build/CMakeFiles/4.4.2/CMakeCXXCompiler.cmake
+103
View File
@@ -0,0 +1,103 @@
set(CMAKE_CXX_COMPILER "/usr/bin/c++")
set(CMAKE_CXX_COMPILER_ARG1 "")
set(CMAKE_CXX_COMPILER_ID "GNU")
set(CMAKE_CXX_COMPILER_VERSION "16.2.1")
set(CMAKE_CXX_COMPILER_VERSION_INTERNAL "")
set(CMAKE_CXX_COMPILER_WRAPPER "")
set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "20")
set(CMAKE_CXX_EXTENSIONS_COMPUTED_DEFAULT "ON")
set(CMAKE_CXX_STANDARD_LATEST "26")
set(CMAKE_CXX_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters;cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates;cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates;cxx_std_17;cxx_std_20;cxx_std_23;cxx_std_26")
set(CMAKE_CXX98_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters")
set(CMAKE_CXX11_COMPILE_FEATURES "cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates")
set(CMAKE_CXX14_COMPILE_FEATURES "cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates")
set(CMAKE_CXX17_COMPILE_FEATURES "cxx_std_17")
set(CMAKE_CXX20_COMPILE_FEATURES "cxx_std_20")
set(CMAKE_CXX23_COMPILE_FEATURES "cxx_std_23")
set(CMAKE_CXX26_COMPILE_FEATURES "cxx_std_26")
set(CMAKE_CXX_PLATFORM_ID "Linux")
set(CMAKE_CXX_SIMULATE_ID "")
set(CMAKE_CXX_COMPILER_FRONTEND_VARIANT "GNU")
set(CMAKE_CXX_COMPILER_APPLE_SYSROOT "")
set(CMAKE_CXX_SIMULATE_VERSION "")
set(CMAKE_CXX_COMPILER_ARCHITECTURE_ID "x86_64")
set(CMAKE_AR "/usr/bin/ar")
set(CMAKE_CXX_COMPILER_AR "/usr/bin/gcc-ar")
set(CMAKE_RANLIB "/usr/bin/ranlib")
set(CMAKE_CXX_COMPILER_RANLIB "/usr/bin/gcc-ranlib")
set(CMAKE_LINKER "/usr/bin/ld")
set(CMAKE_LINKER_LINK "")
set(CMAKE_LINKER_LLD "")
set(CMAKE_CXX_COMPILER_LINKER "/usr/bin/ld")
set(CMAKE_CXX_COMPILER_LINKER_ARCHITECTURE_FLAGS "-m;elf")
set(CMAKE_CXX_COMPILER_LINKER_ID "GNU")
set(CMAKE_CXX_COMPILER_LINKER_VERSION "2.47")
set(CMAKE_CXX_COMPILER_LINKER_FRONTEND_VARIANT "GNU")
set(CMAKE_MT "")
set(CMAKE_TAPI "CMAKE_TAPI-NOTFOUND")
set(CMAKE_COMPILER_IS_GNUCXX 1)
set(CMAKE_CXX_COMPILER_LOADED 1)
set(CMAKE_CXX_COMPILER_WORKS TRUE)
set(CMAKE_CXX_ABI_COMPILED TRUE)
set(CMAKE_CXX_COMPILER_ENV_VAR "CXX")
set(CMAKE_CXX_COMPILER_ID_RUN 1)
set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm;mpp;CPP;ixx;cppm;ccm;cxxm;c++m)
set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC)
foreach (lang IN ITEMS C OBJC OBJCXX)
if (CMAKE_${lang}_COMPILER_ID_RUN)
foreach(extension IN LISTS CMAKE_${lang}_SOURCE_FILE_EXTENSIONS)
list(REMOVE_ITEM CMAKE_CXX_SOURCE_FILE_EXTENSIONS ${extension})
endforeach()
endif()
endforeach()
set(CMAKE_CXX_LINKER_PREFERENCE 30)
set(CMAKE_CXX_LINKER_PREFERENCE_PROPAGATES 1)
set(CMAKE_CXX_LINKER_DEPFILE_SUPPORTED TRUE)
set(CMAKE_LINKER_PUSHPOP_STATE_SUPPORTED TRUE)
set(CMAKE_CXX_LINKER_PUSHPOP_STATE_SUPPORTED TRUE)
# Save compiler ABI information.
set(CMAKE_CXX_SIZEOF_DATA_PTR "8")
set(CMAKE_CXX_COMPILER_ABI "ELF")
set(CMAKE_CXX_BYTE_ORDER "LITTLE_ENDIAN")
set(CMAKE_CXX_LIBRARY_ARCHITECTURE "")
if(CMAKE_CXX_SIZEOF_DATA_PTR)
set(CMAKE_SIZEOF_VOID_P "${CMAKE_CXX_SIZEOF_DATA_PTR}")
endif()
if(CMAKE_CXX_COMPILER_ABI)
set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CXX_COMPILER_ABI}")
endif()
if(CMAKE_CXX_LIBRARY_ARCHITECTURE)
set(CMAKE_LIBRARY_ARCHITECTURE "")
endif()
set(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX "")
if(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX)
set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_CXX_CL_SHOWINCLUDES_PREFIX}")
endif()
set(CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES "/usr/include/c++/16;/usr/include/c++/16/x86_64-pc-linux-gnu;/usr/include/c++/16/backward;/usr/lib/gcc/x86_64-pc-linux-gnu/16/include;/usr/local/include;/usr/include")
set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "stdc++;m;gcc_s;gcc;atomic_asneeded;c;gcc_s;gcc")
set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "/usr/lib/gcc/x86_64-pc-linux-gnu/16;/usr/lib;/lib")
set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "")
set(CMAKE_CXX_COMPILER_CLANG_RESOURCE_DIR "")
set(CMAKE_CXX_COMPILER_IMPORT_STD "")
set(CMAKE_CXX_COMPILER_IMPORT_STD_ERROR_MESSAGE "Unsupported generator: Unix Makefiles")
set(CMAKE_CXX_STDLIB_MODULES_JSON "")
Client/streamhub-qt/build/CMakeFiles/4.4.2/CMakeDetermineCompilerABI_CXX.bin
Executable
BIN
View File
Binary file not shown.
Client/streamhub-qt/build/CMakeFiles/4.4.2/CMakeSystem.cmake
+15
View File
@@ -0,0 +1,15 @@
set(CMAKE_HOST_SYSTEM "Linux-7.1.8-arch1-3")
set(CMAKE_HOST_SYSTEM_NAME "Linux")
set(CMAKE_HOST_SYSTEM_VERSION "7.1.8-arch1-3")
set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64")
set(CMAKE_SYSTEM "Linux-7.1.8-arch1-3")
set(CMAKE_SYSTEM_NAME "Linux")
set(CMAKE_SYSTEM_VERSION "7.1.8-arch1-3")
set(CMAKE_SYSTEM_PROCESSOR "x86_64")
set(CMAKE_CROSSCOMPILING "FALSE")
set(CMAKE_SYSTEM_LOADED 1)
Client/streamhub-qt/build/CMakeFiles/4.4.2/CompilerIdCXX/CMakeCXXCompilerId.cpp
+954
View File
@@ -0,0 +1,954 @@
/* This source file must have a .cpp extension so that all C++ compilers
recognize the extension without flags. Borland does not know .cxx for
example. */
#ifndef __cplusplus
# error "A C compiler has been selected for C++."
#endif
#if !defined(__has_include)
/* If the compiler does not have __has_include, pretend the answer is
always no. */
# define __has_include(x) 0
#endif
/* Version number components: V=Version, R=Revision, P=Patch
Version date components: YYYY=Year, MM=Month, DD=Day */
#if defined(__INTEL_COMPILER) || defined(__ICC)
# define COMPILER_ID "Intel"
# if defined(_MSC_VER)
# define SIMULATE_ID "MSVC"
# endif
# if defined(__GNUC__)
# define SIMULATE_ID "GNU"
# endif
/* __INTEL_COMPILER = VRP prior to 2021, and then VVVV for 2021 and later,
except that a few beta releases use the old format with V=2021. */
# if __INTEL_COMPILER < 2021 || __INTEL_COMPILER == 202110 || __INTEL_COMPILER == 202111
# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100)
# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10)
# if defined(__INTEL_COMPILER_UPDATE)
# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE)
# else
# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER % 10)
# endif
# else
# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER)
# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER_UPDATE)
/* The third version component from --version is an update index,
but no macro is provided for it. */
# define COMPILER_VERSION_PATCH DEC(0)
# endif
# if defined(__INTEL_COMPILER_BUILD_DATE)
/* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */
# define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE)
# endif
# if defined(_MSC_VER)
/* _MSC_VER = VVRR */
# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
# endif
# if defined(__GNUC__)
# define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
# elif defined(__GNUG__)
# define SIMULATE_VERSION_MAJOR DEC(__GNUG__)
# endif
# if defined(__GNUC_MINOR__)
# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
# endif
# if defined(__GNUC_PATCHLEVEL__)
# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
# endif
#elif (defined(__clang__) && defined(__INTEL_CLANG_COMPILER)) || defined(__INTEL_LLVM_COMPILER)
# define COMPILER_ID "IntelLLVM"
#if defined(_MSC_VER)
# define SIMULATE_ID "MSVC"
#endif
#if defined(__GNUC__)
# define SIMULATE_ID "GNU"
#endif
/* __INTEL_LLVM_COMPILER = VVVVRP prior to 2021.2.0, VVVVRRPP for 2021.2.0 and
* later. Look for 6 digit vs. 8 digit version number to decide encoding.
* VVVV is no smaller than the current year when a version is released.
*/
#if __INTEL_LLVM_COMPILER < 1000000L
# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/100)
# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 10)
#else
# define COMPILER_VERSION_MAJOR DEC(__INTEL_LLVM_COMPILER/10000)
# define COMPILER_VERSION_MINOR DEC(__INTEL_LLVM_COMPILER/100 % 100)
# define COMPILER_VERSION_PATCH DEC(__INTEL_LLVM_COMPILER % 100)
#endif
#if defined(_MSC_VER)
/* _MSC_VER = VVRR */
# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
#endif
#if defined(__GNUC__)
# define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
#elif defined(__GNUG__)
# define SIMULATE_VERSION_MAJOR DEC(__GNUG__)
#endif
#if defined(__GNUC_MINOR__)
# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
#endif
#if defined(__GNUC_PATCHLEVEL__)
# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
#endif
#elif defined(__PATHCC__)
# define COMPILER_ID "PathScale"
# define COMPILER_VERSION_MAJOR DEC(__PATHCC__)
# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__)
# if defined(__PATHCC_PATCHLEVEL__)
# define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__)
# endif
#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__)
# define COMPILER_ID "Embarcadero"
# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF)
# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF)
# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF)
#elif defined(__BORLANDC__)
# define COMPILER_ID "Borland"
/* __BORLANDC__ = 0xVRR */
# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8)
# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF)
#elif defined(__WATCOMC__) && __WATCOMC__ < 1200
# define COMPILER_ID "Watcom"
/* __WATCOMC__ = VVRR */
# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100)
# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
# if (__WATCOMC__ % 10) > 0
# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
# endif
#elif defined(__WATCOMC__)
# define COMPILER_ID "OpenWatcom"
/* __WATCOMC__ = VVRP + 1100 */
# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100)
# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10)
# if (__WATCOMC__ % 10) > 0
# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10)
# endif
#elif defined(__SUNPRO_CC)
# define COMPILER_ID "SunPro"
# if __SUNPRO_CC >= 0x5100
/* __SUNPRO_CC = 0xVRRP */
# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>12)
# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xFF)
# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF)
# else
/* __SUNPRO_CC = 0xVRP */
# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>8)
# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xF)
# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF)
# endif
#elif defined(__HP_aCC)
# define COMPILER_ID "HP"
/* __HP_aCC = VVRRPP */
# define COMPILER_VERSION_MAJOR DEC(__HP_aCC/10000)
# define COMPILER_VERSION_MINOR DEC(__HP_aCC/100 % 100)
# define COMPILER_VERSION_PATCH DEC(__HP_aCC % 100)
#elif defined(__DECCXX)
# define COMPILER_ID "Compaq"
/* __DECCXX_VER = VVRRTPPPP */
# define COMPILER_VERSION_MAJOR DEC(__DECCXX_VER/10000000)
# define COMPILER_VERSION_MINOR DEC(__DECCXX_VER/100000 % 100)
# define COMPILER_VERSION_PATCH DEC(__DECCXX_VER % 10000)
#elif defined(__IBMCPP__) && defined(__COMPILER_VER__)
# define COMPILER_ID "zOS"
/* __IBMCPP__ = VRP */
# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10)
#elif defined(__open_xl__) && defined(__clang__)
# define COMPILER_ID "IBMClang"
# define COMPILER_VERSION_MAJOR DEC(__open_xl_version__)
# define COMPILER_VERSION_MINOR DEC(__open_xl_release__)
# define COMPILER_VERSION_PATCH DEC(__open_xl_modification__)
# define COMPILER_VERSION_TWEAK DEC(__open_xl_ptf_fix_level__)
# define COMPILER_VERSION_INTERNAL_STR __clang_version__
#elif defined(__ibmxl__) && defined(__clang__)
# define COMPILER_ID "XLClang"
# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__)
# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__)
# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__)
# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__)
#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ >= 800
# define COMPILER_ID "XL"
/* __IBMCPP__ = VRP */
# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10)
#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ < 800
# define COMPILER_ID "VisualAge"
/* __IBMCPP__ = VRP */
# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100)
# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10)
# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10)
#elif defined(__NVCOMPILER)
# define COMPILER_ID "NVHPC"
# define COMPILER_VERSION_MAJOR DEC(__NVCOMPILER_MAJOR__)
# define COMPILER_VERSION_MINOR DEC(__NVCOMPILER_MINOR__)
# if defined(__NVCOMPILER_PATCHLEVEL__)
# define COMPILER_VERSION_PATCH DEC(__NVCOMPILER_PATCHLEVEL__)
# endif
#elif defined(__PGI)
# define COMPILER_ID "PGI"
# define COMPILER_VERSION_MAJOR DEC(__PGIC__)
# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__)
# if defined(__PGIC_PATCHLEVEL__)
# define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__)
# endif
#elif defined(__clang__) && defined(__cray__)
# define COMPILER_ID "CrayClang"
# define COMPILER_VERSION_MAJOR DEC(__cray_major__)
# define COMPILER_VERSION_MINOR DEC(__cray_minor__)
# define COMPILER_VERSION_PATCH DEC(__cray_patchlevel__)
# define COMPILER_VERSION_INTERNAL_STR __clang_version__
#elif defined(_CRAYC)
# define COMPILER_ID "Cray"
# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR)
# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR)
#elif defined(__TI_COMPILER_VERSION__)
# define COMPILER_ID "TI"
/* __TI_COMPILER_VERSION__ = VVVRRRPPP */
# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000)
# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000)
# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000)
#elif defined(__CLANG_FUJITSU)
# define COMPILER_ID "FujitsuClang"
# define COMPILER_VERSION_MAJOR DEC(__FCC_major__)
# define COMPILER_VERSION_MINOR DEC(__FCC_minor__)
# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__)
# define COMPILER_VERSION_INTERNAL_STR __clang_version__
#elif defined(__FUJITSU)
# define COMPILER_ID "Fujitsu"
# if defined(__FCC_version__)
# define COMPILER_VERSION __FCC_version__
# elif defined(__FCC_major__)
# define COMPILER_VERSION_MAJOR DEC(__FCC_major__)
# define COMPILER_VERSION_MINOR DEC(__FCC_minor__)
# define COMPILER_VERSION_PATCH DEC(__FCC_patchlevel__)
# endif
# if defined(__fcc_version)
# define COMPILER_VERSION_INTERNAL DEC(__fcc_version)
# elif defined(__FCC_VERSION)
# define COMPILER_VERSION_INTERNAL DEC(__FCC_VERSION)
# endif
#elif defined(__ghs__)
# define COMPILER_ID "GHS"
/* __GHS_VERSION_NUMBER = VVVVRP */
# ifdef __GHS_VERSION_NUMBER
# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100)
# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10)
# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER % 10)
# endif
#elif defined(__TASKING__)
# define COMPILER_ID "Tasking"
# define COMPILER_VERSION_MAJOR DEC(__VERSION__/1000)
# define COMPILER_VERSION_MINOR DEC(__VERSION__ % 100)
# define COMPILER_VERSION_INTERNAL DEC(__VERSION__)
#elif defined(__ORANGEC__)
# define COMPILER_ID "OrangeC"
# define COMPILER_VERSION_MAJOR DEC(__ORANGEC_MAJOR__)
# define COMPILER_VERSION_MINOR DEC(__ORANGEC_MINOR__)
# define COMPILER_VERSION_PATCH DEC(__ORANGEC_PATCHLEVEL__)
#elif defined(__RENESAS__)
# define COMPILER_ID "Renesas"
/* __RENESAS_VERSION__ = 0xVVRRPP00 */
# define COMPILER_VERSION_MAJOR HEX(__RENESAS_VERSION__ >> 24 & 0xFF)
# define COMPILER_VERSION_MINOR HEX(__RENESAS_VERSION__ >> 16 & 0xFF)
# define COMPILER_VERSION_PATCH HEX(__RENESAS_VERSION__ >> 8 & 0xFF)
#elif defined(__SCO_VERSION__)
# define COMPILER_ID "SCO"
#elif defined(__ARMCC_VERSION) && !defined(__clang__)
# define COMPILER_ID "ARMCC"
#if __ARMCC_VERSION >= 1000000
/* __ARMCC_VERSION = VRRPPPP */
# define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000)
# define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100)
# define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000)
#else
/* __ARMCC_VERSION = VRPPPP */
# define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000)
# define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10)
# define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000)
#endif
#elif defined(__clang__) && defined(__apple_build_version__)
# define COMPILER_ID "AppleClang"
# if defined(_MSC_VER)
# define SIMULATE_ID "MSVC"
# endif
# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
# if defined(_MSC_VER)
/* _MSC_VER = VVRR */
# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
# endif
# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__)
#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION)
# define COMPILER_ID "ARMClang"
# define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000)
# define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100)
# define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION/100 % 100)
# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION)
#elif defined(__clang__) && defined(__ti__)
# define COMPILER_ID "TIClang"
# define COMPILER_VERSION_MAJOR DEC(__ti_major__)
# define COMPILER_VERSION_MINOR DEC(__ti_minor__)
# define COMPILER_VERSION_PATCH DEC(__ti_patchlevel__)
# define COMPILER_VERSION_INTERNAL DEC(__ti_version__)
#elif defined(__clang__)
# define COMPILER_ID "Clang"
# if defined(_MSC_VER)
# define SIMULATE_ID "MSVC"
# endif
# define COMPILER_VERSION_MAJOR DEC(__clang_major__)
# define COMPILER_VERSION_MINOR DEC(__clang_minor__)
# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__)
# if defined(_MSC_VER)
/* _MSC_VER = VVRR */
# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100)
# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100)
# endif
#elif defined(__LCC__) && (defined(__GNUC__) || defined(__GNUG__) || defined(__MCST__))
# define COMPILER_ID "LCC"
# define COMPILER_VERSION_MAJOR DEC(__LCC__ / 100)
# define COMPILER_VERSION_MINOR DEC(__LCC__ % 100)
# if defined(__LCC_MINOR__)
# define COMPILER_VERSION_PATCH DEC(__LCC_MINOR__)
# endif
# if defined(__GNUC__) && defined(__GNUC_MINOR__)
# define SIMULATE_ID "GNU"
# define SIMULATE_VERSION_MAJOR DEC(__GNUC__)
# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__)
# if defined(__GNUC_PATCHLEVEL__)
# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
# endif
# endif
#elif defined(__GNUC__) || defined(__GNUG__)
# define COMPILER_ID "GNU"
# if defined(__GNUC__)
# define COMPILER_VERSION_MAJOR DEC(__GNUC__)
# else
# define COMPILER_VERSION_MAJOR DEC(__GNUG__)
# endif
# if defined(__GNUC_MINOR__)
# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__)
# endif
# if defined(__GNUC_PATCHLEVEL__)
# define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__)
# endif
#elif defined(_MSC_VER)
# define COMPILER_ID "MSVC"
/* _MSC_VER = VVRR */
# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100)
# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100)
# if defined(_MSC_FULL_VER)
# if _MSC_VER >= 1400
/* _MSC_FULL_VER = VVRRPPPPP */
# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000)
# else
/* _MSC_FULL_VER = VVRRPPPP */
# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000)
# endif
# endif
# if defined(_MSC_BUILD)
# define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD)
# endif
#elif defined(_ADI_COMPILER)
# define COMPILER_ID "ADSP"
#if defined(__VERSIONNUM__)
/* __VERSIONNUM__ = 0xVVRRPPTT */
# define COMPILER_VERSION_MAJOR DEC(__VERSIONNUM__ >> 24 & 0xFF)
# define COMPILER_VERSION_MINOR DEC(__VERSIONNUM__ >> 16 & 0xFF)
# define COMPILER_VERSION_PATCH DEC(__VERSIONNUM__ >> 8 & 0xFF)
# define COMPILER_VERSION_TWEAK DEC(__VERSIONNUM__ & 0xFF)
#endif
#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
# define COMPILER_ID "IAR"
# if defined(__VER__) && defined(__ICCARM__)
# define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000)
# define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000)
# define COMPILER_VERSION_PATCH DEC((__VER__) % 1000)
# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__) || defined(__ICCSTM8__))
# define COMPILER_VERSION_MAJOR DEC((__VER__) / 100)
# define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100))
# define COMPILER_VERSION_PATCH DEC(__SUBVERSION__)
# endif
# if defined(__IAR_COMPILERBASE__)
# define COMPILER_VERSION_INTERNAL DEC(__IAR_COMPILERBASE__)
# else
# define COMPILER_VERSION_INTERNAL DEC((__IAR_SYSTEMS_ICC__ << 16))
# endif
#elif defined(__DCC__) && defined(_DIAB_TOOL)
# define COMPILER_ID "Diab"
# define COMPILER_VERSION_MAJOR DEC(__VERSION_MAJOR_NUMBER__)
# define COMPILER_VERSION_MINOR DEC(__VERSION_MINOR_NUMBER__)
# define COMPILER_VERSION_PATCH DEC(__VERSION_ARCH_FEATURE_NUMBER__)
# define COMPILER_VERSION_TWEAK DEC(__VERSION_BUG_FIX_NUMBER__)
/* These compilers are either not known or too old to define an
identification macro. Try to identify the platform and guess that
it is the native compiler. */
#elif defined(__hpux) || defined(__hpua)
# define COMPILER_ID "HP"
#else /* unknown compiler */
# define COMPILER_ID ""
#endif
/* Construct the string literal in pieces to prevent the source from
getting matched. Store it in a pointer rather than an array
because some compilers will just produce instructions to fill the
array rather than assigning a pointer to a static array. */
char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]";
#ifdef SIMULATE_ID
char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]";
#endif
#ifdef __QNXNTO__
char const* qnxnto = "INFO" ":" "qnxnto[]";
#endif
#if defined(__CRAYXT_COMPUTE_LINUX_TARGET)
char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]";
#endif
#define STRINGIFY_HELPER(X) #X
#define STRINGIFY(X) STRINGIFY_HELPER(X)
/* Identify known platforms by name. */
#if defined(__linux) || defined(__linux__) || defined(linux)
# define PLATFORM_ID "Linux"
#elif defined(__MSYS__)
# define PLATFORM_ID "MSYS"
#elif defined(__CYGWIN__)
# define PLATFORM_ID "Cygwin"
#elif defined(__MINGW32__)
# define PLATFORM_ID "MinGW"
#elif defined(__APPLE__)
# define PLATFORM_ID "Darwin"
#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32)
# define PLATFORM_ID "Windows"
#elif defined(__FreeBSD__) || defined(__FreeBSD)
# define PLATFORM_ID "FreeBSD"
#elif defined(__NetBSD__) || defined(__NetBSD)
# define PLATFORM_ID "NetBSD"
#elif defined(__OpenBSD__) || defined(__OPENBSD)
# define PLATFORM_ID "OpenBSD"
#elif defined(__sun) || defined(sun)
# define PLATFORM_ID "SunOS"
#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__)
# define PLATFORM_ID "AIX"
#elif defined(__hpux) || defined(__hpux__)
# define PLATFORM_ID "HP-UX"
#elif defined(__HAIKU__)
# define PLATFORM_ID "Haiku"
#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS)
# define PLATFORM_ID "BeOS"
#elif defined(__QNX__) || defined(__QNXNTO__)
# define PLATFORM_ID "QNX"
#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__)
# define PLATFORM_ID "Tru64"
#elif defined(__riscos) || defined(__riscos__)
# define PLATFORM_ID "RISCos"
#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__)
# define PLATFORM_ID "SINIX"
#elif defined(__UNIX_SV__)
# define PLATFORM_ID "UNIX_SV"
#elif defined(__bsdos__)
# define PLATFORM_ID "BSDOS"
#elif defined(_MPRAS) || defined(MPRAS)
# define PLATFORM_ID "MP-RAS"
#elif defined(__osf) || defined(__osf__)
# define PLATFORM_ID "OSF1"
#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv)
# define PLATFORM_ID "SCO_SV"
#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX)
# define PLATFORM_ID "ULTRIX"
#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX)
# define PLATFORM_ID "Xenix"
#elif defined(__WATCOMC__)
# if defined(__LINUX__)
# define PLATFORM_ID "Linux"
# elif defined(__DOS__)
# define PLATFORM_ID "DOS"
# elif defined(__OS2__)
# define PLATFORM_ID "OS2"
# elif defined(__WINDOWS__)
# define PLATFORM_ID "Windows3x"
# elif defined(__VXWORKS__)
# define PLATFORM_ID "VxWorks"
# else /* unknown platform */
# define PLATFORM_ID
# endif
#elif defined(__INTEGRITY)
# if defined(INT_178B)
# define PLATFORM_ID "Integrity178"
# else /* regular Integrity */
# define PLATFORM_ID "Integrity"
# endif
# elif defined(_ADI_COMPILER)
# define PLATFORM_ID "ADSP"
#else /* unknown platform */
# define PLATFORM_ID
#endif
/* For windows compilers MSVC and Intel we can determine
the architecture of the compiler being used. This is because
the compilers do not have flags that can change the architecture,
but rather depend on which compiler is being used
*/
#if defined(_WIN32) && defined(_MSC_VER)
# if defined(_M_IA64)
# define ARCHITECTURE_ID "IA64"
# elif defined(_M_ARM64EC)
# define ARCHITECTURE_ID "ARM64EC"
# elif defined(_M_X64) || defined(_M_AMD64)
# define ARCHITECTURE_ID "x64"
# elif defined(_M_IX86)
# define ARCHITECTURE_ID "X86"
# elif defined(_M_ARM64)
# define ARCHITECTURE_ID "ARM64"
# elif defined(_M_ARM)
# if _M_ARM == 4
# define ARCHITECTURE_ID "ARMV4I"
# elif _M_ARM == 5
# define ARCHITECTURE_ID "ARMV5I"
# else
# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM)
# endif
# elif defined(_M_MIPS)
# define ARCHITECTURE_ID "MIPS"
# elif defined(_M_SH)
# define ARCHITECTURE_ID "SHx"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__WATCOMC__)
# if defined(_M_I86)
# define ARCHITECTURE_ID "I86"
# elif defined(_M_IX86)
# define ARCHITECTURE_ID "X86"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC)
# if defined(__ICCARM__)
# define ARCHITECTURE_ID "ARM"
# elif defined(__ICCRX__)
# define ARCHITECTURE_ID "RX"
# elif defined(__ICCRH850__)
# define ARCHITECTURE_ID "RH850"
# elif defined(__ICCRL78__)
# define ARCHITECTURE_ID "RL78"
# elif defined(__ICCRISCV__)
# define ARCHITECTURE_ID "RISCV"
# elif defined(__ICCAVR__)
# define ARCHITECTURE_ID "AVR"
# elif defined(__ICC430__)
# define ARCHITECTURE_ID "MSP430"
# elif defined(__ICCV850__)
# define ARCHITECTURE_ID "V850"
# elif defined(__ICC8051__)
# define ARCHITECTURE_ID "8051"
# elif defined(__ICCSTM8__)
# define ARCHITECTURE_ID "STM8"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__ghs__)
# if defined(__PPC64__)
# define ARCHITECTURE_ID "PPC64"
# elif defined(__ppc__)
# define ARCHITECTURE_ID "PPC"
# elif defined(__ARM__)
# define ARCHITECTURE_ID "ARM"
# elif defined(__x86_64__)
# define ARCHITECTURE_ID "x64"
# elif defined(__i386__)
# define ARCHITECTURE_ID "X86"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__clang__) && defined(__ti__)
# if defined(__ARM_ARCH)
# define ARCHITECTURE_ID "ARM"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
#elif defined(__TI_COMPILER_VERSION__)
# if defined(__TI_ARM__)
# define ARCHITECTURE_ID "ARM"
# elif defined(__MSP430__)
# define ARCHITECTURE_ID "MSP430"
# elif defined(__TMS320C28XX__)
# define ARCHITECTURE_ID "TMS320C28x"
# elif defined(__TMS320C6X__) || defined(_TMS320C6X)
# define ARCHITECTURE_ID "TMS320C6x"
# else /* unknown architecture */
# define ARCHITECTURE_ID ""
# endif
# elif defined(__ADSPSHARC__)
# define ARCHITECTURE_ID "SHARC"
# elif defined(__ADSPBLACKFIN__)
# define ARCHITECTURE_ID "Blackfin"
#elif defined(__TASKING__)
# if defined(__CTC__) || defined(__CPTC__)
# define ARCHITECTURE_ID "TriCore"
# elif defined(__CMCS__)
# define ARCHITECTURE_ID "MCS"
# elif defined(__CARM__) || defined(__CPARM__)
# define ARCHITECTURE_ID "ARM"
# elif defined(__CARC__)
# define ARCHITECTURE_ID "ARC"
# elif defined(__C51__)
# define ARCHITECTURE_ID "8051"
# elif defined(__CPCP__)
# define ARCHITECTURE_ID "PCP"
# else
# define ARCHITECTURE_ID ""
# endif
#elif defined(__RENESAS__)
# if defined(__CCRX__)
# define ARCHITECTURE_ID "RX"
# elif defined(__CCRL__)
# define ARCHITECTURE_ID "RL78"
# elif defined(__CCRH__)
# define ARCHITECTURE_ID "RH850"
# else
# define ARCHITECTURE_ID ""
# endif
#else
# define ARCHITECTURE_ID
#endif
/* Convert integer to decimal digit literals. */
#define DEC(n) \
('0' + (((n) / 10000000)%10)), \
('0' + (((n) / 1000000)%10)), \
('0' + (((n) / 100000)%10)), \
('0' + (((n) / 10000)%10)), \
('0' + (((n) / 1000)%10)), \
('0' + (((n) / 100)%10)), \
('0' + (((n) / 10)%10)), \
('0' + ((n) % 10))
/* Convert integer to hex digit literals. */
#define HEX(n) \
('0' + ((n)>>28 & 0xF)), \
('0' + ((n)>>24 & 0xF)), \
('0' + ((n)>>20 & 0xF)), \
('0' + ((n)>>16 & 0xF)), \
('0' + ((n)>>12 & 0xF)), \
('0' + ((n)>>8 & 0xF)), \
('0' + ((n)>>4 & 0xF)), \
('0' + ((n) & 0xF))
/* Construct a string literal encoding the version number. */
#ifdef COMPILER_VERSION
char const* info_version = "INFO" ":" "compiler_version[" COMPILER_VERSION "]";
/* Construct a string literal encoding the version number components. */
#elif defined(COMPILER_VERSION_MAJOR)
char const info_version[] = {
'I', 'N', 'F', 'O', ':',
'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[',
COMPILER_VERSION_MAJOR,
# ifdef COMPILER_VERSION_MINOR
'.', COMPILER_VERSION_MINOR,
# ifdef COMPILER_VERSION_PATCH
'.', COMPILER_VERSION_PATCH,
# ifdef COMPILER_VERSION_TWEAK
'.', COMPILER_VERSION_TWEAK,
# endif
# endif
# endif
']','\0'};
#endif
/* Construct a string literal encoding the internal version number. */
#ifdef COMPILER_VERSION_INTERNAL
char const info_version_internal[] = {
'I', 'N', 'F', 'O', ':',
'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_',
'i','n','t','e','r','n','a','l','[',
COMPILER_VERSION_INTERNAL,']','\0'};
#elif defined(COMPILER_VERSION_INTERNAL_STR)
char const* info_version_internal = "INFO" ":" "compiler_version_internal[" COMPILER_VERSION_INTERNAL_STR "]";
#endif
/* Construct a string literal encoding the version number components. */
#ifdef SIMULATE_VERSION_MAJOR
char const info_simulate_version[] = {
'I', 'N', 'F', 'O', ':',
's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[',
SIMULATE_VERSION_MAJOR,
# ifdef SIMULATE_VERSION_MINOR
'.', SIMULATE_VERSION_MINOR,
# ifdef SIMULATE_VERSION_PATCH
'.', SIMULATE_VERSION_PATCH,
# ifdef SIMULATE_VERSION_TWEAK
'.', SIMULATE_VERSION_TWEAK,
# endif
# endif
# endif
']','\0'};
#endif
/* Construct the string literal in pieces to prevent the source from
getting matched. Store it in a pointer rather than an array
because some compilers will just produce instructions to fill the
array rather than assigning a pointer to a static array. */
char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]";
char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]";
#define CXX_STD_98 199711L
#define CXX_STD_11 201103L
#define CXX_STD_14 201402L
#define CXX_STD_17 201703L
#define CXX_STD_20 202002L
#define CXX_STD_23 202302L
#if defined(__INTEL_COMPILER) && defined(_MSVC_LANG)
# if _MSVC_LANG > CXX_STD_17
# define CXX_STD _MSVC_LANG
# elif _MSVC_LANG == CXX_STD_17 && defined(__cpp_aggregate_paren_init)
# define CXX_STD CXX_STD_20
# elif _MSVC_LANG > CXX_STD_14 && __cplusplus > CXX_STD_17
# define CXX_STD CXX_STD_20
# elif _MSVC_LANG > CXX_STD_14
# define CXX_STD CXX_STD_17
# elif defined(__INTEL_CXX11_MODE__) && defined(__cpp_aggregate_nsdmi)
# define CXX_STD CXX_STD_14
# elif defined(__INTEL_CXX11_MODE__)
# define CXX_STD CXX_STD_11
# else
# define CXX_STD CXX_STD_98
# endif
#elif defined(_MSC_VER) && defined(_MSVC_LANG)
# if _MSVC_LANG > __cplusplus
# define CXX_STD _MSVC_LANG
# else
# define CXX_STD __cplusplus
# endif
#elif defined(__NVCOMPILER)
# if __cplusplus > CXX_STD_20 && defined(__cpp_pp_embed)
# define CXX_STD /*CXX_STD_26*/ (CXX_STD_23 + 1)
# elif __cplusplus == CXX_STD_17 && defined(__cpp_aggregate_paren_init)
# define CXX_STD CXX_STD_20
# else
# define CXX_STD __cplusplus
# endif
#elif defined(__INTEL_COMPILER) || defined(__PGI)
# if __cplusplus == CXX_STD_11 && defined(__cpp_namespace_attributes)
# define CXX_STD CXX_STD_17
# elif __cplusplus == CXX_STD_11 && defined(__cpp_aggregate_nsdmi)
# define CXX_STD CXX_STD_14
# else
# define CXX_STD __cplusplus
# endif
#elif (defined(__IBMCPP__) || defined(__ibmxl__)) && defined(__linux__)
# if __cplusplus == CXX_STD_11 && defined(__cpp_aggregate_nsdmi)
# define CXX_STD CXX_STD_14
# else
# define CXX_STD __cplusplus
# endif
#elif __cplusplus == 1 && defined(__GXX_EXPERIMENTAL_CXX0X__)
# define CXX_STD CXX_STD_11
#else
# define CXX_STD __cplusplus
#endif
const char* info_language_standard_default = "INFO" ":" "standard_default["
#if CXX_STD > CXX_STD_23
"26"
#elif CXX_STD > CXX_STD_20
"23"
#elif CXX_STD > CXX_STD_17
"20"
#elif CXX_STD > CXX_STD_14
"17"
#elif CXX_STD > CXX_STD_11
"14"
#elif CXX_STD >= CXX_STD_11
"11"
#else
"98"
#endif
"]";
const char* info_language_extensions_default = "INFO" ":" "extensions_default["
#if (defined(__clang__) || defined(__GNUC__) || defined(__xlC__) || \
defined(__TI_COMPILER_VERSION__) || defined(__RENESAS__)) && \
!defined(__STRICT_ANSI__)
"ON"
#else
"OFF"
#endif
"]";
/*--------------------------------------------------------------------------*/
int main(int argc, char* argv[])
{
int require = 0;
require += info_compiler[argc];
require += info_platform[argc];
require += info_arch[argc];
#ifdef COMPILER_VERSION_MAJOR
require += info_version[argc];
#endif
#if defined(COMPILER_VERSION_INTERNAL) || defined(COMPILER_VERSION_INTERNAL_STR)
require += info_version_internal[argc];
#endif
#ifdef SIMULATE_ID
require += info_simulate[argc];
#endif
#ifdef SIMULATE_VERSION_MAJOR
require += info_simulate_version[argc];
#endif
#if defined(__CRAYXT_COMPUTE_LINUX_TARGET)
require += info_cray[argc];
#endif
require += info_language_standard_default[argc];
require += info_language_extensions_default[argc];
(void)argv;
return require;
}
Client/streamhub-qt/build/CMakeFiles/4.4.2/CompilerIdCXX/a.out
Executable
BIN
View File
Binary file not shown.
Client/streamhub-qt/build/CMakeFiles/CMakeConfigureLog.yaml
+13167
View File
File diff suppressed because it is too large Load Diff
Client/streamhub-qt/build/CMakeFiles/CMakeDirectoryInformation.cmake
+16
View File
@@ -0,0 +1,16 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 4.4
# Relative path conversion top directories.
set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt")
set(CMAKE_RELATIVE_PATH_TOP_BINARY "/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build")
# Force unix paths in dependencies.
set(CMAKE_FORCE_UNIX_PATHS 1)
# The C and CXX include file regular expressions for this directory.
set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$")
set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$")
set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN})
set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN})
Client/streamhub-qt/build/CMakeFiles/CMakeRuleHashes.txt
+3
View File
@@ -0,0 +1,3 @@
# Hashes of file build rules.
0cb4e5ccccdee237bca094c8b1abeca7 CMakeFiles/StreamHubQtClient_autogen
e7f54a49cd115db46d4899f7b6078912 StreamHubQtClient_autogen/timestamp
Client/streamhub-qt/build/CMakeFiles/InstallScripts.json
+7
View File
@@ -0,0 +1,7 @@
{
"InstallScripts" :
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/cmake_install.cmake"
],
"Parallel" : false
}
Client/streamhub-qt/build/CMakeFiles/Makefile.cmake
+568
View File
@@ -0,0 +1,568 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 4.4
# The generator used is:
set(CMAKE_DEPENDS_GENERATOR "Unix Makefiles")
# The top level Makefile was generated from the following files:
set(CMAKE_MAKEFILE_DEPENDS
"CMakeCache.txt"
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/CMakeLists.txt"
"CMakeFiles/4.4.2/CMakeCXXCompiler.cmake"
"CMakeFiles/4.4.2/CMakeSystem.cmake"
"/usr/lib/cmake/Qt6/FindWrapAtomic.cmake"
"/usr/lib/cmake/Qt6/FindWrapOpenGL.cmake"
"/usr/lib/cmake/Qt6/FindWrapVulkanHeaders.cmake"
"/usr/lib/cmake/Qt6/Qt6Config.cmake"
"/usr/lib/cmake/Qt6/Qt6ConfigExtras.cmake"
"/usr/lib/cmake/Qt6/Qt6ConfigVersion.cmake"
"/usr/lib/cmake/Qt6/Qt6ConfigVersionImpl.cmake"
"/usr/lib/cmake/Qt6/Qt6Dependencies.cmake"
"/usr/lib/cmake/Qt6/Qt6Targets.cmake"
"/usr/lib/cmake/Qt6/Qt6TargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6/Qt6VersionlessAliasTargets.cmake"
"/usr/lib/cmake/Qt6/QtFeature.cmake"
"/usr/lib/cmake/Qt6/QtFeatureCommon.cmake"
"/usr/lib/cmake/Qt6/QtInstallPaths.cmake"
"/usr/lib/cmake/Qt6/QtPublicAndroidHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicAppleHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicCMakeEarlyPolicyHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicCMakeHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicCMakeVersionHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicDependencyHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicExternalProjectHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicFinalizerHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicFindPackageHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicGitHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicPluginHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicPluginHelpers_v2.cmake"
"/usr/lib/cmake/Qt6/QtPublicSbomAttributionHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicSbomBuildToolHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicSbomCommonGenerationHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicSbomCpeHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicSbomCycloneDXHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicSbomDepHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicSbomDocumentNamespaceHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicSbomExternalReferenceHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicSbomFileHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicSbomGenerationCycloneDXHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicSbomGenerationHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicSbomHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicSbomLicenseHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicSbomOpsHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicSbomPurlHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicSbomPythonHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicSbomQtEntityHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicSbomRelationshipHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicSbomSystemDepHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicTargetHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicTestHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicToolHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicWalkLibsHelpers.cmake"
"/usr/lib/cmake/Qt6/QtPublicWindowsHelpers.cmake"
"/usr/lib/cmake/Qt6Core/Qt6CoreAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Core/Qt6CoreConfig.cmake"
"/usr/lib/cmake/Qt6Core/Qt6CoreConfigExtras.cmake"
"/usr/lib/cmake/Qt6Core/Qt6CoreConfigVersion.cmake"
"/usr/lib/cmake/Qt6Core/Qt6CoreConfigVersionImpl.cmake"
"/usr/lib/cmake/Qt6Core/Qt6CoreDependencies.cmake"
"/usr/lib/cmake/Qt6Core/Qt6CoreMacros.cmake"
"/usr/lib/cmake/Qt6Core/Qt6CoreTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Core/Qt6CoreTargets.cmake"
"/usr/lib/cmake/Qt6Core/Qt6CoreTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Core/Qt6CoreVersionlessAliasTargets.cmake"
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfig.cmake"
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfigVersion.cmake"
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfigVersionImpl.cmake"
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsDependencies.cmake"
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsTargets.cmake"
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsVersionlessTargets.cmake"
"/usr/lib/cmake/Qt6DBus/Qt6DBusAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6DBus/Qt6DBusConfig.cmake"
"/usr/lib/cmake/Qt6DBus/Qt6DBusConfigVersion.cmake"
"/usr/lib/cmake/Qt6DBus/Qt6DBusConfigVersionImpl.cmake"
"/usr/lib/cmake/Qt6DBus/Qt6DBusDependencies.cmake"
"/usr/lib/cmake/Qt6DBus/Qt6DBusMacros.cmake"
"/usr/lib/cmake/Qt6DBus/Qt6DBusTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6DBus/Qt6DBusTargets.cmake"
"/usr/lib/cmake/Qt6DBus/Qt6DBusTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6DBus/Qt6DBusVersionlessAliasTargets.cmake"
"/usr/lib/cmake/Qt6DBusTools/Qt6DBusToolsAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6DBusTools/Qt6DBusToolsConfig.cmake"
"/usr/lib/cmake/Qt6DBusTools/Qt6DBusToolsConfigVersion.cmake"
"/usr/lib/cmake/Qt6DBusTools/Qt6DBusToolsConfigVersionImpl.cmake"
"/usr/lib/cmake/Qt6DBusTools/Qt6DBusToolsDependencies.cmake"
"/usr/lib/cmake/Qt6DBusTools/Qt6DBusToolsTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6DBusTools/Qt6DBusToolsTargets.cmake"
"/usr/lib/cmake/Qt6DBusTools/Qt6DBusToolsTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6DBusTools/Qt6DBusToolsVersionlessTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6DmaBufServerBufferPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6DmaBufServerBufferPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6DmaBufServerBufferPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6DmaBufServerBufferPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6DmaBufServerBufferPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6DrmEglServerBufferPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6DrmEglServerBufferPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6DrmEglServerBufferPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6DrmEglServerBufferPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6DrmEglServerBufferPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6GuiAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6GuiConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6GuiConfigVersion.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6GuiConfigVersionImpl.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6GuiDependencies.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6GuiPlugins.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6GuiTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6GuiTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6GuiTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6GuiVersionlessAliasTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QComposePlatformInputContextPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QComposePlatformInputContextPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QComposePlatformInputContextPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QComposePlatformInputContextPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QComposePlatformInputContextPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSEmulatorIntegrationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSEmulatorIntegrationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSEmulatorIntegrationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSEmulatorIntegrationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSEmulatorIntegrationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSIntegrationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSIntegrationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSIntegrationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSIntegrationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSIntegrationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSKmsEglDeviceIntegrationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSKmsEglDeviceIntegrationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSKmsEglDeviceIntegrationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSKmsEglDeviceIntegrationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSKmsEglDeviceIntegrationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSKmsGbmIntegrationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSKmsGbmIntegrationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSKmsGbmIntegrationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSKmsGbmIntegrationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSKmsGbmIntegrationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSX11IntegrationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSX11IntegrationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSX11IntegrationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSX11IntegrationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSX11IntegrationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevKeyboardPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevKeyboardPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevKeyboardPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevKeyboardPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevKeyboardPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevMousePluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevMousePluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevMousePluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevMousePluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevMousePluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevTabletPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevTabletPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevTabletPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevTabletPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevTabletPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevTouchScreenPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevTouchScreenPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevTouchScreenPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevTouchScreenPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevTouchScreenPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QGifPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QGifPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QGifPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QGifPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QGifPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QGtk3ThemePluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QGtk3ThemePluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QGtk3ThemePluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QGtk3ThemePluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QGtk3ThemePluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QICNSPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QICNSPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QICNSPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QICNSPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QICNSPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QICOPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QICOPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QICOPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QICOPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QICOPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QIbusPlatformInputContextPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QIbusPlatformInputContextPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QIbusPlatformInputContextPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QIbusPlatformInputContextPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QIbusPlatformInputContextPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QJp2PluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QJp2PluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QJp2PluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QJp2PluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QJp2PluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QJpegPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QJpegPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QJpegPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QJpegPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QJpegPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QLibInputPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QLibInputPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QLibInputPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QLibInputPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QLibInputPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QLinuxFbIntegrationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QLinuxFbIntegrationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QLinuxFbIntegrationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QLinuxFbIntegrationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QLinuxFbIntegrationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QMinimalEglIntegrationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QMinimalEglIntegrationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QMinimalEglIntegrationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QMinimalEglIntegrationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QMinimalEglIntegrationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QMngPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QMngPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QMngPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QMngPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QMngPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QPdfPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QPdfPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QPdfPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QPdfPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QPdfPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QSvgIconPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QSvgIconPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QSvgIconPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QSvgIconPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QSvgIconPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QSvgPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QSvgPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QSvgPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QSvgPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QSvgPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QTgaPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QTgaPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QTgaPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QTgaPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QTgaPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QTiffPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QTiffPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QTiffPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QTiffPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QTiffPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QTsLibPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QTsLibPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QTsLibPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QTsLibPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QTsLibPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QVkKhrDisplayIntegrationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QVkKhrDisplayIntegrationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QVkKhrDisplayIntegrationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QVkKhrDisplayIntegrationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QVkKhrDisplayIntegrationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QVncIntegrationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QVncIntegrationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QVncIntegrationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QVncIntegrationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QVncIntegrationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandAdwaitaDecorationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandAdwaitaDecorationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandAdwaitaDecorationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandAdwaitaDecorationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandAdwaitaDecorationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandBradientDecorationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandBradientDecorationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandBradientDecorationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandBradientDecorationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandBradientDecorationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandEglClientBufferPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandEglClientBufferPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandEglClientBufferPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandEglClientBufferPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandEglClientBufferPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandFullScreenShellV1IntegrationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandFullScreenShellV1IntegrationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandFullScreenShellV1IntegrationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandFullScreenShellV1IntegrationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandFullScreenShellV1IntegrationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandIntegrationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandIntegrationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandIntegrationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandIntegrationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandIntegrationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandIviShellIntegrationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandIviShellIntegrationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandIviShellIntegrationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandIviShellIntegrationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandIviShellIntegrationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandQtShellIntegrationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandQtShellIntegrationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandQtShellIntegrationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandQtShellIntegrationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandQtShellIntegrationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandWlShellIntegrationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandWlShellIntegrationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandWlShellIntegrationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandWlShellIntegrationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandWlShellIntegrationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandXdgShellIntegrationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandXdgShellIntegrationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandXdgShellIntegrationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandXdgShellIntegrationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandXdgShellIntegrationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWbmpPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWbmpPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWbmpPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWbmpPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWbmpPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWebpPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWebpPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWebpPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWebpPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QWebpPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QXcbEglIntegrationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QXcbEglIntegrationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QXcbEglIntegrationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QXcbEglIntegrationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QXcbEglIntegrationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QXcbGlxIntegrationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QXcbGlxIntegrationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QXcbGlxIntegrationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QXcbGlxIntegrationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QXcbGlxIntegrationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QXcbIntegrationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QXcbIntegrationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QXcbIntegrationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QXcbIntegrationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QXcbIntegrationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QXdgDesktopPortalThemePluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QXdgDesktopPortalThemePluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QXdgDesktopPortalThemePluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QXdgDesktopPortalThemePluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6QXdgDesktopPortalThemePluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6ShmServerBufferPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6ShmServerBufferPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6ShmServerBufferPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6ShmServerBufferPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6ShmServerBufferPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6VulkanServerBufferPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6VulkanServerBufferPluginConfig.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6VulkanServerBufferPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6VulkanServerBufferPluginTargets.cmake"
"/usr/lib/cmake/Qt6Gui/Qt6VulkanServerBufferPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6GuiTools/Qt6GuiToolsAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6GuiTools/Qt6GuiToolsConfig.cmake"
"/usr/lib/cmake/Qt6GuiTools/Qt6GuiToolsConfigVersion.cmake"
"/usr/lib/cmake/Qt6GuiTools/Qt6GuiToolsConfigVersionImpl.cmake"
"/usr/lib/cmake/Qt6GuiTools/Qt6GuiToolsDependencies.cmake"
"/usr/lib/cmake/Qt6GuiTools/Qt6GuiToolsTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6GuiTools/Qt6GuiToolsTargets.cmake"
"/usr/lib/cmake/Qt6GuiTools/Qt6GuiToolsTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6GuiTools/Qt6GuiToolsVersionlessTargets.cmake"
"/usr/lib/cmake/Qt6Network/Qt6NetworkAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Network/Qt6NetworkConfig.cmake"
"/usr/lib/cmake/Qt6Network/Qt6NetworkConfigVersion.cmake"
"/usr/lib/cmake/Qt6Network/Qt6NetworkConfigVersionImpl.cmake"
"/usr/lib/cmake/Qt6Network/Qt6NetworkDependencies.cmake"
"/usr/lib/cmake/Qt6Network/Qt6NetworkPlugins.cmake"
"/usr/lib/cmake/Qt6Network/Qt6NetworkTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Network/Qt6NetworkTargets.cmake"
"/usr/lib/cmake/Qt6Network/Qt6NetworkTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Network/Qt6NetworkVersionlessAliasTargets.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QConnManNetworkInformationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QConnManNetworkInformationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QConnManNetworkInformationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QConnManNetworkInformationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QConnManNetworkInformationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QGlibNetworkInformationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QGlibNetworkInformationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QGlibNetworkInformationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QGlibNetworkInformationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QGlibNetworkInformationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QNetworkManagerNetworkInformationPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QNetworkManagerNetworkInformationPluginConfig.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QNetworkManagerNetworkInformationPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QNetworkManagerNetworkInformationPluginTargets.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QNetworkManagerNetworkInformationPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginConfig.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginTargets.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginConfig.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginTargets.cmake"
"/usr/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6WebSockets/Qt6WebSocketsAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6WebSockets/Qt6WebSocketsConfig.cmake"
"/usr/lib/cmake/Qt6WebSockets/Qt6WebSocketsConfigVersion.cmake"
"/usr/lib/cmake/Qt6WebSockets/Qt6WebSocketsConfigVersionImpl.cmake"
"/usr/lib/cmake/Qt6WebSockets/Qt6WebSocketsDependencies.cmake"
"/usr/lib/cmake/Qt6WebSockets/Qt6WebSocketsTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6WebSockets/Qt6WebSocketsTargets.cmake"
"/usr/lib/cmake/Qt6WebSockets/Qt6WebSocketsTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6WebSockets/Qt6WebSocketsVersionlessAliasTargets.cmake"
"/usr/lib/cmake/Qt6Widgets/Qt6WidgetsAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6Widgets/Qt6WidgetsConfig.cmake"
"/usr/lib/cmake/Qt6Widgets/Qt6WidgetsConfigVersion.cmake"
"/usr/lib/cmake/Qt6Widgets/Qt6WidgetsConfigVersionImpl.cmake"
"/usr/lib/cmake/Qt6Widgets/Qt6WidgetsDependencies.cmake"
"/usr/lib/cmake/Qt6Widgets/Qt6WidgetsMacros.cmake"
"/usr/lib/cmake/Qt6Widgets/Qt6WidgetsPlugins.cmake"
"/usr/lib/cmake/Qt6Widgets/Qt6WidgetsTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6Widgets/Qt6WidgetsTargets.cmake"
"/usr/lib/cmake/Qt6Widgets/Qt6WidgetsTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6Widgets/Qt6WidgetsVersionlessAliasTargets.cmake"
"/usr/lib/cmake/Qt6WidgetsTools/Qt6WidgetsToolsAdditionalTargetInfo.cmake"
"/usr/lib/cmake/Qt6WidgetsTools/Qt6WidgetsToolsConfig.cmake"
"/usr/lib/cmake/Qt6WidgetsTools/Qt6WidgetsToolsConfigVersion.cmake"
"/usr/lib/cmake/Qt6WidgetsTools/Qt6WidgetsToolsConfigVersionImpl.cmake"
"/usr/lib/cmake/Qt6WidgetsTools/Qt6WidgetsToolsDependencies.cmake"
"/usr/lib/cmake/Qt6WidgetsTools/Qt6WidgetsToolsTargets-relwithdebinfo.cmake"
"/usr/lib/cmake/Qt6WidgetsTools/Qt6WidgetsToolsTargets.cmake"
"/usr/lib/cmake/Qt6WidgetsTools/Qt6WidgetsToolsTargetsPrecheck.cmake"
"/usr/lib/cmake/Qt6WidgetsTools/Qt6WidgetsToolsVersionlessTargets.cmake"
"/usr/share/cmake/Modules/CMakeCXXCompiler.cmake.in"
"/usr/share/cmake/Modules/CMakeCXXCompilerABI.cpp"
"/usr/share/cmake/Modules/CMakeCXXInformation.cmake"
"/usr/share/cmake/Modules/CMakeCheckCompilerFlagCommonPatterns.cmake"
"/usr/share/cmake/Modules/CMakeCommonLanguageInclude.cmake"
"/usr/share/cmake/Modules/CMakeCompilerIdDetection.cmake"
"/usr/share/cmake/Modules/CMakeDetermineCXXCompiler.cmake"
"/usr/share/cmake/Modules/CMakeDetermineCompiler.cmake"
"/usr/share/cmake/Modules/CMakeDetermineCompilerABI.cmake"
"/usr/share/cmake/Modules/CMakeDetermineCompilerId.cmake"
"/usr/share/cmake/Modules/CMakeDetermineCompilerSupport.cmake"
"/usr/share/cmake/Modules/CMakeDetermineSystem.cmake"
"/usr/share/cmake/Modules/CMakeFindBinUtils.cmake"
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake"
"/usr/share/cmake/Modules/CMakeGenericSystem.cmake"
"/usr/share/cmake/Modules/CMakeInitializeConfigs.cmake"
"/usr/share/cmake/Modules/CMakeLanguageInformation.cmake"
"/usr/share/cmake/Modules/CMakeParseImplicitIncludeInfo.cmake"
"/usr/share/cmake/Modules/CMakeParseImplicitLinkInfo.cmake"
"/usr/share/cmake/Modules/CMakeParseLibraryArchitecture.cmake"
"/usr/share/cmake/Modules/CMakeSystem.cmake.in"
"/usr/share/cmake/Modules/CMakeSystemSpecificInformation.cmake"
"/usr/share/cmake/Modules/CMakeSystemSpecificInitialize.cmake"
"/usr/share/cmake/Modules/CMakeTestCXXCompiler.cmake"
"/usr/share/cmake/Modules/CMakeTestCompilerCommon.cmake"
"/usr/share/cmake/Modules/CMakeUnixFindMake.cmake"
"/usr/share/cmake/Modules/CheckCXXCompilerFlag.cmake"
"/usr/share/cmake/Modules/CheckCXXSourceCompiles.cmake"
"/usr/share/cmake/Modules/CheckIncludeFileCXX.cmake"
"/usr/share/cmake/Modules/CheckLibraryExists.cmake"
"/usr/share/cmake/Modules/Compiler/ADSP-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/ARMCC-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/ARMClang-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/AppleClang-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/Borland-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/CMakeCommonCompilerMacros.cmake"
"/usr/share/cmake/Modules/Compiler/Clang-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/Clang-DetermineCompilerInternal.cmake"
"/usr/share/cmake/Modules/Compiler/Compaq-CXX-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/Cray-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/CrayClang-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/Diab-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/Embarcadero-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/Fujitsu-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/FujitsuClang-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/GHS-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/GNU-CXX-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/GNU-CXX.cmake"
"/usr/share/cmake/Modules/Compiler/GNU-FindBinUtils.cmake"
"/usr/share/cmake/Modules/Compiler/GNU.cmake"
"/usr/share/cmake/Modules/Compiler/HP-CXX-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/IAR-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake"
"/usr/share/cmake/Modules/Compiler/IBMClang-CXX-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/Intel-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/IntelLLVM-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/LCC-CXX-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/MSVC-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/NVHPC-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/NVIDIA-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/OpenWatcom-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/OrangeC-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/PGI-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/PathScale-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/PellesC-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/Renesas-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/SCO-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/SunPro-CXX-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/TI-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/TIClang-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/Tasking-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/VisualAge-CXX-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/Watcom-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/XL-CXX-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/XLClang-CXX-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/Compiler/zOS-CXX-DetermineCompiler.cmake"
"/usr/share/cmake/Modules/FindOpenGL.cmake"
"/usr/share/cmake/Modules/FindPackageHandleStandardArgs.cmake"
"/usr/share/cmake/Modules/FindPackageMessage.cmake"
"/usr/share/cmake/Modules/FindThreads.cmake"
"/usr/share/cmake/Modules/FindVulkan.cmake"
"/usr/share/cmake/Modules/GNUInstallDirs.cmake"
"/usr/share/cmake/Modules/Internal/CMakeCXXLinkerInformation.cmake"
"/usr/share/cmake/Modules/Internal/CMakeCommonLinkerInformation.cmake"
"/usr/share/cmake/Modules/Internal/CMakeDetermineLinkerId.cmake"
"/usr/share/cmake/Modules/Internal/CMakeInspectCXXLinker.cmake"
"/usr/share/cmake/Modules/Internal/CheckCommon.cmake"
"/usr/share/cmake/Modules/Internal/CheckCompilerFlag.cmake"
"/usr/share/cmake/Modules/Internal/CheckFlagCommonConfig.cmake"
"/usr/share/cmake/Modules/Internal/CheckSourceCompiles.cmake"
"/usr/share/cmake/Modules/Internal/FeatureTesting.cmake"
"/usr/share/cmake/Modules/Linker/GNU-CXX.cmake"
"/usr/share/cmake/Modules/Linker/GNU.cmake"
"/usr/share/cmake/Modules/MacroAddFileDependencies.cmake"
"/usr/share/cmake/Modules/Platform/Linker/GNU.cmake"
"/usr/share/cmake/Modules/Platform/Linker/Linux-GNU-CXX.cmake"
"/usr/share/cmake/Modules/Platform/Linker/Linux-GNU.cmake"
"/usr/share/cmake/Modules/Platform/Linux-Determine-CXX.cmake"
"/usr/share/cmake/Modules/Platform/Linux-GNU-CXX.cmake"
"/usr/share/cmake/Modules/Platform/Linux-GNU.cmake"
"/usr/share/cmake/Modules/Platform/Linux-Initialize.cmake"
"/usr/share/cmake/Modules/Platform/Linux.cmake"
"/usr/share/cmake/Modules/Platform/UnixPaths.cmake"
)
# The corresponding makefile is:
set(CMAKE_MAKEFILE_OUTPUTS
"Makefile"
"CMakeFiles/cmake.check_cache"
)
# Byproducts of CMake generate step:
set(CMAKE_MAKEFILE_PRODUCTS
"CMakeFiles/4.4.2/CMakeSystem.cmake"
"CMakeFiles/4.4.2/CMakeCXXCompiler.cmake"
"CMakeFiles/4.4.2/CMakeCXXCompiler.cmake"
"CMakeFiles/4.4.2/CMakeCXXCompiler.cmake"
"CMakeFiles/StreamHubQtClient_autogen.dir/AutogenInfo.json"
".qt/QtDeploySupport.cmake"
".qt/QtDeployTargets.cmake"
"CMakeFiles/CMakeDirectoryInformation.cmake"
)
# Dependency information for all targets:
set(CMAKE_DEPEND_INFO_FILES
"CMakeFiles/StreamHubQtClient.dir/DependInfo.cmake"
"CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/DependInfo.cmake"
"CMakeFiles/StreamHubQtClient_autogen.dir/DependInfo.cmake"
)
Client/streamhub-qt/build/CMakeFiles/Makefile2
+189
View File
@@ -0,0 +1,189 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 4.4
# Default target executed when no arguments are given to make.
default_target: all
.PHONY : default_target
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Disable VCS-based implicit rules.
% : %,v
# Disable VCS-based implicit rules.
% : RCS/%
# Disable VCS-based implicit rules.
% : RCS/%,v
# Disable VCS-based implicit rules.
% : SCCS/s.%
# Disable VCS-based implicit rules.
% : s.%
.SUFFIXES: .hpux_make_needs_suffix_list
# Command-line flag to silence nested $(MAKE).
$(VERBOSE)MAKESILENT = -s
#Suppress display of executed commands.
$(VERBOSE).SILENT:
# A target that is always out of date.
cmake_force:
.PHONY : cmake_force
#=============================================================================
# Set environment variables for the build.
# The shell in which to execute make rules.
SHELL = /bin/sh
# The CMake executable.
CMAKE_COMMAND = /usr/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E rm -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build
#=============================================================================
# Directory level rules for the build root directory
# The main recursive "all" target.
all: CMakeFiles/StreamHubQtClient.dir/all
.PHONY : all
# The main recursive "codegen" target.
codegen: CMakeFiles/StreamHubQtClient.dir/codegen
.PHONY : codegen
# The main recursive "preinstall" target.
preinstall:
.PHONY : preinstall
# The main recursive "clean" target.
clean: CMakeFiles/StreamHubQtClient.dir/clean
clean: CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/clean
clean: CMakeFiles/StreamHubQtClient_autogen.dir/clean
.PHONY : clean
#=============================================================================
# Target rules for target CMakeFiles/StreamHubQtClient.dir
# All Build rule for target.
CMakeFiles/StreamHubQtClient.dir/all: CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/all
CMakeFiles/StreamHubQtClient.dir/all: CMakeFiles/StreamHubQtClient_autogen.dir/all
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/depend
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/build
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles --progress-num=1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 "Built target StreamHubQtClient"
.PHONY : CMakeFiles/StreamHubQtClient.dir/all
# Build rule for subdir invocation for target.
CMakeFiles/StreamHubQtClient.dir/rule: cmake_check_build_system
$(CMAKE_COMMAND) -E cmake_progress_start /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles 16
$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 CMakeFiles/StreamHubQtClient.dir/all
$(CMAKE_COMMAND) -E cmake_progress_start /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles 0
.PHONY : CMakeFiles/StreamHubQtClient.dir/rule
# Convenience name for target.
StreamHubQtClient: CMakeFiles/StreamHubQtClient.dir/rule
.PHONY : StreamHubQtClient
# codegen rule for target.
CMakeFiles/StreamHubQtClient.dir/codegen: CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/all
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/codegen
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles --progress-num=1,2,3,4,5,6,7,8,9,10,11,12,13,14,15 "Finished codegen for target StreamHubQtClient"
.PHONY : CMakeFiles/StreamHubQtClient.dir/codegen
# clean rule for target.
CMakeFiles/StreamHubQtClient.dir/clean:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/clean
.PHONY : CMakeFiles/StreamHubQtClient.dir/clean
#=============================================================================
# Target rules for target CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir
# All Build rule for target.
CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/all:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/build.make CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/depend
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/build.make CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/build
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles --progress-num= "Built target StreamHubQtClient_autogen_timestamp_deps"
.PHONY : CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/all
# Build rule for subdir invocation for target.
CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/rule: cmake_check_build_system
$(CMAKE_COMMAND) -E cmake_progress_start /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles 0
$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/all
$(CMAKE_COMMAND) -E cmake_progress_start /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles 0
.PHONY : CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/rule
# Convenience name for target.
StreamHubQtClient_autogen_timestamp_deps: CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/rule
.PHONY : StreamHubQtClient_autogen_timestamp_deps
# codegen rule for target.
CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/codegen:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/build.make CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/codegen
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles --progress-num= "Finished codegen for target StreamHubQtClient_autogen_timestamp_deps"
.PHONY : CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/codegen
# clean rule for target.
CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/clean:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/build.make CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/clean
.PHONY : CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/clean
#=============================================================================
# Target rules for target CMakeFiles/StreamHubQtClient_autogen.dir
# All Build rule for target.
CMakeFiles/StreamHubQtClient_autogen.dir/all: CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/all
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient_autogen.dir/build.make CMakeFiles/StreamHubQtClient_autogen.dir/depend
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient_autogen.dir/build.make CMakeFiles/StreamHubQtClient_autogen.dir/build
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles --progress-num=16 "Built target StreamHubQtClient_autogen"
.PHONY : CMakeFiles/StreamHubQtClient_autogen.dir/all
# Build rule for subdir invocation for target.
CMakeFiles/StreamHubQtClient_autogen.dir/rule: cmake_check_build_system
$(CMAKE_COMMAND) -E cmake_progress_start /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles 1
$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 CMakeFiles/StreamHubQtClient_autogen.dir/all
$(CMAKE_COMMAND) -E cmake_progress_start /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles 0
.PHONY : CMakeFiles/StreamHubQtClient_autogen.dir/rule
# Convenience name for target.
StreamHubQtClient_autogen: CMakeFiles/StreamHubQtClient_autogen.dir/rule
.PHONY : StreamHubQtClient_autogen
# codegen rule for target.
CMakeFiles/StreamHubQtClient_autogen.dir/codegen: CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/all
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient_autogen.dir/build.make CMakeFiles/StreamHubQtClient_autogen.dir/codegen
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles --progress-num=16 "Finished codegen for target StreamHubQtClient_autogen"
.PHONY : CMakeFiles/StreamHubQtClient_autogen.dir/codegen
# clean rule for target.
CMakeFiles/StreamHubQtClient_autogen.dir/clean:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient_autogen.dir/build.make CMakeFiles/StreamHubQtClient_autogen.dir/clean
.PHONY : CMakeFiles/StreamHubQtClient_autogen.dir/clean
#=============================================================================
# Special targets to cleanup operation of make.
# Special rule to run CMake to check the build system integrity.
# No rule that depends on this can have commands that come from listfiles
# because they might be regenerated.
cmake_check_build_system:
$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
.PHONY : cmake_check_build_system
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient.dir/DependInfo.cmake
+37
View File
@@ -0,0 +1,37 @@
# Consider dependencies only in project.
set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF)
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of dependency files which are needed:
set(CMAKE_DEPENDS_DEPENDENCY_FILES
"" "StreamHubQtClient_autogen/timestamp" "custom" "StreamHubQtClient_autogen/deps"
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/HistoryBar.cpp" "CMakeFiles/StreamHubQtClient.dir/HistoryBar.cpp.o" "gcc" "CMakeFiles/StreamHubQtClient.dir/HistoryBar.cpp.o.d"
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/Hub.cpp" "CMakeFiles/StreamHubQtClient.dir/Hub.cpp.o" "gcc" "CMakeFiles/StreamHubQtClient.dir/Hub.cpp.o.d"
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/MainWindow.cpp" "CMakeFiles/StreamHubQtClient.dir/MainWindow.cpp.o" "gcc" "CMakeFiles/StreamHubQtClient.dir/MainWindow.cpp.o.d"
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/PlotGrid.cpp" "CMakeFiles/StreamHubQtClient.dir/PlotGrid.cpp.o" "gcc" "CMakeFiles/StreamHubQtClient.dir/PlotGrid.cpp.o.d"
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/PlotWidget.cpp" "CMakeFiles/StreamHubQtClient.dir/PlotWidget.cpp.o" "gcc" "CMakeFiles/StreamHubQtClient.dir/PlotWidget.cpp.o.d"
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/SourceSidebar.cpp" "CMakeFiles/StreamHubQtClient.dir/SourceSidebar.cpp.o" "gcc" "CMakeFiles/StreamHubQtClient.dir/SourceSidebar.cpp.o.d"
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/StatsDialog.cpp" "CMakeFiles/StreamHubQtClient.dir/StatsDialog.cpp.o" "gcc" "CMakeFiles/StreamHubQtClient.dir/StatsDialog.cpp.o.d"
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/StreamHubQtClient_autogen/mocs_compilation.cpp" "CMakeFiles/StreamHubQtClient.dir/StreamHubQtClient_autogen/mocs_compilation.cpp.o" "gcc" "CMakeFiles/StreamHubQtClient.dir/StreamHubQtClient_autogen/mocs_compilation.cpp.o.d"
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/Theme.cpp" "CMakeFiles/StreamHubQtClient.dir/Theme.cpp.o" "gcc" "CMakeFiles/StreamHubQtClient.dir/Theme.cpp.o.d"
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/TriggerBar.cpp" "CMakeFiles/StreamHubQtClient.dir/TriggerBar.cpp.o" "gcc" "CMakeFiles/StreamHubQtClient.dir/TriggerBar.cpp.o.d"
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/WsClient.cpp" "CMakeFiles/StreamHubQtClient.dir/WsClient.cpp.o" "gcc" "CMakeFiles/StreamHubQtClient.dir/WsClient.cpp.o.d"
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp" "CMakeFiles/StreamHubQtClient.dir/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.o" "gcc" "CMakeFiles/StreamHubQtClient.dir/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.o.d"
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/main.cpp" "CMakeFiles/StreamHubQtClient.dir/main.cpp.o" "gcc" "CMakeFiles/StreamHubQtClient.dir/main.cpp.o.d"
"" "StreamHubQtClient" "gcc" "CMakeFiles/StreamHubQtClient.dir/link.d"
)
# Targets to which this target links which contain Fortran sources.
set(CMAKE_Fortran_TARGET_LINKED_INFO_FILES
)
# Targets to which this target links which contain Fortran sources.
set(CMAKE_Fortran_TARGET_FORWARD_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient.dir/build.make
+319
View File
@@ -0,0 +1,319 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 4.4
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Disable VCS-based implicit rules.
% : %,v
# Disable VCS-based implicit rules.
% : RCS/%
# Disable VCS-based implicit rules.
% : RCS/%,v
# Disable VCS-based implicit rules.
% : SCCS/s.%
# Disable VCS-based implicit rules.
% : s.%
.SUFFIXES: .hpux_make_needs_suffix_list
# Command-line flag to silence nested $(MAKE).
$(VERBOSE)MAKESILENT = -s
#Suppress display of executed commands.
$(VERBOSE).SILENT:
# A target that is always out of date.
cmake_force:
.PHONY : cmake_force
#=============================================================================
# Set environment variables for the build.
# The shell in which to execute make rules.
SHELL = /bin/sh
# The CMake executable.
CMAKE_COMMAND = /usr/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E rm -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build
# Include any dependencies generated for this target.
include CMakeFiles/StreamHubQtClient.dir/depend.make
# Include any dependencies generated by the compiler for this target.
include CMakeFiles/StreamHubQtClient.dir/compiler_depend.make
# Include the progress variables for this target.
include CMakeFiles/StreamHubQtClient.dir/progress.make
# Include the compile flags for this target's objects.
include CMakeFiles/StreamHubQtClient.dir/flags.make
StreamHubQtClient_autogen/timestamp: /usr/lib/qt6/moc
StreamHubQtClient_autogen/timestamp: CMakeFiles/StreamHubQtClient.dir/compiler_depend.ts
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Automatic MOC for target StreamHubQtClient"
/usr/bin/cmake -E cmake_autogen /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient_autogen.dir/AutogenInfo.json ""
/usr/bin/cmake -E touch /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/StreamHubQtClient_autogen/timestamp
CMakeFiles/StreamHubQtClient.dir/codegen:
.PHONY : CMakeFiles/StreamHubQtClient.dir/codegen
CMakeFiles/StreamHubQtClient.dir/StreamHubQtClient_autogen/mocs_compilation.cpp.o: CMakeFiles/StreamHubQtClient.dir/flags.make
CMakeFiles/StreamHubQtClient.dir/StreamHubQtClient_autogen/mocs_compilation.cpp.o: StreamHubQtClient_autogen/mocs_compilation.cpp
CMakeFiles/StreamHubQtClient.dir/StreamHubQtClient_autogen/mocs_compilation.cpp.o: CMakeFiles/StreamHubQtClient.dir/compiler_depend.ts
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building CXX object CMakeFiles/StreamHubQtClient.dir/StreamHubQtClient_autogen/mocs_compilation.cpp.o"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/StreamHubQtClient.dir/StreamHubQtClient_autogen/mocs_compilation.cpp.o -MF CMakeFiles/StreamHubQtClient.dir/StreamHubQtClient_autogen/mocs_compilation.cpp.o.d -o CMakeFiles/StreamHubQtClient.dir/StreamHubQtClient_autogen/mocs_compilation.cpp.o -c /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/StreamHubQtClient_autogen/mocs_compilation.cpp
CMakeFiles/StreamHubQtClient.dir/StreamHubQtClient_autogen/mocs_compilation.cpp.i: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/StreamHubQtClient.dir/StreamHubQtClient_autogen/mocs_compilation.cpp.i"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/StreamHubQtClient_autogen/mocs_compilation.cpp > CMakeFiles/StreamHubQtClient.dir/StreamHubQtClient_autogen/mocs_compilation.cpp.i
CMakeFiles/StreamHubQtClient.dir/StreamHubQtClient_autogen/mocs_compilation.cpp.s: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/StreamHubQtClient.dir/StreamHubQtClient_autogen/mocs_compilation.cpp.s"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/StreamHubQtClient_autogen/mocs_compilation.cpp -o CMakeFiles/StreamHubQtClient.dir/StreamHubQtClient_autogen/mocs_compilation.cpp.s
CMakeFiles/StreamHubQtClient.dir/main.cpp.o: CMakeFiles/StreamHubQtClient.dir/flags.make
CMakeFiles/StreamHubQtClient.dir/main.cpp.o: /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/main.cpp
CMakeFiles/StreamHubQtClient.dir/main.cpp.o: CMakeFiles/StreamHubQtClient.dir/compiler_depend.ts
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Building CXX object CMakeFiles/StreamHubQtClient.dir/main.cpp.o"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/StreamHubQtClient.dir/main.cpp.o -MF CMakeFiles/StreamHubQtClient.dir/main.cpp.o.d -o CMakeFiles/StreamHubQtClient.dir/main.cpp.o -c /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/main.cpp
CMakeFiles/StreamHubQtClient.dir/main.cpp.i: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/StreamHubQtClient.dir/main.cpp.i"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/main.cpp > CMakeFiles/StreamHubQtClient.dir/main.cpp.i
CMakeFiles/StreamHubQtClient.dir/main.cpp.s: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/StreamHubQtClient.dir/main.cpp.s"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/main.cpp -o CMakeFiles/StreamHubQtClient.dir/main.cpp.s
CMakeFiles/StreamHubQtClient.dir/Theme.cpp.o: CMakeFiles/StreamHubQtClient.dir/flags.make
CMakeFiles/StreamHubQtClient.dir/Theme.cpp.o: /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/Theme.cpp
CMakeFiles/StreamHubQtClient.dir/Theme.cpp.o: CMakeFiles/StreamHubQtClient.dir/compiler_depend.ts
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_4) "Building CXX object CMakeFiles/StreamHubQtClient.dir/Theme.cpp.o"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/StreamHubQtClient.dir/Theme.cpp.o -MF CMakeFiles/StreamHubQtClient.dir/Theme.cpp.o.d -o CMakeFiles/StreamHubQtClient.dir/Theme.cpp.o -c /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/Theme.cpp
CMakeFiles/StreamHubQtClient.dir/Theme.cpp.i: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/StreamHubQtClient.dir/Theme.cpp.i"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/Theme.cpp > CMakeFiles/StreamHubQtClient.dir/Theme.cpp.i
CMakeFiles/StreamHubQtClient.dir/Theme.cpp.s: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/StreamHubQtClient.dir/Theme.cpp.s"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/Theme.cpp -o CMakeFiles/StreamHubQtClient.dir/Theme.cpp.s
CMakeFiles/StreamHubQtClient.dir/Hub.cpp.o: CMakeFiles/StreamHubQtClient.dir/flags.make
CMakeFiles/StreamHubQtClient.dir/Hub.cpp.o: /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/Hub.cpp
CMakeFiles/StreamHubQtClient.dir/Hub.cpp.o: CMakeFiles/StreamHubQtClient.dir/compiler_depend.ts
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_5) "Building CXX object CMakeFiles/StreamHubQtClient.dir/Hub.cpp.o"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/StreamHubQtClient.dir/Hub.cpp.o -MF CMakeFiles/StreamHubQtClient.dir/Hub.cpp.o.d -o CMakeFiles/StreamHubQtClient.dir/Hub.cpp.o -c /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/Hub.cpp
CMakeFiles/StreamHubQtClient.dir/Hub.cpp.i: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/StreamHubQtClient.dir/Hub.cpp.i"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/Hub.cpp > CMakeFiles/StreamHubQtClient.dir/Hub.cpp.i
CMakeFiles/StreamHubQtClient.dir/Hub.cpp.s: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/StreamHubQtClient.dir/Hub.cpp.s"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/Hub.cpp -o CMakeFiles/StreamHubQtClient.dir/Hub.cpp.s
CMakeFiles/StreamHubQtClient.dir/WsClient.cpp.o: CMakeFiles/StreamHubQtClient.dir/flags.make
CMakeFiles/StreamHubQtClient.dir/WsClient.cpp.o: /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/WsClient.cpp
CMakeFiles/StreamHubQtClient.dir/WsClient.cpp.o: CMakeFiles/StreamHubQtClient.dir/compiler_depend.ts
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_6) "Building CXX object CMakeFiles/StreamHubQtClient.dir/WsClient.cpp.o"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/StreamHubQtClient.dir/WsClient.cpp.o -MF CMakeFiles/StreamHubQtClient.dir/WsClient.cpp.o.d -o CMakeFiles/StreamHubQtClient.dir/WsClient.cpp.o -c /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/WsClient.cpp
CMakeFiles/StreamHubQtClient.dir/WsClient.cpp.i: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/StreamHubQtClient.dir/WsClient.cpp.i"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/WsClient.cpp > CMakeFiles/StreamHubQtClient.dir/WsClient.cpp.i
CMakeFiles/StreamHubQtClient.dir/WsClient.cpp.s: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/StreamHubQtClient.dir/WsClient.cpp.s"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/WsClient.cpp -o CMakeFiles/StreamHubQtClient.dir/WsClient.cpp.s
CMakeFiles/StreamHubQtClient.dir/PlotWidget.cpp.o: CMakeFiles/StreamHubQtClient.dir/flags.make
CMakeFiles/StreamHubQtClient.dir/PlotWidget.cpp.o: /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/PlotWidget.cpp
CMakeFiles/StreamHubQtClient.dir/PlotWidget.cpp.o: CMakeFiles/StreamHubQtClient.dir/compiler_depend.ts
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_7) "Building CXX object CMakeFiles/StreamHubQtClient.dir/PlotWidget.cpp.o"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/StreamHubQtClient.dir/PlotWidget.cpp.o -MF CMakeFiles/StreamHubQtClient.dir/PlotWidget.cpp.o.d -o CMakeFiles/StreamHubQtClient.dir/PlotWidget.cpp.o -c /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/PlotWidget.cpp
CMakeFiles/StreamHubQtClient.dir/PlotWidget.cpp.i: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/StreamHubQtClient.dir/PlotWidget.cpp.i"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/PlotWidget.cpp > CMakeFiles/StreamHubQtClient.dir/PlotWidget.cpp.i
CMakeFiles/StreamHubQtClient.dir/PlotWidget.cpp.s: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/StreamHubQtClient.dir/PlotWidget.cpp.s"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/PlotWidget.cpp -o CMakeFiles/StreamHubQtClient.dir/PlotWidget.cpp.s
CMakeFiles/StreamHubQtClient.dir/PlotGrid.cpp.o: CMakeFiles/StreamHubQtClient.dir/flags.make
CMakeFiles/StreamHubQtClient.dir/PlotGrid.cpp.o: /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/PlotGrid.cpp
CMakeFiles/StreamHubQtClient.dir/PlotGrid.cpp.o: CMakeFiles/StreamHubQtClient.dir/compiler_depend.ts
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_8) "Building CXX object CMakeFiles/StreamHubQtClient.dir/PlotGrid.cpp.o"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/StreamHubQtClient.dir/PlotGrid.cpp.o -MF CMakeFiles/StreamHubQtClient.dir/PlotGrid.cpp.o.d -o CMakeFiles/StreamHubQtClient.dir/PlotGrid.cpp.o -c /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/PlotGrid.cpp
CMakeFiles/StreamHubQtClient.dir/PlotGrid.cpp.i: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/StreamHubQtClient.dir/PlotGrid.cpp.i"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/PlotGrid.cpp > CMakeFiles/StreamHubQtClient.dir/PlotGrid.cpp.i
CMakeFiles/StreamHubQtClient.dir/PlotGrid.cpp.s: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/StreamHubQtClient.dir/PlotGrid.cpp.s"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/PlotGrid.cpp -o CMakeFiles/StreamHubQtClient.dir/PlotGrid.cpp.s
CMakeFiles/StreamHubQtClient.dir/SourceSidebar.cpp.o: CMakeFiles/StreamHubQtClient.dir/flags.make
CMakeFiles/StreamHubQtClient.dir/SourceSidebar.cpp.o: /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/SourceSidebar.cpp
CMakeFiles/StreamHubQtClient.dir/SourceSidebar.cpp.o: CMakeFiles/StreamHubQtClient.dir/compiler_depend.ts
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_9) "Building CXX object CMakeFiles/StreamHubQtClient.dir/SourceSidebar.cpp.o"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/StreamHubQtClient.dir/SourceSidebar.cpp.o -MF CMakeFiles/StreamHubQtClient.dir/SourceSidebar.cpp.o.d -o CMakeFiles/StreamHubQtClient.dir/SourceSidebar.cpp.o -c /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/SourceSidebar.cpp
CMakeFiles/StreamHubQtClient.dir/SourceSidebar.cpp.i: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/StreamHubQtClient.dir/SourceSidebar.cpp.i"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/SourceSidebar.cpp > CMakeFiles/StreamHubQtClient.dir/SourceSidebar.cpp.i
CMakeFiles/StreamHubQtClient.dir/SourceSidebar.cpp.s: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/StreamHubQtClient.dir/SourceSidebar.cpp.s"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/SourceSidebar.cpp -o CMakeFiles/StreamHubQtClient.dir/SourceSidebar.cpp.s
CMakeFiles/StreamHubQtClient.dir/TriggerBar.cpp.o: CMakeFiles/StreamHubQtClient.dir/flags.make
CMakeFiles/StreamHubQtClient.dir/TriggerBar.cpp.o: /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/TriggerBar.cpp
CMakeFiles/StreamHubQtClient.dir/TriggerBar.cpp.o: CMakeFiles/StreamHubQtClient.dir/compiler_depend.ts
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_10) "Building CXX object CMakeFiles/StreamHubQtClient.dir/TriggerBar.cpp.o"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/StreamHubQtClient.dir/TriggerBar.cpp.o -MF CMakeFiles/StreamHubQtClient.dir/TriggerBar.cpp.o.d -o CMakeFiles/StreamHubQtClient.dir/TriggerBar.cpp.o -c /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/TriggerBar.cpp
CMakeFiles/StreamHubQtClient.dir/TriggerBar.cpp.i: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/StreamHubQtClient.dir/TriggerBar.cpp.i"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/TriggerBar.cpp > CMakeFiles/StreamHubQtClient.dir/TriggerBar.cpp.i
CMakeFiles/StreamHubQtClient.dir/TriggerBar.cpp.s: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/StreamHubQtClient.dir/TriggerBar.cpp.s"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/TriggerBar.cpp -o CMakeFiles/StreamHubQtClient.dir/TriggerBar.cpp.s
CMakeFiles/StreamHubQtClient.dir/StatsDialog.cpp.o: CMakeFiles/StreamHubQtClient.dir/flags.make
CMakeFiles/StreamHubQtClient.dir/StatsDialog.cpp.o: /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/StatsDialog.cpp
CMakeFiles/StreamHubQtClient.dir/StatsDialog.cpp.o: CMakeFiles/StreamHubQtClient.dir/compiler_depend.ts
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_11) "Building CXX object CMakeFiles/StreamHubQtClient.dir/StatsDialog.cpp.o"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/StreamHubQtClient.dir/StatsDialog.cpp.o -MF CMakeFiles/StreamHubQtClient.dir/StatsDialog.cpp.o.d -o CMakeFiles/StreamHubQtClient.dir/StatsDialog.cpp.o -c /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/StatsDialog.cpp
CMakeFiles/StreamHubQtClient.dir/StatsDialog.cpp.i: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/StreamHubQtClient.dir/StatsDialog.cpp.i"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/StatsDialog.cpp > CMakeFiles/StreamHubQtClient.dir/StatsDialog.cpp.i
CMakeFiles/StreamHubQtClient.dir/StatsDialog.cpp.s: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/StreamHubQtClient.dir/StatsDialog.cpp.s"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/StatsDialog.cpp -o CMakeFiles/StreamHubQtClient.dir/StatsDialog.cpp.s
CMakeFiles/StreamHubQtClient.dir/HistoryBar.cpp.o: CMakeFiles/StreamHubQtClient.dir/flags.make
CMakeFiles/StreamHubQtClient.dir/HistoryBar.cpp.o: /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/HistoryBar.cpp
CMakeFiles/StreamHubQtClient.dir/HistoryBar.cpp.o: CMakeFiles/StreamHubQtClient.dir/compiler_depend.ts
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_12) "Building CXX object CMakeFiles/StreamHubQtClient.dir/HistoryBar.cpp.o"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/StreamHubQtClient.dir/HistoryBar.cpp.o -MF CMakeFiles/StreamHubQtClient.dir/HistoryBar.cpp.o.d -o CMakeFiles/StreamHubQtClient.dir/HistoryBar.cpp.o -c /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/HistoryBar.cpp
CMakeFiles/StreamHubQtClient.dir/HistoryBar.cpp.i: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/StreamHubQtClient.dir/HistoryBar.cpp.i"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/HistoryBar.cpp > CMakeFiles/StreamHubQtClient.dir/HistoryBar.cpp.i
CMakeFiles/StreamHubQtClient.dir/HistoryBar.cpp.s: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/StreamHubQtClient.dir/HistoryBar.cpp.s"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/HistoryBar.cpp -o CMakeFiles/StreamHubQtClient.dir/HistoryBar.cpp.s
CMakeFiles/StreamHubQtClient.dir/MainWindow.cpp.o: CMakeFiles/StreamHubQtClient.dir/flags.make
CMakeFiles/StreamHubQtClient.dir/MainWindow.cpp.o: /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/MainWindow.cpp
CMakeFiles/StreamHubQtClient.dir/MainWindow.cpp.o: CMakeFiles/StreamHubQtClient.dir/compiler_depend.ts
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_13) "Building CXX object CMakeFiles/StreamHubQtClient.dir/MainWindow.cpp.o"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/StreamHubQtClient.dir/MainWindow.cpp.o -MF CMakeFiles/StreamHubQtClient.dir/MainWindow.cpp.o.d -o CMakeFiles/StreamHubQtClient.dir/MainWindow.cpp.o -c /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/MainWindow.cpp
CMakeFiles/StreamHubQtClient.dir/MainWindow.cpp.i: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/StreamHubQtClient.dir/MainWindow.cpp.i"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/MainWindow.cpp > CMakeFiles/StreamHubQtClient.dir/MainWindow.cpp.i
CMakeFiles/StreamHubQtClient.dir/MainWindow.cpp.s: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/StreamHubQtClient.dir/MainWindow.cpp.s"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/MainWindow.cpp -o CMakeFiles/StreamHubQtClient.dir/MainWindow.cpp.s
CMakeFiles/StreamHubQtClient.dir/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.o: CMakeFiles/StreamHubQtClient.dir/flags.make
CMakeFiles/StreamHubQtClient.dir/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.o: /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp
CMakeFiles/StreamHubQtClient.dir/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.o: CMakeFiles/StreamHubQtClient.dir/compiler_depend.ts
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --progress-dir=/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_14) "Building CXX object CMakeFiles/StreamHubQtClient.dir/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.o"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -MD -MT CMakeFiles/StreamHubQtClient.dir/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.o -MF CMakeFiles/StreamHubQtClient.dir/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.o.d -o CMakeFiles/StreamHubQtClient.dir/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.o -c /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp
CMakeFiles/StreamHubQtClient.dir/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.i: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Preprocessing CXX source to CMakeFiles/StreamHubQtClient.dir/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.i"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp > CMakeFiles/StreamHubQtClient.dir/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.i
CMakeFiles/StreamHubQtClient.dir/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.s: cmake_force
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling CXX source to assembly CMakeFiles/StreamHubQtClient.dir/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.s"
/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp -o CMakeFiles/StreamHubQtClient.dir/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.s
# Object files for target StreamHubQtClient
StreamHubQtClient_OBJECTS = \
"CMakeFiles/StreamHubQtClient.dir/StreamHubQtClient_autogen/mocs_compilation.cpp.o" \
"CMakeFiles/StreamHubQtClient.dir/main.cpp.o" \
"CMakeFiles/StreamHubQtClient.dir/Theme.cpp.o" \
"CMakeFiles/StreamHubQtClient.dir/Hub.cpp.o" \
"CMakeFiles/StreamHubQtClient.dir/WsClient.cpp.o" \
"CMakeFiles/StreamHubQtClient.dir/PlotWidget.cpp.o" \
"CMakeFiles/StreamHubQtClient.dir/PlotGrid.cpp.o" \
"CMakeFiles/StreamHubQtClient.dir/SourceSidebar.cpp.o" \
"CMakeFiles/StreamHubQtClient.dir/TriggerBar.cpp.o" \
"CMakeFiles/StreamHubQtClient.dir/StatsDialog.cpp.o" \
"CMakeFiles/StreamHubQtClient.dir/HistoryBar.cpp.o" \
"CMakeFiles/StreamHubQtClient.dir/MainWindow.cpp.o" \
"CMakeFiles/StreamHubQtClient.dir/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.o"
# External object files for target StreamHubQtClient
StreamHubQtClient_EXTERNAL_OBJECTS =
StreamHubQtClient: CMakeFiles/StreamHubQtClient.dir/StreamHubQtClient_autogen/mocs_compilation.cpp.o
StreamHubQtClient: CMakeFiles/StreamHubQtClient.dir/main.cpp.o
StreamHubQtClient: CMakeFiles/StreamHubQtClient.dir/Theme.cpp.o
StreamHubQtClient: CMakeFiles/StreamHubQtClient.dir/Hub.cpp.o
StreamHubQtClient: CMakeFiles/StreamHubQtClient.dir/WsClient.cpp.o
StreamHubQtClient: CMakeFiles/StreamHubQtClient.dir/PlotWidget.cpp.o
StreamHubQtClient: CMakeFiles/StreamHubQtClient.dir/PlotGrid.cpp.o
StreamHubQtClient: CMakeFiles/StreamHubQtClient.dir/SourceSidebar.cpp.o
StreamHubQtClient: CMakeFiles/StreamHubQtClient.dir/TriggerBar.cpp.o
StreamHubQtClient: CMakeFiles/StreamHubQtClient.dir/StatsDialog.cpp.o
StreamHubQtClient: CMakeFiles/StreamHubQtClient.dir/HistoryBar.cpp.o
StreamHubQtClient: CMakeFiles/StreamHubQtClient.dir/MainWindow.cpp.o
StreamHubQtClient: CMakeFiles/StreamHubQtClient.dir/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.o
StreamHubQtClient: CMakeFiles/StreamHubQtClient.dir/build.make
StreamHubQtClient: CMakeFiles/StreamHubQtClient.dir/compiler_depend.ts
StreamHubQtClient: /usr/lib/libQt6Widgets.so.6.11.1
StreamHubQtClient: /usr/lib/libQt6WebSockets.so.6.11.1
StreamHubQtClient: /usr/lib/libQt6Gui.so.6.11.1
StreamHubQtClient: /usr/lib/libGLX.so
StreamHubQtClient: /usr/lib/libOpenGL.so
StreamHubQtClient: /usr/lib/libQt6Network.so.6.11.1
StreamHubQtClient: /usr/lib/libQt6Core.so.6.11.1
StreamHubQtClient: CMakeFiles/StreamHubQtClient.dir/link.txt
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --bold --progress-dir=/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_15) "Linking CXX executable StreamHubQtClient"
$(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/StreamHubQtClient.dir/link.txt --verbose=$(VERBOSE)
# Rule to build all files generated by this target.
CMakeFiles/StreamHubQtClient.dir/build: StreamHubQtClient
.PHONY : CMakeFiles/StreamHubQtClient.dir/build
CMakeFiles/StreamHubQtClient.dir/clean:
$(CMAKE_COMMAND) -P CMakeFiles/StreamHubQtClient.dir/cmake_clean.cmake
.PHONY : CMakeFiles/StreamHubQtClient.dir/clean
CMakeFiles/StreamHubQtClient.dir/depend: StreamHubQtClient_autogen/timestamp
cd /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient.dir/DependInfo.cmake "--color=$(COLOR)" StreamHubQtClient
.PHONY : CMakeFiles/StreamHubQtClient.dir/depend
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient.dir/cmake_clean.cmake
+41
View File
@@ -0,0 +1,41 @@
file(REMOVE_RECURSE
"CMakeFiles/StreamHubQtClient.dir/link.d"
"CMakeFiles/StreamHubQtClient_autogen.dir/AutogenUsed.txt"
"CMakeFiles/StreamHubQtClient_autogen.dir/ParseCache.txt"
"StreamHubQtClient_autogen"
"CMakeFiles/StreamHubQtClient.dir/HistoryBar.cpp.o"
"CMakeFiles/StreamHubQtClient.dir/HistoryBar.cpp.o.d"
"CMakeFiles/StreamHubQtClient.dir/Hub.cpp.o"
"CMakeFiles/StreamHubQtClient.dir/Hub.cpp.o.d"
"CMakeFiles/StreamHubQtClient.dir/MainWindow.cpp.o"
"CMakeFiles/StreamHubQtClient.dir/MainWindow.cpp.o.d"
"CMakeFiles/StreamHubQtClient.dir/PlotGrid.cpp.o"
"CMakeFiles/StreamHubQtClient.dir/PlotGrid.cpp.o.d"
"CMakeFiles/StreamHubQtClient.dir/PlotWidget.cpp.o"
"CMakeFiles/StreamHubQtClient.dir/PlotWidget.cpp.o.d"
"CMakeFiles/StreamHubQtClient.dir/SourceSidebar.cpp.o"
"CMakeFiles/StreamHubQtClient.dir/SourceSidebar.cpp.o.d"
"CMakeFiles/StreamHubQtClient.dir/StatsDialog.cpp.o"
"CMakeFiles/StreamHubQtClient.dir/StatsDialog.cpp.o.d"
"CMakeFiles/StreamHubQtClient.dir/StreamHubQtClient_autogen/mocs_compilation.cpp.o"
"CMakeFiles/StreamHubQtClient.dir/StreamHubQtClient_autogen/mocs_compilation.cpp.o.d"
"CMakeFiles/StreamHubQtClient.dir/Theme.cpp.o"
"CMakeFiles/StreamHubQtClient.dir/Theme.cpp.o.d"
"CMakeFiles/StreamHubQtClient.dir/TriggerBar.cpp.o"
"CMakeFiles/StreamHubQtClient.dir/TriggerBar.cpp.o.d"
"CMakeFiles/StreamHubQtClient.dir/WsClient.cpp.o"
"CMakeFiles/StreamHubQtClient.dir/WsClient.cpp.o.d"
"CMakeFiles/StreamHubQtClient.dir/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.o"
"CMakeFiles/StreamHubQtClient.dir/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.o.d"
"CMakeFiles/StreamHubQtClient.dir/main.cpp.o"
"CMakeFiles/StreamHubQtClient.dir/main.cpp.o.d"
"StreamHubQtClient"
"StreamHubQtClient.pdb"
"StreamHubQtClient_autogen/mocs_compilation.cpp"
"StreamHubQtClient_autogen/timestamp"
)
# Per-language clean rules from dependency scanning.
foreach(lang CXX)
include(CMakeFiles/StreamHubQtClient.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient.dir/compiler_depend.internal
+1061
View File
File diff suppressed because it is too large Load Diff
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient.dir/compiler_depend.make
+3172
View File
File diff suppressed because it is too large Load Diff
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient.dir/compiler_depend.ts
+2
View File
@@ -0,0 +1,2 @@
# CMAKE generated file: DO NOT EDIT!
# Timestamp file for compiler generated dependencies management for StreamHubQtClient.
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient.dir/depend.make
+2
View File
@@ -0,0 +1,2 @@
# Empty dependencies file for StreamHubQtClient.
# This may be replaced when dependencies are built.
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient.dir/flags.make
+10
View File
@@ -0,0 +1,10 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 4.4
# compile CXX with /usr/bin/c++
CXX_DEFINES = -DQT_CORE_LIB -DQT_GUI_LIB -DQT_NETWORK_LIB -DQT_NO_DEBUG -DQT_NO_KEYWORDS -DQT_WEBSOCKETS_LIB -DQT_WIDGETS_LIB
CXX_INCLUDES = -I/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/StreamHubQtClient_autogen/include -I/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt -I/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/../streamhub -isystem /usr/include/qt6/QtWidgets -isystem /usr/include/qt6 -isystem /usr/include/qt6/QtCore -isystem /usr/lib/qt6/mkspecs/linux-g++ -isystem /usr/include/qt6/QtGui -isystem /usr/include/qt6/QtWebSockets -isystem /usr/include/qt6/QtNetwork
CXX_FLAGS = -std=gnu++17 -Wall -Wextra -Wno-unused-parameter -mno-direct-extern-access
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient.dir/link.txt
+1
View File
@@ -0,0 +1 @@
/usr/bin/c++ -Wl,--dependency-file=CMakeFiles/StreamHubQtClient.dir/link.d CMakeFiles/StreamHubQtClient.dir/StreamHubQtClient_autogen/mocs_compilation.cpp.o CMakeFiles/StreamHubQtClient.dir/main.cpp.o CMakeFiles/StreamHubQtClient.dir/Theme.cpp.o CMakeFiles/StreamHubQtClient.dir/Hub.cpp.o CMakeFiles/StreamHubQtClient.dir/WsClient.cpp.o CMakeFiles/StreamHubQtClient.dir/PlotWidget.cpp.o CMakeFiles/StreamHubQtClient.dir/PlotGrid.cpp.o CMakeFiles/StreamHubQtClient.dir/SourceSidebar.cpp.o CMakeFiles/StreamHubQtClient.dir/TriggerBar.cpp.o CMakeFiles/StreamHubQtClient.dir/StatsDialog.cpp.o CMakeFiles/StreamHubQtClient.dir/HistoryBar.cpp.o CMakeFiles/StreamHubQtClient.dir/MainWindow.cpp.o CMakeFiles/StreamHubQtClient.dir/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.o -o StreamHubQtClient /usr/lib/libQt6Widgets.so.6.11.1 /usr/lib/libQt6WebSockets.so.6.11.1 /usr/lib/libQt6Gui.so.6.11.1 /usr/lib/libGLX.so /usr/lib/libOpenGL.so /usr/lib/libQt6Network.so.6.11.1 /usr/lib/libQt6Core.so.6.11.1
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient.dir/progress.make
+16
View File
@@ -0,0 +1,16 @@
CMAKE_PROGRESS_1 = 1
CMAKE_PROGRESS_2 = 2
CMAKE_PROGRESS_3 = 3
CMAKE_PROGRESS_4 = 4
CMAKE_PROGRESS_5 = 5
CMAKE_PROGRESS_6 = 6
CMAKE_PROGRESS_7 = 7
CMAKE_PROGRESS_8 = 8
CMAKE_PROGRESS_9 = 9
CMAKE_PROGRESS_10 = 10
CMAKE_PROGRESS_11 = 11
CMAKE_PROGRESS_12 = 12
CMAKE_PROGRESS_13 = 13
CMAKE_PROGRESS_14 = 14
CMAKE_PROGRESS_15 = 15
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient_autogen.dir/AutogenInfo.json
+925
View File
@@ -0,0 +1,925 @@
{
"BUILD_DIR" : "/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/StreamHubQtClient_autogen",
"CMAKE_BINARY_DIR" : "/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build",
"CMAKE_CURRENT_BINARY_DIR" : "/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build",
"CMAKE_CURRENT_SOURCE_DIR" : "/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt",
"CMAKE_EXECUTABLE" : "/usr/bin/cmake",
"CMAKE_LIST_FILES" :
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/CMakeLists.txt",
"/usr/share/cmake/Modules/CMakeDetermineSystem.cmake",
"/usr/share/cmake/Modules/CMakeSystem.cmake.in",
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles/4.4.2/CMakeSystem.cmake",
"/usr/share/cmake/Modules/CMakeUnixFindMake.cmake",
"/usr/share/cmake/Modules/CMakeSystemSpecificInitialize.cmake",
"/usr/share/cmake/Modules/Platform/Linux-Initialize.cmake",
"/usr/share/cmake/Modules/CMakeDetermineCXXCompiler.cmake",
"/usr/share/cmake/Modules/CMakeDetermineCompiler.cmake",
"/usr/share/cmake/Modules/Platform/Linux-Determine-CXX.cmake",
"/usr/share/cmake/Modules/CMakeDetermineCompilerId.cmake",
"/usr/share/cmake/Modules/CMakeCompilerIdDetection.cmake",
"/usr/share/cmake/Modules/Compiler/ADSP-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/ARMCC-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/ARMClang-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/AppleClang-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/Clang-DetermineCompilerInternal.cmake",
"/usr/share/cmake/Modules/Compiler/Borland-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/Clang-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/Clang-DetermineCompilerInternal.cmake",
"/usr/share/cmake/Modules/Compiler/Compaq-CXX-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/Cray-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/CrayClang-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/Diab-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/Embarcadero-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/Fujitsu-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/FujitsuClang-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/GHS-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/GNU-CXX-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/HP-CXX-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/IAR-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/IBMClang-CXX-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/Intel-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/IntelLLVM-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/LCC-CXX-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/MSVC-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/NVHPC-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/NVIDIA-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/OpenWatcom-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/OrangeC-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/PGI-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/PathScale-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/PellesC-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/Renesas-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/SCO-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/SunPro-CXX-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/TI-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/TIClang-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/Tasking-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/VisualAge-CXX-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake",
"/usr/share/cmake/Modules/Compiler/Watcom-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/XL-CXX-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake",
"/usr/share/cmake/Modules/Compiler/XLClang-CXX-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/zOS-CXX-DetermineCompiler.cmake",
"/usr/share/cmake/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake",
"/usr/share/cmake/Modules/CMakeFindBinUtils.cmake",
"/usr/share/cmake/Modules/Compiler/GNU-FindBinUtils.cmake",
"/usr/share/cmake/Modules/CMakeCXXCompiler.cmake.in",
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles/4.4.2/CMakeCXXCompiler.cmake",
"/usr/share/cmake/Modules/CMakeSystemSpecificInformation.cmake",
"/usr/share/cmake/Modules/CMakeGenericSystem.cmake",
"/usr/share/cmake/Modules/CMakeInitializeConfigs.cmake",
"/usr/share/cmake/Modules/Platform/Linux.cmake",
"/usr/share/cmake/Modules/Platform/UnixPaths.cmake",
"/usr/share/cmake/Modules/CMakeCXXInformation.cmake",
"/usr/share/cmake/Modules/CMakeLanguageInformation.cmake",
"/usr/share/cmake/Modules/Compiler/GNU-CXX.cmake",
"/usr/share/cmake/Modules/Compiler/GNU.cmake",
"/usr/share/cmake/Modules/Compiler/CMakeCommonCompilerMacros.cmake",
"/usr/share/cmake/Modules/Platform/Linux-GNU-CXX.cmake",
"/usr/share/cmake/Modules/Platform/Linux-GNU.cmake",
"/usr/share/cmake/Modules/CMakeCommonLanguageInclude.cmake",
"/usr/share/cmake/Modules/CMakeTestCXXCompiler.cmake",
"/usr/share/cmake/Modules/CMakeTestCompilerCommon.cmake",
"/usr/share/cmake/Modules/CMakeDetermineCompilerABI.cmake",
"/usr/share/cmake/Modules/Internal/CMakeDetermineLinkerId.cmake",
"/usr/share/cmake/Modules/CMakeParseImplicitIncludeInfo.cmake",
"/usr/share/cmake/Modules/CMakeParseImplicitLinkInfo.cmake",
"/usr/share/cmake/Modules/CMakeParseLibraryArchitecture.cmake",
"/usr/share/cmake/Modules/CMakeTestCompilerCommon.cmake",
"/usr/share/cmake/Modules/CMakeCXXCompilerABI.cpp",
"/usr/share/cmake/Modules/CMakeDetermineCompilerSupport.cmake",
"/usr/share/cmake/Modules/Internal/FeatureTesting.cmake",
"/usr/share/cmake/Modules/CMakeCXXCompiler.cmake.in",
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles/4.4.2/CMakeCXXCompiler.cmake",
"/usr/share/cmake/Modules/Internal/CMakeCXXLinkerInformation.cmake",
"/usr/share/cmake/Modules/Internal/CMakeCommonLinkerInformation.cmake",
"/usr/share/cmake/Modules/Linker/GNU-CXX.cmake",
"/usr/share/cmake/Modules/Linker/GNU.cmake",
"/usr/share/cmake/Modules/Platform/Linker/Linux-GNU-CXX.cmake",
"/usr/share/cmake/Modules/Platform/Linker/Linux-GNU.cmake",
"/usr/share/cmake/Modules/Platform/Linker/GNU.cmake",
"/usr/share/cmake/Modules/Internal/CMakeInspectCXXLinker.cmake",
"/usr/share/cmake/Modules/CMakeCXXCompiler.cmake.in",
"/usr/lib/cmake/Qt6/Qt6ConfigVersion.cmake",
"/usr/lib/cmake/Qt6/Qt6ConfigVersionImpl.cmake",
"/usr/lib/cmake/Qt6/Qt6Config.cmake",
"/usr/lib/cmake/Qt6/QtPublicCMakeEarlyPolicyHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicCMakeHelpers.cmake",
"/usr/lib/cmake/Qt6/Qt6ConfigExtras.cmake",
"/usr/lib/cmake/Qt6/QtPublicCMakeVersionHelpers.cmake",
"/usr/lib/cmake/Qt6/QtInstallPaths.cmake",
"/usr/lib/cmake/Qt6/Qt6TargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6/Qt6Targets.cmake",
"/usr/lib/cmake/Qt6/Qt6VersionlessAliasTargets.cmake",
"/usr/lib/cmake/Qt6/QtFeature.cmake",
"/usr/share/cmake/Modules/CheckCXXCompilerFlag.cmake",
"/usr/share/cmake/Modules/Internal/CheckCompilerFlag.cmake",
"/usr/share/cmake/Modules/Internal/CheckFlagCommonConfig.cmake",
"/usr/share/cmake/Modules/Internal/CheckSourceCompiles.cmake",
"/usr/share/cmake/Modules/Internal/CheckCommon.cmake",
"/usr/share/cmake/Modules/CMakeCheckCompilerFlagCommonPatterns.cmake",
"/usr/share/cmake/Modules/CheckCXXSourceCompiles.cmake",
"/usr/share/cmake/Modules/Internal/CheckSourceCompiles.cmake",
"/usr/lib/cmake/Qt6/QtFeatureCommon.cmake",
"/usr/lib/cmake/Qt6/QtPublicAndroidHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicAppleHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicCMakeHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicCMakeVersionHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicDependencyHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicExternalProjectHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicFinalizerHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicFindPackageHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicGitHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicPluginHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicPluginHelpers_v2.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomAttributionHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomBuildToolHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomCommonGenerationHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomCpeHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomCycloneDXHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomDocumentNamespaceHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomDepHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomExternalReferenceHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomFileHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomGenerationHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomGenerationCycloneDXHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomLicenseHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomOpsHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomPurlHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomPythonHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomQtEntityHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomRelationshipHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomSystemDepHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicTargetHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicTestHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicToolHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicWalkLibsHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicWindowsHelpers.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6/Qt6Dependencies.cmake",
"/usr/share/cmake/Modules/FindThreads.cmake",
"/usr/share/cmake/Modules/CheckLibraryExists.cmake",
"/usr/share/cmake/Modules/Internal/CheckCommon.cmake",
"/usr/share/cmake/Modules/CheckIncludeFileCXX.cmake",
"/usr/share/cmake/Modules/Internal/CheckCommon.cmake",
"/usr/share/cmake/Modules/CheckCXXSourceCompiles.cmake",
"/usr/share/cmake/Modules/FindPackageHandleStandardArgs.cmake",
"/usr/share/cmake/Modules/FindPackageMessage.cmake",
"/usr/lib/cmake/Qt6/Qt6ConfigVersion.cmake",
"/usr/lib/cmake/Qt6/Qt6ConfigVersionImpl.cmake",
"/usr/lib/cmake/Qt6/Qt6Config.cmake",
"/usr/lib/cmake/Qt6/QtPublicCMakeEarlyPolicyHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicCMakeHelpers.cmake",
"/usr/lib/cmake/Qt6/Qt6ConfigExtras.cmake",
"/usr/lib/cmake/Qt6/QtPublicCMakeVersionHelpers.cmake",
"/usr/lib/cmake/Qt6/QtInstallPaths.cmake",
"/usr/lib/cmake/Qt6/Qt6TargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6/QtFeature.cmake",
"/usr/share/cmake/Modules/CheckCXXCompilerFlag.cmake",
"/usr/lib/cmake/Qt6/QtFeatureCommon.cmake",
"/usr/lib/cmake/Qt6/QtPublicAndroidHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicAppleHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicCMakeHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicCMakeVersionHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicDependencyHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicExternalProjectHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicFinalizerHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicFindPackageHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicGitHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicPluginHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicPluginHelpers_v2.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomAttributionHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomBuildToolHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomCommonGenerationHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomCpeHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomCycloneDXHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomDocumentNamespaceHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomDepHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomExternalReferenceHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomFileHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomGenerationHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomGenerationCycloneDXHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomLicenseHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomOpsHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomPurlHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomPythonHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomQtEntityHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomRelationshipHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicSbomSystemDepHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicTargetHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicTestHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicToolHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicWalkLibsHelpers.cmake",
"/usr/lib/cmake/Qt6/QtPublicWindowsHelpers.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6/Qt6Dependencies.cmake",
"/usr/lib/cmake/Qt6Widgets/Qt6WidgetsConfigVersion.cmake",
"/usr/lib/cmake/Qt6Widgets/Qt6WidgetsConfigVersionImpl.cmake",
"/usr/lib/cmake/Qt6Widgets/Qt6WidgetsConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Widgets/Qt6WidgetsDependencies.cmake",
"/usr/lib/cmake/Qt6WidgetsTools/Qt6WidgetsToolsConfigVersion.cmake",
"/usr/lib/cmake/Qt6WidgetsTools/Qt6WidgetsToolsConfigVersionImpl.cmake",
"/usr/lib/cmake/Qt6WidgetsTools/Qt6WidgetsToolsConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6WidgetsTools/Qt6WidgetsToolsDependencies.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfigVersion.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfigVersionImpl.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsDependencies.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsTargets.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsVersionlessTargets.cmake",
"/usr/lib/cmake/Qt6GuiTools/Qt6GuiToolsConfigVersion.cmake",
"/usr/lib/cmake/Qt6GuiTools/Qt6GuiToolsConfigVersionImpl.cmake",
"/usr/lib/cmake/Qt6GuiTools/Qt6GuiToolsConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6GuiTools/Qt6GuiToolsDependencies.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfigVersion.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfigVersionImpl.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsDependencies.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6GuiTools/Qt6GuiToolsTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6GuiTools/Qt6GuiToolsTargets.cmake",
"/usr/lib/cmake/Qt6GuiTools/Qt6GuiToolsTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6GuiTools/Qt6GuiToolsAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6GuiTools/Qt6GuiToolsVersionlessTargets.cmake",
"/usr/lib/cmake/Qt6WidgetsTools/Qt6WidgetsToolsTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6WidgetsTools/Qt6WidgetsToolsTargets.cmake",
"/usr/lib/cmake/Qt6WidgetsTools/Qt6WidgetsToolsTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6WidgetsTools/Qt6WidgetsToolsAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6WidgetsTools/Qt6WidgetsToolsVersionlessTargets.cmake",
"/usr/lib/cmake/Qt6Core/Qt6CoreConfigVersion.cmake",
"/usr/lib/cmake/Qt6Core/Qt6CoreConfigVersionImpl.cmake",
"/usr/lib/cmake/Qt6Core/Qt6CoreConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Core/Qt6CoreDependencies.cmake",
"/usr/lib/cmake/Qt6/FindWrapAtomic.cmake",
"/usr/share/cmake/Modules/CheckCXXSourceCompiles.cmake",
"/usr/share/cmake/Modules/FindPackageHandleStandardArgs.cmake",
"/usr/share/cmake/Modules/FindPackageMessage.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfigVersion.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfigVersionImpl.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsDependencies.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Core/Qt6CoreTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Core/Qt6CoreTargets.cmake",
"/usr/lib/cmake/Qt6Core/Qt6CoreTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Core/Qt6CoreAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Core/Qt6CoreMacros.cmake",
"/usr/lib/cmake/Qt6Core/Qt6CoreConfigExtras.cmake",
"/usr/share/cmake/Modules/GNUInstallDirs.cmake",
"/usr/lib/cmake/Qt6Core/Qt6CoreVersionlessAliasTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6GuiConfigVersion.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6GuiConfigVersionImpl.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6GuiConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6GuiDependencies.cmake",
"/usr/lib/cmake/Qt6/FindWrapOpenGL.cmake",
"/usr/share/cmake/Modules/FindOpenGL.cmake",
"/usr/share/cmake/Modules/FindPackageHandleStandardArgs.cmake",
"/usr/share/cmake/Modules/FindPackageMessage.cmake",
"/usr/share/cmake/Modules/FindPackageHandleStandardArgs.cmake",
"/usr/share/cmake/Modules/FindPackageMessage.cmake",
"/usr/lib/cmake/Qt6/FindWrapVulkanHeaders.cmake",
"/usr/share/cmake/Modules/FindVulkan.cmake",
"/usr/share/cmake/Modules/FindPackageHandleStandardArgs.cmake",
"/usr/share/cmake/Modules/FindPackageMessage.cmake",
"/usr/share/cmake/Modules/FindPackageHandleStandardArgs.cmake",
"/usr/share/cmake/Modules/FindPackageMessage.cmake",
"/usr/lib/cmake/Qt6GuiTools/Qt6GuiToolsConfigVersion.cmake",
"/usr/lib/cmake/Qt6GuiTools/Qt6GuiToolsConfigVersionImpl.cmake",
"/usr/lib/cmake/Qt6GuiTools/Qt6GuiToolsConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6GuiTools/Qt6GuiToolsDependencies.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfigVersion.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfigVersionImpl.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsDependencies.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6GuiTools/Qt6GuiToolsTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6DBus/Qt6DBusConfigVersion.cmake",
"/usr/lib/cmake/Qt6DBus/Qt6DBusConfigVersionImpl.cmake",
"/usr/lib/cmake/Qt6DBus/Qt6DBusConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6DBus/Qt6DBusDependencies.cmake",
"/usr/lib/cmake/Qt6DBusTools/Qt6DBusToolsConfigVersion.cmake",
"/usr/lib/cmake/Qt6DBusTools/Qt6DBusToolsConfigVersionImpl.cmake",
"/usr/lib/cmake/Qt6DBusTools/Qt6DBusToolsConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6DBusTools/Qt6DBusToolsDependencies.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfigVersion.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfigVersionImpl.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsDependencies.cmake",
"/usr/lib/cmake/Qt6CoreTools/Qt6CoreToolsTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6DBusTools/Qt6DBusToolsTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6DBusTools/Qt6DBusToolsTargets.cmake",
"/usr/lib/cmake/Qt6DBusTools/Qt6DBusToolsTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6DBusTools/Qt6DBusToolsAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6DBusTools/Qt6DBusToolsVersionlessTargets.cmake",
"/usr/lib/cmake/Qt6DBus/Qt6DBusTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6DBus/Qt6DBusTargets.cmake",
"/usr/lib/cmake/Qt6DBus/Qt6DBusTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6DBus/Qt6DBusAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6DBus/Qt6DBusMacros.cmake",
"/usr/share/cmake/Modules/MacroAddFileDependencies.cmake",
"/usr/lib/cmake/Qt6DBus/Qt6DBusVersionlessAliasTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6GuiTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6GuiTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6GuiTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6GuiAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6GuiPlugins.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6DmaBufServerBufferPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6DmaBufServerBufferPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6DmaBufServerBufferPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6DmaBufServerBufferPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6DmaBufServerBufferPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6DrmEglServerBufferPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6DrmEglServerBufferPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6DrmEglServerBufferPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6DrmEglServerBufferPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6DrmEglServerBufferPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QComposePlatformInputContextPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QComposePlatformInputContextPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QComposePlatformInputContextPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QComposePlatformInputContextPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QComposePlatformInputContextPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSEmulatorIntegrationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSEmulatorIntegrationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSEmulatorIntegrationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSEmulatorIntegrationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSEmulatorIntegrationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSIntegrationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSIntegrationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSIntegrationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSIntegrationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSIntegrationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSKmsEglDeviceIntegrationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSKmsEglDeviceIntegrationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSKmsEglDeviceIntegrationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSKmsEglDeviceIntegrationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSKmsEglDeviceIntegrationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSKmsGbmIntegrationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSKmsGbmIntegrationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSKmsGbmIntegrationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSKmsGbmIntegrationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSKmsGbmIntegrationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSX11IntegrationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSX11IntegrationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSX11IntegrationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSX11IntegrationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEglFSX11IntegrationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevKeyboardPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevKeyboardPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevKeyboardPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevKeyboardPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevKeyboardPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevMousePluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevMousePluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevMousePluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevMousePluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevMousePluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevTabletPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevTabletPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevTabletPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevTabletPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevTabletPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevTouchScreenPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevTouchScreenPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevTouchScreenPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevTouchScreenPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QEvdevTouchScreenPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QGifPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QGifPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QGifPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QGifPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QGifPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QGtk3ThemePluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QGtk3ThemePluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QGtk3ThemePluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QGtk3ThemePluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QGtk3ThemePluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QICNSPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QICNSPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QICNSPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QICNSPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QICNSPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QICOPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QICOPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QICOPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QICOPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QICOPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QIbusPlatformInputContextPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QIbusPlatformInputContextPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QIbusPlatformInputContextPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QIbusPlatformInputContextPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QIbusPlatformInputContextPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QJp2PluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QJp2PluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QJp2PluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QJp2PluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QJp2PluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QJpegPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QJpegPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QJpegPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QJpegPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QJpegPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QLibInputPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QLibInputPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QLibInputPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QLibInputPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QLibInputPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QLinuxFbIntegrationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QLinuxFbIntegrationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QLinuxFbIntegrationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QLinuxFbIntegrationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QLinuxFbIntegrationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QMinimalEglIntegrationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QMinimalEglIntegrationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QMinimalEglIntegrationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QMinimalEglIntegrationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QMinimalEglIntegrationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QMinimalIntegrationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QMngPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QMngPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QMngPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QMngPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QMngPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QOffscreenIntegrationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QPdfPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QPdfPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QPdfPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QPdfPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QPdfPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QSvgIconPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QSvgIconPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QSvgIconPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QSvgIconPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QSvgIconPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QSvgPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QSvgPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QSvgPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QSvgPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QSvgPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QTgaPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QTgaPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QTgaPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QTgaPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QTgaPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QTiffPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QTiffPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QTiffPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QTiffPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QTiffPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QTsLibPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QTsLibPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QTsLibPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QTsLibPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QTsLibPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QTuioTouchPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QVkKhrDisplayIntegrationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QVkKhrDisplayIntegrationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QVkKhrDisplayIntegrationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QVkKhrDisplayIntegrationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QVkKhrDisplayIntegrationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QVncIntegrationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QVncIntegrationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QVncIntegrationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QVncIntegrationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QVncIntegrationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandAdwaitaDecorationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandAdwaitaDecorationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandAdwaitaDecorationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandAdwaitaDecorationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandAdwaitaDecorationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandBradientDecorationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandBradientDecorationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandBradientDecorationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandBradientDecorationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandBradientDecorationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandEglClientBufferPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandEglClientBufferPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandEglClientBufferPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandEglClientBufferPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandEglClientBufferPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandFullScreenShellV1IntegrationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandFullScreenShellV1IntegrationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandFullScreenShellV1IntegrationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandFullScreenShellV1IntegrationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandFullScreenShellV1IntegrationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandIntegrationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandIntegrationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandIntegrationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandIntegrationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandIntegrationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandIviShellIntegrationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandIviShellIntegrationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandIviShellIntegrationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandIviShellIntegrationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandIviShellIntegrationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandQtShellIntegrationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandQtShellIntegrationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandQtShellIntegrationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandQtShellIntegrationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandQtShellIntegrationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandWlShellIntegrationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandWlShellIntegrationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandWlShellIntegrationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandWlShellIntegrationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandWlShellIntegrationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandXdgShellIntegrationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandXdgShellIntegrationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandXdgShellIntegrationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandXdgShellIntegrationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWaylandXdgShellIntegrationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWbmpPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWbmpPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWbmpPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWbmpPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWbmpPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWebpPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWebpPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWebpPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWebpPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QWebpPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QXcbEglIntegrationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QXcbEglIntegrationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QXcbEglIntegrationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QXcbEglIntegrationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QXcbEglIntegrationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QXcbGlxIntegrationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QXcbGlxIntegrationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QXcbGlxIntegrationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QXcbGlxIntegrationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QXcbGlxIntegrationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QXcbIntegrationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QXcbIntegrationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QXcbIntegrationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QXcbIntegrationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QXcbIntegrationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QXdgDesktopPortalThemePluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QXdgDesktopPortalThemePluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QXdgDesktopPortalThemePluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QXdgDesktopPortalThemePluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6QXdgDesktopPortalThemePluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6ShmServerBufferPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6ShmServerBufferPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6ShmServerBufferPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6ShmServerBufferPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6ShmServerBufferPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6VulkanServerBufferPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6VulkanServerBufferPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6VulkanServerBufferPluginTargets.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6VulkanServerBufferPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6VulkanServerBufferPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Gui/Qt6GuiVersionlessAliasTargets.cmake",
"/usr/lib/cmake/Qt6Widgets/Qt6WidgetsTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Widgets/Qt6WidgetsTargets.cmake",
"/usr/lib/cmake/Qt6Widgets/Qt6WidgetsTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Widgets/Qt6WidgetsAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Widgets/Qt6WidgetsMacros.cmake",
"/usr/lib/cmake/Qt6Widgets/Qt6WidgetsPlugins.cmake",
"/usr/lib/cmake/Qt6Widgets/Qt6WidgetsVersionlessAliasTargets.cmake",
"/usr/lib/cmake/Qt6WebSockets/Qt6WebSocketsConfigVersion.cmake",
"/usr/lib/cmake/Qt6WebSockets/Qt6WebSocketsConfigVersionImpl.cmake",
"/usr/lib/cmake/Qt6WebSockets/Qt6WebSocketsConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6WebSockets/Qt6WebSocketsDependencies.cmake",
"/usr/lib/cmake/Qt6Network/Qt6NetworkConfigVersion.cmake",
"/usr/lib/cmake/Qt6Network/Qt6NetworkConfigVersionImpl.cmake",
"/usr/lib/cmake/Qt6Network/Qt6NetworkConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Network/Qt6NetworkDependencies.cmake",
"/usr/lib/cmake/Qt6Network/Qt6NetworkTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Network/Qt6NetworkTargets.cmake",
"/usr/lib/cmake/Qt6Network/Qt6NetworkTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Network/Qt6NetworkAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Network/Qt6NetworkPlugins.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QConnManNetworkInformationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QConnManNetworkInformationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QConnManNetworkInformationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QConnManNetworkInformationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QConnManNetworkInformationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QGlibNetworkInformationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QGlibNetworkInformationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QGlibNetworkInformationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QGlibNetworkInformationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QGlibNetworkInformationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QNetworkManagerNetworkInformationPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QNetworkManagerNetworkInformationPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QNetworkManagerNetworkInformationPluginTargets.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QNetworkManagerNetworkInformationPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QNetworkManagerNetworkInformationPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginTargets.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QTlsBackendCertOnlyPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginConfig.cmake",
"/usr/share/cmake/Modules/CMakeFindDependencyMacro.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginTargets.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6Network/Qt6QTlsBackendOpenSSLPluginAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6Network/Qt6NetworkVersionlessAliasTargets.cmake",
"/usr/lib/cmake/Qt6WebSockets/Qt6WebSocketsTargetsPrecheck.cmake",
"/usr/lib/cmake/Qt6WebSockets/Qt6WebSocketsTargets.cmake",
"/usr/lib/cmake/Qt6WebSockets/Qt6WebSocketsTargets-relwithdebinfo.cmake",
"/usr/lib/cmake/Qt6WebSockets/Qt6WebSocketsAdditionalTargetInfo.cmake",
"/usr/lib/cmake/Qt6WebSockets/Qt6WebSocketsVersionlessAliasTargets.cmake"
],
"CMAKE_SOURCE_DIR" : "/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt",
"CROSS_CONFIG" : false,
"DEP_FILE" : "/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/StreamHubQtClient_autogen/deps",
"DEP_FILE_RULE_NAME" : "StreamHubQtClient_autogen/timestamp",
"HEADERS" :
[
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/HistoryBar.h",
"Mu",
"EWIEGA46WW/moc_HistoryBar.cpp",
null
],
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/Hub.h",
"Mu",
"EWIEGA46WW/moc_Hub.cpp",
null
],
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/MainWindow.h",
"Mu",
"EWIEGA46WW/moc_MainWindow.cpp",
null
],
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/Model.h",
"Mu",
"EWIEGA46WW/moc_Model.cpp",
null
],
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/PlotGrid.h",
"Mu",
"EWIEGA46WW/moc_PlotGrid.cpp",
null
],
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/PlotWidget.h",
"Mu",
"EWIEGA46WW/moc_PlotWidget.cpp",
null
],
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/SourceSidebar.h",
"Mu",
"EWIEGA46WW/moc_SourceSidebar.cpp",
null
],
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/StatsDialog.h",
"Mu",
"EWIEGA46WW/moc_StatsDialog.cpp",
null
],
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/Theme.h",
"Mu",
"EWIEGA46WW/moc_Theme.cpp",
null
],
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/TriggerBar.h",
"Mu",
"EWIEGA46WW/moc_TriggerBar.cpp",
null
],
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/WsClient.h",
"Mu",
"EWIEGA46WW/moc_WsClient.cpp",
null
],
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.h",
"Mu",
"RQWVCOUPNN/moc_Protocol.cpp",
null
]
],
"HEADER_EXTENSIONS" : [ "h", "hh", "h++", "hm", "hpp", "hxx", "in", "txx" ],
"INCLUDE_DIR" : "/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/StreamHubQtClient_autogen/include",
"MOC_COMPILATION_FILE" : "/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/StreamHubQtClient_autogen/mocs_compilation.cpp",
"MOC_DEFINITIONS" :
[
"QT_CORE_LIB",
"QT_GUI_LIB",
"QT_NETWORK_LIB",
"QT_NO_DEBUG",
"QT_NO_KEYWORDS",
"QT_WEBSOCKETS_LIB",
"QT_WIDGETS_LIB"
],
"MOC_DEPEND_FILTERS" :
[
[
"Q_PLUGIN_METADATA",
"[\n][ \t]*Q_PLUGIN_METADATA[ \t]*\\([^\\)]*FILE[ \t]*\"([^\"]+)\""
]
],
"MOC_INCLUDES" :
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt",
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub",
"/usr/include/qt6/QtWidgets",
"/usr/include/qt6",
"/usr/include/qt6/QtCore",
"/usr/lib/qt6/mkspecs/linux-g++",
"/usr/include/qt6/QtGui",
"/usr/include/qt6/QtWebSockets",
"/usr/include/qt6/QtNetwork",
"/usr/include",
"/usr/include/c++/16",
"/usr/include/c++/16/x86_64-pc-linux-gnu",
"/usr/include/c++/16/backward",
"/usr/lib/gcc/x86_64-pc-linux-gnu/16/include",
"/usr/local/include"
],
"MOC_MACRO_NAMES" :
[
"Q_OBJECT",
"Q_GADGET",
"Q_NAMESPACE",
"Q_NAMESPACE_EXPORT",
"Q_GADGET_EXPORT",
"Q_ENUM_NS"
],
"MOC_OPTIONS" : [],
"MOC_PATH_PREFIX" : false,
"MOC_PREDEFS_CMD" :
[
"/usr/bin/c++",
"-std=gnu++17",
"-w",
"-dM",
"-E",
"/usr/share/cmake/Modules/CMakeCXXCompilerABI.cpp"
],
"MOC_PREDEFS_FILE" : "/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/StreamHubQtClient_autogen/moc_predefs.h",
"MOC_RELAXED_MODE" : false,
"MOC_SKIP" : [],
"MULTI_CONFIG" : false,
"PARALLEL" : 12,
"PARSE_CACHE_FILE" : "/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient_autogen.dir/ParseCache.txt",
"QT_MOC_EXECUTABLE" : "/usr/lib/qt6/moc",
"QT_UIC_EXECUTABLE" : "",
"QT_VERSION_MAJOR" : 6,
"QT_VERSION_MINOR" : 11,
"SETTINGS_FILE" : "/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient_autogen.dir/AutogenUsed.txt",
"SOURCES" :
[
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/HistoryBar.cpp",
"Mu",
null
],
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/Hub.cpp",
"Mu",
null
],
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/MainWindow.cpp",
"Mu",
null
],
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/PlotGrid.cpp",
"Mu",
null
],
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/PlotWidget.cpp",
"Mu",
null
],
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/SourceSidebar.cpp",
"Mu",
null
],
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/StatsDialog.cpp",
"Mu",
null
],
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/Theme.cpp",
"Mu",
null
],
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/TriggerBar.cpp",
"Mu",
null
],
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/WsClient.cpp",
"Mu",
null
],
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/main.cpp",
"Mu",
null
],
[
"/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp",
"Mu",
null
]
],
"USE_BETTER_GRAPH" : true,
"VERBOSITY" : 0
}
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient_autogen.dir/AutogenUsed.txt
+1
View File
@@ -0,0 +1 @@
moc:fbadccd7b3896336babda4a708ab9e156687fc005a6a2d8e03a91a4da1b7f080
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient_autogen.dir/DependInfo.cmake
+23
View File
@@ -0,0 +1,23 @@
# Consider dependencies only in project.
set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF)
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of dependency files which are needed:
set(CMAKE_DEPENDS_DEPENDENCY_FILES
"" "StreamHubQtClient_autogen/timestamp" "custom" "StreamHubQtClient_autogen/deps"
)
# Targets to which this target links which contain Fortran sources.
set(CMAKE_Fortran_TARGET_LINKED_INFO_FILES
)
# Targets to which this target links which contain Fortran sources.
set(CMAKE_Fortran_TARGET_FORWARD_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient_autogen.dir/ParseCache.txt
+4149
View File
File diff suppressed because it is too large Load Diff
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient_autogen.dir/build.make
+96
View File
@@ -0,0 +1,96 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 4.4
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Disable VCS-based implicit rules.
% : %,v
# Disable VCS-based implicit rules.
% : RCS/%
# Disable VCS-based implicit rules.
% : RCS/%,v
# Disable VCS-based implicit rules.
% : SCCS/s.%
# Disable VCS-based implicit rules.
% : s.%
.SUFFIXES: .hpux_make_needs_suffix_list
# Command-line flag to silence nested $(MAKE).
$(VERBOSE)MAKESILENT = -s
#Suppress display of executed commands.
$(VERBOSE).SILENT:
# A target that is always out of date.
cmake_force:
.PHONY : cmake_force
#=============================================================================
# Set environment variables for the build.
# The shell in which to execute make rules.
SHELL = /bin/sh
# The CMake executable.
CMAKE_COMMAND = /usr/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E rm -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build
# Utility rule file for StreamHubQtClient_autogen.
# Include any custom commands dependencies for this target.
include CMakeFiles/StreamHubQtClient_autogen.dir/compiler_depend.make
# Include the progress variables for this target.
include CMakeFiles/StreamHubQtClient_autogen.dir/progress.make
CMakeFiles/StreamHubQtClient_autogen: StreamHubQtClient_autogen/timestamp
StreamHubQtClient_autogen/timestamp: /usr/lib/qt6/moc
StreamHubQtClient_autogen/timestamp: CMakeFiles/StreamHubQtClient_autogen.dir/compiler_depend.ts
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --blue --bold --progress-dir=/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Automatic MOC for target StreamHubQtClient"
/usr/bin/cmake -E cmake_autogen /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient_autogen.dir/AutogenInfo.json ""
/usr/bin/cmake -E touch /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/StreamHubQtClient_autogen/timestamp
CMakeFiles/StreamHubQtClient_autogen.dir/codegen:
.PHONY : CMakeFiles/StreamHubQtClient_autogen.dir/codegen
StreamHubQtClient_autogen: CMakeFiles/StreamHubQtClient_autogen
StreamHubQtClient_autogen: StreamHubQtClient_autogen/timestamp
StreamHubQtClient_autogen: CMakeFiles/StreamHubQtClient_autogen.dir/build.make
.PHONY : StreamHubQtClient_autogen
# Rule to build all files generated by this target.
CMakeFiles/StreamHubQtClient_autogen.dir/build: StreamHubQtClient_autogen
.PHONY : CMakeFiles/StreamHubQtClient_autogen.dir/build
CMakeFiles/StreamHubQtClient_autogen.dir/clean:
$(CMAKE_COMMAND) -P CMakeFiles/StreamHubQtClient_autogen.dir/cmake_clean.cmake
.PHONY : CMakeFiles/StreamHubQtClient_autogen.dir/clean
CMakeFiles/StreamHubQtClient_autogen.dir/depend:
cd /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient_autogen.dir/DependInfo.cmake "--color=$(COLOR)" StreamHubQtClient_autogen
.PHONY : CMakeFiles/StreamHubQtClient_autogen.dir/depend
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient_autogen.dir/cmake_clean.cmake
+10
View File
@@ -0,0 +1,10 @@
file(REMOVE_RECURSE
"CMakeFiles/StreamHubQtClient_autogen"
"StreamHubQtClient_autogen/mocs_compilation.cpp"
"StreamHubQtClient_autogen/timestamp"
)
# Per-language clean rules from dependency scanning.
foreach(lang )
include(CMakeFiles/StreamHubQtClient_autogen.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient_autogen.dir/compiler_depend.make
+2
View File
@@ -0,0 +1,2 @@
# Empty custom commands generated dependencies file for StreamHubQtClient_autogen.
# This may be replaced when dependencies are built.
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient_autogen.dir/compiler_depend.ts
+2
View File
@@ -0,0 +1,2 @@
# CMAKE generated file: DO NOT EDIT!
# Timestamp file for custom commands dependencies management for StreamHubQtClient_autogen.
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient_autogen.dir/progress.make
+2
View File
@@ -0,0 +1,2 @@
CMAKE_PROGRESS_1 = 16
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/DependInfo.cmake
+22
View File
@@ -0,0 +1,22 @@
# Consider dependencies only in project.
set(CMAKE_DEPENDS_IN_PROJECT_ONLY OFF)
# The set of languages for which implicit dependencies are needed:
set(CMAKE_DEPENDS_LANGUAGES
)
# The set of dependency files which are needed:
set(CMAKE_DEPENDS_DEPENDENCY_FILES
)
# Targets to which this target links which contain Fortran sources.
set(CMAKE_Fortran_TARGET_LINKED_INFO_FILES
)
# Targets to which this target links which contain Fortran sources.
set(CMAKE_Fortran_TARGET_FORWARD_LINKED_INFO_FILES
)
# Fortran module output directory.
set(CMAKE_Fortran_TARGET_MODULE_DIR "")
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/build.make
+86
View File
@@ -0,0 +1,86 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 4.4
# Delete rule output on recipe failure.
.DELETE_ON_ERROR:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Disable VCS-based implicit rules.
% : %,v
# Disable VCS-based implicit rules.
% : RCS/%
# Disable VCS-based implicit rules.
% : RCS/%,v
# Disable VCS-based implicit rules.
% : SCCS/s.%
# Disable VCS-based implicit rules.
% : s.%
.SUFFIXES: .hpux_make_needs_suffix_list
# Command-line flag to silence nested $(MAKE).
$(VERBOSE)MAKESILENT = -s
#Suppress display of executed commands.
$(VERBOSE).SILENT:
# A target that is always out of date.
cmake_force:
.PHONY : cmake_force
#=============================================================================
# Set environment variables for the build.
# The shell in which to execute make rules.
SHELL = /bin/sh
# The CMake executable.
CMAKE_COMMAND = /usr/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E rm -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build
# Utility rule file for StreamHubQtClient_autogen_timestamp_deps.
# Include any custom commands dependencies for this target.
include CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/compiler_depend.make
# Include the progress variables for this target.
include CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/progress.make
CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/codegen:
.PHONY : CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/codegen
StreamHubQtClient_autogen_timestamp_deps: CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/build.make
.PHONY : StreamHubQtClient_autogen_timestamp_deps
# Rule to build all files generated by this target.
CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/build: StreamHubQtClient_autogen_timestamp_deps
.PHONY : CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/build
CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/clean:
$(CMAKE_COMMAND) -P CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/cmake_clean.cmake
.PHONY : CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/clean
CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/depend:
cd /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/DependInfo.cmake "--color=$(COLOR)" StreamHubQtClient_autogen_timestamp_deps
.PHONY : CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/depend
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/cmake_clean.cmake
+5
View File
@@ -0,0 +1,5 @@
# Per-language clean rules from dependency scanning.
foreach(lang )
include(CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/cmake_clean_${lang}.cmake OPTIONAL)
endforeach()
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/compiler_depend.make
+2
View File
@@ -0,0 +1,2 @@
# Empty custom commands generated dependencies file for StreamHubQtClient_autogen_timestamp_deps.
# This may be replaced when dependencies are built.
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/compiler_depend.ts
+2
View File
@@ -0,0 +1,2 @@
# CMAKE generated file: DO NOT EDIT!
# Timestamp file for custom commands dependencies management for StreamHubQtClient_autogen_timestamp_deps.
Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/progress.make
+1
View File
@@ -0,0 +1 @@
Client/streamhub-qt/build/CMakeFiles/TargetDirectories.txt
+9
View File
@@ -0,0 +1,9 @@
/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient.dir
/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles/edit_cache.dir
/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles/rebuild_cache.dir
/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles/list_install_components.dir
/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles/install.dir
/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles/install/local.dir
/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles/install/strip.dir
/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir
/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient_autogen.dir
Client/streamhub-qt/build/CMakeFiles/cmake.check_cache
+1
View File
@@ -0,0 +1 @@
# This file is generated by cmake for dependency checking of the CMakeCache.txt file
Client/streamhub-qt/build/CMakeFiles/progress.marks
+1
View File
@@ -0,0 +1 @@
16
Client/streamhub-qt/build/Makefile
+582
View File
@@ -0,0 +1,582 @@
# CMAKE generated file: DO NOT EDIT!
# Generated by "Unix Makefiles" Generator, CMake Version 4.4
# Default target executed when no arguments are given to make.
default_target: all
.PHONY : default_target
# Allow only one "make -f Makefile2" at a time, but pass parallelism.
.NOTPARALLEL:
#=============================================================================
# Special targets provided by cmake.
# Disable implicit rules so canonical targets will work.
.SUFFIXES:
# Disable VCS-based implicit rules.
% : %,v
# Disable VCS-based implicit rules.
% : RCS/%
# Disable VCS-based implicit rules.
% : RCS/%,v
# Disable VCS-based implicit rules.
% : SCCS/s.%
# Disable VCS-based implicit rules.
% : s.%
.SUFFIXES: .hpux_make_needs_suffix_list
# Command-line flag to silence nested $(MAKE).
$(VERBOSE)MAKESILENT = -s
#Suppress display of executed commands.
$(VERBOSE).SILENT:
# A target that is always out of date.
cmake_force:
.PHONY : cmake_force
#=============================================================================
# Set environment variables for the build.
# The shell in which to execute make rules.
SHELL = /bin/sh
# The CMake executable.
CMAKE_COMMAND = /usr/bin/cmake
# The command to remove a file.
RM = /usr/bin/cmake -E rm -f
# Escaping for special characters.
EQUALS = =
# The top-level source directory on which CMake was run.
CMAKE_SOURCE_DIR = /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt
# The top-level build directory on which CMake was run.
CMAKE_BINARY_DIR = /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build
#=============================================================================
# Targets provided globally by CMake.
# Special rule for the target edit_cache
edit_cache:
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake cache editor..."
/usr/bin/ccmake -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
.PHONY : edit_cache
# Special rule for the target edit_cache
edit_cache/fast: edit_cache
.PHONY : edit_cache/fast
# Special rule for the target rebuild_cache
rebuild_cache:
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Running CMake to regenerate build system..."
/usr/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR)
.PHONY : rebuild_cache
# Special rule for the target rebuild_cache
rebuild_cache/fast: rebuild_cache
.PHONY : rebuild_cache/fast
# Special rule for the target list_install_components
list_install_components:
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Available install components are: \"Unspecified\""
.PHONY : list_install_components
# Special rule for the target list_install_components
list_install_components/fast: list_install_components
.PHONY : list_install_components/fast
# Special rule for the target install
install: preinstall
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
/usr/bin/cmake -P cmake_install.cmake
.PHONY : install
# Special rule for the target install
install/fast: preinstall/fast
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Install the project..."
/usr/bin/cmake -P cmake_install.cmake
.PHONY : install/fast
# Special rule for the target install/local
install/local: preinstall
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
/usr/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
.PHONY : install/local
# Special rule for the target install/local
install/local/fast: preinstall/fast
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing only the local directory..."
/usr/bin/cmake -DCMAKE_INSTALL_LOCAL_ONLY=1 -P cmake_install.cmake
.PHONY : install/local/fast
# Special rule for the target install/strip
install/strip: preinstall
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
/usr/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
.PHONY : install/strip
# Special rule for the target install/strip
install/strip/fast: preinstall/fast
@$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --cyan "Installing the project stripped..."
/usr/bin/cmake -DCMAKE_INSTALL_DO_STRIP=1 -P cmake_install.cmake
.PHONY : install/strip/fast
# The main all target
all: cmake_check_build_system
$(CMAKE_COMMAND) -E cmake_progress_start /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build//CMakeFiles/progress.marks
$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 all
$(CMAKE_COMMAND) -E cmake_progress_start /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles 0
.PHONY : all
# The main clean target
clean:
$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 clean
.PHONY : clean
# The main clean target
clean/fast: clean
.PHONY : clean/fast
# Prepare targets for installation.
preinstall: all
$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 preinstall
.PHONY : preinstall
# Prepare targets for installation.
preinstall/fast:
$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 preinstall
.PHONY : preinstall/fast
# clear depends
depend:
$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1
.PHONY : depend
#=============================================================================
# Target rules for targets named StreamHubQtClient
# Build rule for target.
StreamHubQtClient: cmake_check_build_system
$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 StreamHubQtClient
.PHONY : StreamHubQtClient
# fast build rule for target.
StreamHubQtClient/fast:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/build
.PHONY : StreamHubQtClient/fast
#=============================================================================
# Target rules for targets named StreamHubQtClient_autogen_timestamp_deps
# Build rule for target.
StreamHubQtClient_autogen_timestamp_deps: cmake_check_build_system
$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 StreamHubQtClient_autogen_timestamp_deps
.PHONY : StreamHubQtClient_autogen_timestamp_deps
# fast build rule for target.
StreamHubQtClient_autogen_timestamp_deps/fast:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/build.make CMakeFiles/StreamHubQtClient_autogen_timestamp_deps.dir/build
.PHONY : StreamHubQtClient_autogen_timestamp_deps/fast
#=============================================================================
# Target rules for targets named StreamHubQtClient_autogen
# Build rule for target.
StreamHubQtClient_autogen: cmake_check_build_system
$(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 StreamHubQtClient_autogen
.PHONY : StreamHubQtClient_autogen
# fast build rule for target.
StreamHubQtClient_autogen/fast:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient_autogen.dir/build.make CMakeFiles/StreamHubQtClient_autogen.dir/build
.PHONY : StreamHubQtClient_autogen/fast
HistoryBar.o: HistoryBar.cpp.o
.PHONY : HistoryBar.o
# target to build an object file
HistoryBar.cpp.o:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/HistoryBar.cpp.o
.PHONY : HistoryBar.cpp.o
HistoryBar.i: HistoryBar.cpp.i
.PHONY : HistoryBar.i
# target to preprocess a source file
HistoryBar.cpp.i:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/HistoryBar.cpp.i
.PHONY : HistoryBar.cpp.i
HistoryBar.s: HistoryBar.cpp.s
.PHONY : HistoryBar.s
# target to generate assembly for a file
HistoryBar.cpp.s:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/HistoryBar.cpp.s
.PHONY : HistoryBar.cpp.s
Hub.o: Hub.cpp.o
.PHONY : Hub.o
# target to build an object file
Hub.cpp.o:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/Hub.cpp.o
.PHONY : Hub.cpp.o
Hub.i: Hub.cpp.i
.PHONY : Hub.i
# target to preprocess a source file
Hub.cpp.i:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/Hub.cpp.i
.PHONY : Hub.cpp.i
Hub.s: Hub.cpp.s
.PHONY : Hub.s
# target to generate assembly for a file
Hub.cpp.s:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/Hub.cpp.s
.PHONY : Hub.cpp.s
MainWindow.o: MainWindow.cpp.o
.PHONY : MainWindow.o
# target to build an object file
MainWindow.cpp.o:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/MainWindow.cpp.o
.PHONY : MainWindow.cpp.o
MainWindow.i: MainWindow.cpp.i
.PHONY : MainWindow.i
# target to preprocess a source file
MainWindow.cpp.i:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/MainWindow.cpp.i
.PHONY : MainWindow.cpp.i
MainWindow.s: MainWindow.cpp.s
.PHONY : MainWindow.s
# target to generate assembly for a file
MainWindow.cpp.s:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/MainWindow.cpp.s
.PHONY : MainWindow.cpp.s
PlotGrid.o: PlotGrid.cpp.o
.PHONY : PlotGrid.o
# target to build an object file
PlotGrid.cpp.o:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/PlotGrid.cpp.o
.PHONY : PlotGrid.cpp.o
PlotGrid.i: PlotGrid.cpp.i
.PHONY : PlotGrid.i
# target to preprocess a source file
PlotGrid.cpp.i:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/PlotGrid.cpp.i
.PHONY : PlotGrid.cpp.i
PlotGrid.s: PlotGrid.cpp.s
.PHONY : PlotGrid.s
# target to generate assembly for a file
PlotGrid.cpp.s:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/PlotGrid.cpp.s
.PHONY : PlotGrid.cpp.s
PlotWidget.o: PlotWidget.cpp.o
.PHONY : PlotWidget.o
# target to build an object file
PlotWidget.cpp.o:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/PlotWidget.cpp.o
.PHONY : PlotWidget.cpp.o
PlotWidget.i: PlotWidget.cpp.i
.PHONY : PlotWidget.i
# target to preprocess a source file
PlotWidget.cpp.i:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/PlotWidget.cpp.i
.PHONY : PlotWidget.cpp.i
PlotWidget.s: PlotWidget.cpp.s
.PHONY : PlotWidget.s
# target to generate assembly for a file
PlotWidget.cpp.s:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/PlotWidget.cpp.s
.PHONY : PlotWidget.cpp.s
SourceSidebar.o: SourceSidebar.cpp.o
.PHONY : SourceSidebar.o
# target to build an object file
SourceSidebar.cpp.o:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/SourceSidebar.cpp.o
.PHONY : SourceSidebar.cpp.o
SourceSidebar.i: SourceSidebar.cpp.i
.PHONY : SourceSidebar.i
# target to preprocess a source file
SourceSidebar.cpp.i:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/SourceSidebar.cpp.i
.PHONY : SourceSidebar.cpp.i
SourceSidebar.s: SourceSidebar.cpp.s
.PHONY : SourceSidebar.s
# target to generate assembly for a file
SourceSidebar.cpp.s:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/SourceSidebar.cpp.s
.PHONY : SourceSidebar.cpp.s
StatsDialog.o: StatsDialog.cpp.o
.PHONY : StatsDialog.o
# target to build an object file
StatsDialog.cpp.o:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/StatsDialog.cpp.o
.PHONY : StatsDialog.cpp.o
StatsDialog.i: StatsDialog.cpp.i
.PHONY : StatsDialog.i
# target to preprocess a source file
StatsDialog.cpp.i:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/StatsDialog.cpp.i
.PHONY : StatsDialog.cpp.i
StatsDialog.s: StatsDialog.cpp.s
.PHONY : StatsDialog.s
# target to generate assembly for a file
StatsDialog.cpp.s:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/StatsDialog.cpp.s
.PHONY : StatsDialog.cpp.s
StreamHubQtClient_autogen/mocs_compilation.o: StreamHubQtClient_autogen/mocs_compilation.cpp.o
.PHONY : StreamHubQtClient_autogen/mocs_compilation.o
# target to build an object file
StreamHubQtClient_autogen/mocs_compilation.cpp.o:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/StreamHubQtClient_autogen/mocs_compilation.cpp.o
.PHONY : StreamHubQtClient_autogen/mocs_compilation.cpp.o
StreamHubQtClient_autogen/mocs_compilation.i: StreamHubQtClient_autogen/mocs_compilation.cpp.i
.PHONY : StreamHubQtClient_autogen/mocs_compilation.i
# target to preprocess a source file
StreamHubQtClient_autogen/mocs_compilation.cpp.i:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/StreamHubQtClient_autogen/mocs_compilation.cpp.i
.PHONY : StreamHubQtClient_autogen/mocs_compilation.cpp.i
StreamHubQtClient_autogen/mocs_compilation.s: StreamHubQtClient_autogen/mocs_compilation.cpp.s
.PHONY : StreamHubQtClient_autogen/mocs_compilation.s
# target to generate assembly for a file
StreamHubQtClient_autogen/mocs_compilation.cpp.s:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/StreamHubQtClient_autogen/mocs_compilation.cpp.s
.PHONY : StreamHubQtClient_autogen/mocs_compilation.cpp.s
Theme.o: Theme.cpp.o
.PHONY : Theme.o
# target to build an object file
Theme.cpp.o:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/Theme.cpp.o
.PHONY : Theme.cpp.o
Theme.i: Theme.cpp.i
.PHONY : Theme.i
# target to preprocess a source file
Theme.cpp.i:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/Theme.cpp.i
.PHONY : Theme.cpp.i
Theme.s: Theme.cpp.s
.PHONY : Theme.s
# target to generate assembly for a file
Theme.cpp.s:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/Theme.cpp.s
.PHONY : Theme.cpp.s
TriggerBar.o: TriggerBar.cpp.o
.PHONY : TriggerBar.o
# target to build an object file
TriggerBar.cpp.o:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/TriggerBar.cpp.o
.PHONY : TriggerBar.cpp.o
TriggerBar.i: TriggerBar.cpp.i
.PHONY : TriggerBar.i
# target to preprocess a source file
TriggerBar.cpp.i:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/TriggerBar.cpp.i
.PHONY : TriggerBar.cpp.i
TriggerBar.s: TriggerBar.cpp.s
.PHONY : TriggerBar.s
# target to generate assembly for a file
TriggerBar.cpp.s:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/TriggerBar.cpp.s
.PHONY : TriggerBar.cpp.s
WsClient.o: WsClient.cpp.o
.PHONY : WsClient.o
# target to build an object file
WsClient.cpp.o:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/WsClient.cpp.o
.PHONY : WsClient.cpp.o
WsClient.i: WsClient.cpp.i
.PHONY : WsClient.i
# target to preprocess a source file
WsClient.cpp.i:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/WsClient.cpp.i
.PHONY : WsClient.cpp.i
WsClient.s: WsClient.cpp.s
.PHONY : WsClient.s
# target to generate assembly for a file
WsClient.cpp.s:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/WsClient.cpp.s
.PHONY : WsClient.cpp.s
home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.o: home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.o
.PHONY : home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.o
# target to build an object file
home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.o:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.o
.PHONY : home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.o
home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.i: home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.i
.PHONY : home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.i
# target to preprocess a source file
home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.i:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.i
.PHONY : home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.i
home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.s: home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.s
.PHONY : home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.s
# target to generate assembly for a file
home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.s:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.s
.PHONY : home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.cpp.s
main.o: main.cpp.o
.PHONY : main.o
# target to build an object file
main.cpp.o:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/main.cpp.o
.PHONY : main.cpp.o
main.i: main.cpp.i
.PHONY : main.i
# target to preprocess a source file
main.cpp.i:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/main.cpp.i
.PHONY : main.cpp.i
main.s: main.cpp.s
.PHONY : main.s
# target to generate assembly for a file
main.cpp.s:
$(MAKE) $(MAKESILENT) -f CMakeFiles/StreamHubQtClient.dir/build.make CMakeFiles/StreamHubQtClient.dir/main.cpp.s
.PHONY : main.cpp.s
# Help Target
help:
@echo "The following are some of the valid targets for this Makefile:"
@echo "... all (the default if no target is provided)"
@echo "... clean"
@echo "... depend"
@echo "... edit_cache"
@echo "... install"
@echo "... install/local"
@echo "... install/strip"
@echo "... list_install_components"
@echo "... rebuild_cache"
@echo "... StreamHubQtClient_autogen"
@echo "... StreamHubQtClient_autogen_timestamp_deps"
@echo "... StreamHubQtClient"
@echo "... HistoryBar.o"
@echo "... HistoryBar.i"
@echo "... HistoryBar.s"
@echo "... Hub.o"
@echo "... Hub.i"
@echo "... Hub.s"
@echo "... MainWindow.o"
@echo "... MainWindow.i"
@echo "... MainWindow.s"
@echo "... PlotGrid.o"
@echo "... PlotGrid.i"
@echo "... PlotGrid.s"
@echo "... PlotWidget.o"
@echo "... PlotWidget.i"
@echo "... PlotWidget.s"
@echo "... SourceSidebar.o"
@echo "... SourceSidebar.i"
@echo "... SourceSidebar.s"
@echo "... StatsDialog.o"
@echo "... StatsDialog.i"
@echo "... StatsDialog.s"
@echo "... StreamHubQtClient_autogen/mocs_compilation.o"
@echo "... StreamHubQtClient_autogen/mocs_compilation.i"
@echo "... StreamHubQtClient_autogen/mocs_compilation.s"
@echo "... Theme.o"
@echo "... Theme.i"
@echo "... Theme.s"
@echo "... TriggerBar.o"
@echo "... TriggerBar.i"
@echo "... TriggerBar.s"
@echo "... WsClient.o"
@echo "... WsClient.i"
@echo "... WsClient.s"
@echo "... home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.o"
@echo "... home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.i"
@echo "... home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub/Protocol.s"
@echo "... main.o"
@echo "... main.i"
@echo "... main.s"
.PHONY : help
#=============================================================================
# Special targets to cleanup operation of make.
# Special rule to run CMake to check the build system integrity.
# No rule that depends on this can have commands that come from listfiles
# because they might be regenerated.
cmake_check_build_system:
$(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0
.PHONY : cmake_check_build_system
Client/streamhub-qt/build/StreamHubQtClient
Executable
BIN
View File
Binary file not shown.
Client/streamhub-qt/build/StreamHubQtClient_autogen/EWIEGA46WW/moc_HistoryBar.cpp
+126
View File
@@ -0,0 +1,126 @@
/****************************************************************************
** Meta object code from reading C++ file 'HistoryBar.h'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.11.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../../../HistoryBar.h"
#include <QtCore/qmetatype.h>
#include <QtCore/qtmochelpers.h>
#include <memory>
#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'HistoryBar.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN3shq10HistoryBarE_t {};
} // unnamed namespace
template <> constexpr inline auto shq::HistoryBar::qt_create_metaobjectdata<qt_meta_tag_ZN3shq10HistoryBarE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"shq::HistoryBar",
"liveRequested",
"",
"updateReadout",
"showAll"
};
QtMocHelpers::UintData qt_methods {
// Signal 'liveRequested'
QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
// Slot 'updateReadout'
QtMocHelpers::SlotData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
// Slot 'showAll'
QtMocHelpers::SlotData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<HistoryBar, qt_meta_tag_ZN3shq10HistoryBarE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject shq::HistoryBar::staticMetaObject = { {
QMetaObject::SuperData::link<QWidget::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq10HistoryBarE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq10HistoryBarE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3shq10HistoryBarE_t>.metaTypes,
nullptr
} };
void shq::HistoryBar::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<HistoryBar *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->liveRequested(); break;
case 1: _t->updateReadout(); break;
case 2: _t->showAll(); break;
default: ;
}
}
if (_c == QMetaObject::IndexOfMethod) {
if (QtMocHelpers::indexOfMethod<void (HistoryBar::*)()>(_a, &HistoryBar::liveRequested, 0))
return;
}
}
const QMetaObject *shq::HistoryBar::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *shq::HistoryBar::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq10HistoryBarE_t>.strings))
return static_cast<void*>(this);
return QWidget::qt_metacast(_clname);
}
int shq::HistoryBar::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 3)
qt_static_metacall(this, _c, _id, _a);
_id -= 3;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 3)
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
_id -= 3;
}
return _id;
}
// SIGNAL 0
void shq::HistoryBar::liveRequested()
{
QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
QT_WARNING_POP
Client/streamhub-qt/build/StreamHubQtClient_autogen/EWIEGA46WW/moc_Hub.cpp
+261
View File
@@ -0,0 +1,261 @@
/****************************************************************************
** Meta object code from reading C++ file 'Hub.h'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.11.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../../../Hub.h"
#include <QtCore/qmetatype.h>
#include <QtCore/qtmochelpers.h>
#include <memory>
#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'Hub.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN3shq3HubE_t {};
} // unnamed namespace
template <> constexpr inline auto shq::Hub::qt_create_metaobjectdata<qt_meta_tag_ZN3shq3HubE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"shq::Hub",
"connectedChanged",
"",
"connected",
"sourcesChanged",
"configChanged",
"sourceId",
"statsChanged",
"triggerStateChanged",
"captureReceived",
"zoomReceived",
"plotIdx",
"historyZoomReceived",
"historyInfoChanged",
"maxPointsChanged",
"uint32_t",
"n",
"onConnected",
"onText",
"json",
"onBinary",
"data"
};
QtMocHelpers::UintData qt_methods {
// Signal 'connectedChanged'
QtMocHelpers::SignalData<void(bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Bool, 3 },
}}),
// Signal 'sourcesChanged'
QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
// Signal 'configChanged'
QtMocHelpers::SignalData<void(const QString &)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::QString, 6 },
}}),
// Signal 'statsChanged'
QtMocHelpers::SignalData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
// Signal 'triggerStateChanged'
QtMocHelpers::SignalData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
// Signal 'captureReceived'
QtMocHelpers::SignalData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
// Signal 'zoomReceived'
QtMocHelpers::SignalData<void(int)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Int, 11 },
}}),
// Signal 'historyZoomReceived'
QtMocHelpers::SignalData<void(int)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Int, 11 },
}}),
// Signal 'historyInfoChanged'
QtMocHelpers::SignalData<void()>(13, 2, QMC::AccessPublic, QMetaType::Void),
// Signal 'maxPointsChanged'
QtMocHelpers::SignalData<void(uint32_t)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 15, 16 },
}}),
// Slot 'onConnected'
QtMocHelpers::SlotData<void(bool)>(17, 2, QMC::AccessPrivate, QMetaType::Void, {{
{ QMetaType::Bool, 3 },
}}),
// Slot 'onText'
QtMocHelpers::SlotData<void(const QString &)>(18, 2, QMC::AccessPrivate, QMetaType::Void, {{
{ QMetaType::QString, 19 },
}}),
// Slot 'onBinary'
QtMocHelpers::SlotData<void(const QByteArray &)>(20, 2, QMC::AccessPrivate, QMetaType::Void, {{
{ QMetaType::QByteArray, 21 },
}}),
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<Hub, qt_meta_tag_ZN3shq3HubE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject shq::Hub::staticMetaObject = { {
QMetaObject::SuperData::link<QObject::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq3HubE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq3HubE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3shq3HubE_t>.metaTypes,
nullptr
} };
void shq::Hub::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<Hub *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->connectedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
case 1: _t->sourcesChanged(); break;
case 2: _t->configChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
case 3: _t->statsChanged(); break;
case 4: _t->triggerStateChanged(); break;
case 5: _t->captureReceived(); break;
case 6: _t->zoomReceived((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
case 7: _t->historyZoomReceived((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
case 8: _t->historyInfoChanged(); break;
case 9: _t->maxPointsChanged((*reinterpret_cast<std::add_pointer_t<uint32_t>>(_a[1]))); break;
case 10: _t->onConnected((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
case 11: _t->onText((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
case 12: _t->onBinary((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1]))); break;
default: ;
}
}
if (_c == QMetaObject::IndexOfMethod) {
if (QtMocHelpers::indexOfMethod<void (Hub::*)(bool )>(_a, &Hub::connectedChanged, 0))
return;
if (QtMocHelpers::indexOfMethod<void (Hub::*)()>(_a, &Hub::sourcesChanged, 1))
return;
if (QtMocHelpers::indexOfMethod<void (Hub::*)(const QString & )>(_a, &Hub::configChanged, 2))
return;
if (QtMocHelpers::indexOfMethod<void (Hub::*)()>(_a, &Hub::statsChanged, 3))
return;
if (QtMocHelpers::indexOfMethod<void (Hub::*)()>(_a, &Hub::triggerStateChanged, 4))
return;
if (QtMocHelpers::indexOfMethod<void (Hub::*)()>(_a, &Hub::captureReceived, 5))
return;
if (QtMocHelpers::indexOfMethod<void (Hub::*)(int )>(_a, &Hub::zoomReceived, 6))
return;
if (QtMocHelpers::indexOfMethod<void (Hub::*)(int )>(_a, &Hub::historyZoomReceived, 7))
return;
if (QtMocHelpers::indexOfMethod<void (Hub::*)()>(_a, &Hub::historyInfoChanged, 8))
return;
if (QtMocHelpers::indexOfMethod<void (Hub::*)(uint32_t )>(_a, &Hub::maxPointsChanged, 9))
return;
}
}
const QMetaObject *shq::Hub::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *shq::Hub::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq3HubE_t>.strings))
return static_cast<void*>(this);
return QObject::qt_metacast(_clname);
}
int shq::Hub::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 13)
qt_static_metacall(this, _c, _id, _a);
_id -= 13;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 13)
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
_id -= 13;
}
return _id;
}
// SIGNAL 0
void shq::Hub::connectedChanged(bool _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
// SIGNAL 1
void shq::Hub::sourcesChanged()
{
QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}
// SIGNAL 2
void shq::Hub::configChanged(const QString & _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}
// SIGNAL 3
void shq::Hub::statsChanged()
{
QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}
// SIGNAL 4
void shq::Hub::triggerStateChanged()
{
QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}
// SIGNAL 5
void shq::Hub::captureReceived()
{
QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
}
// SIGNAL 6
void shq::Hub::zoomReceived(int _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1);
}
// SIGNAL 7
void shq::Hub::historyZoomReceived(int _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}
// SIGNAL 8
void shq::Hub::historyInfoChanged()
{
QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
}
// SIGNAL 9
void shq::Hub::maxPointsChanged(uint32_t _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}
QT_WARNING_POP
Client/streamhub-qt/build/StreamHubQtClient_autogen/EWIEGA46WW/moc_MainWindow.cpp
+154
View File
@@ -0,0 +1,154 @@
/****************************************************************************
** Meta object code from reading C++ file 'MainWindow.h'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.11.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../../../MainWindow.h"
#include <QtCore/qmetatype.h>
#include <QtCore/qtmochelpers.h>
#include <memory>
#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'MainWindow.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN3shq10MainWindowE_t {};
} // unnamed namespace
template <> constexpr inline auto shq::MainWindow::qt_create_metaobjectdata<qt_meta_tag_ZN3shq10MainWindowE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"shq::MainWindow",
"onConnectedChanged",
"",
"connected",
"onSourcesChanged",
"onConfigChanged",
"sourceId",
"onStatsChanged",
"onTriggerStateChanged",
"onHistoryInfoChanged",
"onTick",
"togglePause",
"toggleHistory",
"openAddSourceDialog",
"doConnect"
};
QtMocHelpers::UintData qt_methods {
// Slot 'onConnectedChanged'
QtMocHelpers::SlotData<void(bool)>(1, 2, QMC::AccessPrivate, QMetaType::Void, {{
{ QMetaType::Bool, 3 },
}}),
// Slot 'onSourcesChanged'
QtMocHelpers::SlotData<void()>(4, 2, QMC::AccessPrivate, QMetaType::Void),
// Slot 'onConfigChanged'
QtMocHelpers::SlotData<void(const QString &)>(5, 2, QMC::AccessPrivate, QMetaType::Void, {{
{ QMetaType::QString, 6 },
}}),
// Slot 'onStatsChanged'
QtMocHelpers::SlotData<void()>(7, 2, QMC::AccessPrivate, QMetaType::Void),
// Slot 'onTriggerStateChanged'
QtMocHelpers::SlotData<void()>(8, 2, QMC::AccessPrivate, QMetaType::Void),
// Slot 'onHistoryInfoChanged'
QtMocHelpers::SlotData<void()>(9, 2, QMC::AccessPrivate, QMetaType::Void),
// Slot 'onTick'
QtMocHelpers::SlotData<void()>(10, 2, QMC::AccessPrivate, QMetaType::Void),
// Slot 'togglePause'
QtMocHelpers::SlotData<void()>(11, 2, QMC::AccessPrivate, QMetaType::Void),
// Slot 'toggleHistory'
QtMocHelpers::SlotData<void()>(12, 2, QMC::AccessPrivate, QMetaType::Void),
// Slot 'openAddSourceDialog'
QtMocHelpers::SlotData<void()>(13, 2, QMC::AccessPrivate, QMetaType::Void),
// Slot 'doConnect'
QtMocHelpers::SlotData<void()>(14, 2, QMC::AccessPrivate, QMetaType::Void),
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<MainWindow, qt_meta_tag_ZN3shq10MainWindowE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject shq::MainWindow::staticMetaObject = { {
QMetaObject::SuperData::link<QMainWindow::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq10MainWindowE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq10MainWindowE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3shq10MainWindowE_t>.metaTypes,
nullptr
} };
void shq::MainWindow::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<MainWindow *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->onConnectedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
case 1: _t->onSourcesChanged(); break;
case 2: _t->onConfigChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
case 3: _t->onStatsChanged(); break;
case 4: _t->onTriggerStateChanged(); break;
case 5: _t->onHistoryInfoChanged(); break;
case 6: _t->onTick(); break;
case 7: _t->togglePause(); break;
case 8: _t->toggleHistory(); break;
case 9: _t->openAddSourceDialog(); break;
case 10: _t->doConnect(); break;
default: ;
}
}
}
const QMetaObject *shq::MainWindow::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *shq::MainWindow::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq10MainWindowE_t>.strings))
return static_cast<void*>(this);
return QMainWindow::qt_metacast(_clname);
}
int shq::MainWindow::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QMainWindow::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 11)
qt_static_metacall(this, _c, _id, _a);
_id -= 11;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 11)
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
_id -= 11;
}
return _id;
}
QT_WARNING_POP
Client/streamhub-qt/build/StreamHubQtClient_autogen/EWIEGA46WW/moc_PlotGrid.cpp
+155
View File
@@ -0,0 +1,155 @@
/****************************************************************************
** Meta object code from reading C++ file 'PlotGrid.h'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.11.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../../../PlotGrid.h"
#include <QtCore/qmetatype.h>
#include <QtCore/qtmochelpers.h>
#include <memory>
#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'PlotGrid.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN3shq8PlotGridE_t {};
} // unnamed namespace
template <> constexpr inline auto shq::PlotGrid::qt_create_metaobjectdata<qt_meta_tag_ZN3shq8PlotGridE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"shq::PlotGrid",
"onModelChanged",
"",
"onPauseChanged",
"tick",
"goLive",
"setAllStoredX",
"t0",
"t1",
"panAll",
"frac",
"jumpAllAgo",
"secAgo",
"anyNonLive",
"currentRange",
"double&"
};
QtMocHelpers::UintData qt_methods {
// Slot 'onModelChanged'
QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
// Slot 'onPauseChanged'
QtMocHelpers::SlotData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
// Slot 'tick'
QtMocHelpers::SlotData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
// Slot 'goLive'
QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
// Slot 'setAllStoredX'
QtMocHelpers::SlotData<void(double, double)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Double, 7 }, { QMetaType::Double, 8 },
}}),
// Slot 'panAll'
QtMocHelpers::SlotData<void(double)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Double, 10 },
}}),
// Slot 'jumpAllAgo'
QtMocHelpers::SlotData<void(double)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Double, 12 },
}}),
// Slot 'anyNonLive'
QtMocHelpers::SlotData<bool() const>(13, 2, QMC::AccessPublic, QMetaType::Bool),
// Slot 'currentRange'
QtMocHelpers::SlotData<bool(double &, double &) const>(14, 2, QMC::AccessPublic, QMetaType::Bool, {{
{ 0x80000000 | 15, 7 }, { 0x80000000 | 15, 8 },
}}),
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<PlotGrid, qt_meta_tag_ZN3shq8PlotGridE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject shq::PlotGrid::staticMetaObject = { {
QMetaObject::SuperData::link<QWidget::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq8PlotGridE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq8PlotGridE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3shq8PlotGridE_t>.metaTypes,
nullptr
} };
void shq::PlotGrid::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<PlotGrid *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->onModelChanged(); break;
case 1: _t->onPauseChanged(); break;
case 2: _t->tick(); break;
case 3: _t->goLive(); break;
case 4: _t->setAllStoredX((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2]))); break;
case 5: _t->panAll((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
case 6: _t->jumpAllAgo((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
case 7: { bool _r = _t->anyNonLive();
if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); } break;
case 8: { bool _r = _t->currentRange((*reinterpret_cast<std::add_pointer_t<double&>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double&>>(_a[2])));
if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); } break;
default: ;
}
}
}
const QMetaObject *shq::PlotGrid::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *shq::PlotGrid::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq8PlotGridE_t>.strings))
return static_cast<void*>(this);
return QWidget::qt_metacast(_clname);
}
int shq::PlotGrid::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 9)
qt_static_metacall(this, _c, _id, _a);
_id -= 9;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 9)
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
_id -= 9;
}
return _id;
}
QT_WARNING_POP
Client/streamhub-qt/build/StreamHubQtClient_autogen/EWIEGA46WW/moc_PlotWidget.cpp
+125
View File
@@ -0,0 +1,125 @@
/****************************************************************************
** Meta object code from reading C++ file 'PlotWidget.h'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.11.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../../../PlotWidget.h"
#include <QtCore/qmetatype.h>
#include <QtCore/qtmochelpers.h>
#include <memory>
#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'PlotWidget.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN3shq10PlotWidgetE_t {};
} // unnamed namespace
template <> constexpr inline auto shq::PlotWidget::qt_create_metaobjectdata<qt_meta_tag_ZN3shq10PlotWidgetE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"shq::PlotWidget",
"onZoomReceived",
"",
"plotIdx",
"onHistoryZoomReceived",
"onCaptureReceived",
"tick"
};
QtMocHelpers::UintData qt_methods {
// Slot 'onZoomReceived'
QtMocHelpers::SlotData<void(int)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Int, 3 },
}}),
// Slot 'onHistoryZoomReceived'
QtMocHelpers::SlotData<void(int)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Int, 3 },
}}),
// Slot 'onCaptureReceived'
QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
// Slot 'tick'
QtMocHelpers::SlotData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<PlotWidget, qt_meta_tag_ZN3shq10PlotWidgetE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject shq::PlotWidget::staticMetaObject = { {
QMetaObject::SuperData::link<QWidget::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq10PlotWidgetE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq10PlotWidgetE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3shq10PlotWidgetE_t>.metaTypes,
nullptr
} };
void shq::PlotWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<PlotWidget *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->onZoomReceived((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
case 1: _t->onHistoryZoomReceived((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
case 2: _t->onCaptureReceived(); break;
case 3: _t->tick(); break;
default: ;
}
}
}
const QMetaObject *shq::PlotWidget::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *shq::PlotWidget::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq10PlotWidgetE_t>.strings))
return static_cast<void*>(this);
return QWidget::qt_metacast(_clname);
}
int shq::PlotWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 4)
qt_static_metacall(this, _c, _id, _a);
_id -= 4;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 4)
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
_id -= 4;
}
return _id;
}
QT_WARNING_POP
Client/streamhub-qt/build/StreamHubQtClient_autogen/EWIEGA46WW/moc_SourceSidebar.cpp
+122
View File
@@ -0,0 +1,122 @@
/****************************************************************************
** Meta object code from reading C++ file 'SourceSidebar.h'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.11.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../../../SourceSidebar.h"
#include <QtCore/qmetatype.h>
#include <QtCore/qtmochelpers.h>
#include <memory>
#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'SourceSidebar.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN3shq13SourceSidebarE_t {};
} // unnamed namespace
template <> constexpr inline auto shq::SourceSidebar::qt_create_metaobjectdata<qt_meta_tag_ZN3shq13SourceSidebarE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"shq::SourceSidebar",
"addSourceRequested",
"",
"refresh"
};
QtMocHelpers::UintData qt_methods {
// Signal 'addSourceRequested'
QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
// Slot 'refresh'
QtMocHelpers::SlotData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<SourceSidebar, qt_meta_tag_ZN3shq13SourceSidebarE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject shq::SourceSidebar::staticMetaObject = { {
QMetaObject::SuperData::link<QWidget::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq13SourceSidebarE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq13SourceSidebarE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3shq13SourceSidebarE_t>.metaTypes,
nullptr
} };
void shq::SourceSidebar::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<SourceSidebar *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->addSourceRequested(); break;
case 1: _t->refresh(); break;
default: ;
}
}
if (_c == QMetaObject::IndexOfMethod) {
if (QtMocHelpers::indexOfMethod<void (SourceSidebar::*)()>(_a, &SourceSidebar::addSourceRequested, 0))
return;
}
}
const QMetaObject *shq::SourceSidebar::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *shq::SourceSidebar::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq13SourceSidebarE_t>.strings))
return static_cast<void*>(this);
return QWidget::qt_metacast(_clname);
}
int shq::SourceSidebar::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 2)
qt_static_metacall(this, _c, _id, _a);
_id -= 2;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 2)
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
_id -= 2;
}
return _id;
}
// SIGNAL 0
void shq::SourceSidebar::addSourceRequested()
{
QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
QT_WARNING_POP
Client/streamhub-qt/build/StreamHubQtClient_autogen/EWIEGA46WW/moc_StatsDialog.cpp
+166
View File
@@ -0,0 +1,166 @@
/****************************************************************************
** Meta object code from reading C++ file 'StatsDialog.h'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.11.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../../../StatsDialog.h"
#include <QtCore/qmetatype.h>
#include <QtCore/qtmochelpers.h>
#include <memory>
#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'StatsDialog.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN3shq15HistogramWidgetE_t {};
} // unnamed namespace
template <> constexpr inline auto shq::HistogramWidget::qt_create_metaobjectdata<qt_meta_tag_ZN3shq15HistogramWidgetE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"shq::HistogramWidget"
};
QtMocHelpers::UintData qt_methods {
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<HistogramWidget, qt_meta_tag_ZN3shq15HistogramWidgetE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject shq::HistogramWidget::staticMetaObject = { {
QMetaObject::SuperData::link<QWidget::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq15HistogramWidgetE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq15HistogramWidgetE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3shq15HistogramWidgetE_t>.metaTypes,
nullptr
} };
void shq::HistogramWidget::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<HistogramWidget *>(_o);
(void)_t;
(void)_c;
(void)_id;
(void)_a;
}
const QMetaObject *shq::HistogramWidget::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *shq::HistogramWidget::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq15HistogramWidgetE_t>.strings))
return static_cast<void*>(this);
return QWidget::qt_metacast(_clname);
}
int shq::HistogramWidget::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
return _id;
}
namespace {
struct qt_meta_tag_ZN3shq11StatsDialogE_t {};
} // unnamed namespace
template <> constexpr inline auto shq::StatsDialog::qt_create_metaobjectdata<qt_meta_tag_ZN3shq11StatsDialogE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"shq::StatsDialog",
"refresh",
""
};
QtMocHelpers::UintData qt_methods {
// Slot 'refresh'
QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<StatsDialog, qt_meta_tag_ZN3shq11StatsDialogE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject shq::StatsDialog::staticMetaObject = { {
QMetaObject::SuperData::link<QDialog::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq11StatsDialogE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq11StatsDialogE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3shq11StatsDialogE_t>.metaTypes,
nullptr
} };
void shq::StatsDialog::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<StatsDialog *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->refresh(); break;
default: ;
}
}
(void)_a;
}
const QMetaObject *shq::StatsDialog::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *shq::StatsDialog::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq11StatsDialogE_t>.strings))
return static_cast<void*>(this);
return QDialog::qt_metacast(_clname);
}
int shq::StatsDialog::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QDialog::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 1)
qt_static_metacall(this, _c, _id, _a);
_id -= 1;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 1)
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
_id -= 1;
}
return _id;
}
QT_WARNING_POP
Client/streamhub-qt/build/StreamHubQtClient_autogen/EWIEGA46WW/moc_TriggerBar.cpp
+113
View File
@@ -0,0 +1,113 @@
/****************************************************************************
** Meta object code from reading C++ file 'TriggerBar.h'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.11.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../../../TriggerBar.h"
#include <QtCore/qmetatype.h>
#include <QtCore/qtmochelpers.h>
#include <memory>
#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'TriggerBar.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN3shq10TriggerBarE_t {};
} // unnamed namespace
template <> constexpr inline auto shq::TriggerBar::qt_create_metaobjectdata<qt_meta_tag_ZN3shq10TriggerBarE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"shq::TriggerBar",
"refreshSignals",
"",
"onTriggerStateChanged"
};
QtMocHelpers::UintData qt_methods {
// Slot 'refreshSignals'
QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
// Slot 'onTriggerStateChanged'
QtMocHelpers::SlotData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<TriggerBar, qt_meta_tag_ZN3shq10TriggerBarE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject shq::TriggerBar::staticMetaObject = { {
QMetaObject::SuperData::link<QWidget::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq10TriggerBarE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq10TriggerBarE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3shq10TriggerBarE_t>.metaTypes,
nullptr
} };
void shq::TriggerBar::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<TriggerBar *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->refreshSignals(); break;
case 1: _t->onTriggerStateChanged(); break;
default: ;
}
}
(void)_a;
}
const QMetaObject *shq::TriggerBar::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *shq::TriggerBar::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq10TriggerBarE_t>.strings))
return static_cast<void*>(this);
return QWidget::qt_metacast(_clname);
}
int shq::TriggerBar::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QWidget::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 2)
qt_static_metacall(this, _c, _id, _a);
_id -= 2;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 2)
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
_id -= 2;
}
return _id;
}
QT_WARNING_POP
Client/streamhub-qt/build/StreamHubQtClient_autogen/EWIEGA46WW/moc_WsClient.cpp
+175
View File
@@ -0,0 +1,175 @@
/****************************************************************************
** Meta object code from reading C++ file 'WsClient.h'
**
** Created by: The Qt Meta Object Compiler version 69 (Qt 6.11.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../../../WsClient.h"
#include <QtCore/qmetatype.h>
#include <QtCore/qtmochelpers.h>
#include <memory>
#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'WsClient.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN3shq8WsClientE_t {};
} // unnamed namespace
template <> constexpr inline auto shq::WsClient::qt_create_metaobjectdata<qt_meta_tag_ZN3shq8WsClientE_t>()
{
namespace QMC = QtMocConstants;
QtMocHelpers::StringRefStorage qt_stringData {
"shq::WsClient",
"connectedChanged",
"",
"connected",
"textReceived",
"json",
"binaryReceived",
"data",
"sendText",
"std::string",
"onConnected",
"onDisconnected",
"onTick"
};
QtMocHelpers::UintData qt_methods {
// Signal 'connectedChanged'
QtMocHelpers::SignalData<void(bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::Bool, 3 },
}}),
// Signal 'textReceived'
QtMocHelpers::SignalData<void(const QString &)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::QString, 5 },
}}),
// Signal 'binaryReceived'
QtMocHelpers::SignalData<void(const QByteArray &)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::QByteArray, 7 },
}}),
// Slot 'sendText'
QtMocHelpers::SlotData<void(const QString &)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
{ QMetaType::QString, 5 },
}}),
// Slot 'sendText'
QtMocHelpers::SlotData<void(const std::string &)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
{ 0x80000000 | 9, 5 },
}}),
// Slot 'onConnected'
QtMocHelpers::SlotData<void()>(10, 2, QMC::AccessPrivate, QMetaType::Void),
// Slot 'onDisconnected'
QtMocHelpers::SlotData<void()>(11, 2, QMC::AccessPrivate, QMetaType::Void),
// Slot 'onTick'
QtMocHelpers::SlotData<void()>(12, 2, QMC::AccessPrivate, QMetaType::Void),
};
QtMocHelpers::UintData qt_properties {
};
QtMocHelpers::UintData qt_enums {
};
return QtMocHelpers::metaObjectData<WsClient, qt_meta_tag_ZN3shq8WsClientE_t>(QMC::MetaObjectFlag{}, qt_stringData,
qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject shq::WsClient::staticMetaObject = { {
QMetaObject::SuperData::link<QObject::staticMetaObject>(),
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq8WsClientE_t>.stringdata,
qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq8WsClientE_t>.data,
qt_static_metacall,
nullptr,
qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3shq8WsClientE_t>.metaTypes,
nullptr
} };
void shq::WsClient::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
auto *_t = static_cast<WsClient *>(_o);
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: _t->connectedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
case 1: _t->textReceived((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
case 2: _t->binaryReceived((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1]))); break;
case 3: _t->sendText((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
case 4: _t->sendText((*reinterpret_cast<std::add_pointer_t<std::string>>(_a[1]))); break;
case 5: _t->onConnected(); break;
case 6: _t->onDisconnected(); break;
case 7: _t->onTick(); break;
default: ;
}
}
if (_c == QMetaObject::IndexOfMethod) {
if (QtMocHelpers::indexOfMethod<void (WsClient::*)(bool )>(_a, &WsClient::connectedChanged, 0))
return;
if (QtMocHelpers::indexOfMethod<void (WsClient::*)(const QString & )>(_a, &WsClient::textReceived, 1))
return;
if (QtMocHelpers::indexOfMethod<void (WsClient::*)(const QByteArray & )>(_a, &WsClient::binaryReceived, 2))
return;
}
}
const QMetaObject *shq::WsClient::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *shq::WsClient::qt_metacast(const char *_clname)
{
if (!_clname) return nullptr;
if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3shq8WsClientE_t>.strings))
return static_cast<void*>(this);
return QObject::qt_metacast(_clname);
}
int shq::WsClient::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QObject::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 8)
qt_static_metacall(this, _c, _id, _a);
_id -= 8;
}
if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 8)
*reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
_id -= 8;
}
return _id;
}
// SIGNAL 0
void shq::WsClient::connectedChanged(bool _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
// SIGNAL 1
void shq::WsClient::textReceived(const QString & _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}
// SIGNAL 2
void shq::WsClient::binaryReceived(const QByteArray & _t1)
{
QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}
QT_WARNING_POP
Client/streamhub-qt/build/StreamHubQtClient_autogen/deps
+1057
View File
File diff suppressed because it is too large Load Diff
Client/streamhub-qt/build/StreamHubQtClient_autogen/moc_predefs.h
+483
View File
@@ -0,0 +1,483 @@
#define __DBL_MIN_EXP__ (-1021)
#define __LDBL_MANT_DIG__ 64
#define __cpp_nontype_template_parameter_auto 201606L
#define __UINT_LEAST16_MAX__ 0xffff
#define __FLT16_HAS_QUIET_NAN__ 1
#define __ATOMIC_ACQUIRE 2
#define __FLT128_MAX_10_EXP__ 4932
#define __FLT_MIN__ 1.17549435082228750796873653722224568e-38F
#define __GCC_IEC_559_COMPLEX 2
#define __cpp_aggregate_nsdmi 201304L
#define __UINT_LEAST8_TYPE__ unsigned char
#define __SIZEOF_FLOAT80__ 16
#define __BFLT16_DENORM_MIN__ 9.18354961579912115600575419704879436e-41BF16
#define __INTMAX_C(c) c ## L
#define __CHAR_BIT__ 8
#define __UINT8_MAX__ 0xff
#define __SCHAR_WIDTH__ 8
#define __WINT_MAX__ 0xffffffffU
#define __FLT32_MIN_EXP__ (-125)
#define __cpp_static_assert 201411L
#define __BFLT16_MIN_10_EXP__ (-37)
#define __cpp_inheriting_constructors 201511L
#define QT_GUI_LIB 1
#define __ORDER_LITTLE_ENDIAN__ 1234
#define __WCHAR_MAX__ 0x7fffffff
#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 1
#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 1
#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 1
#define __GCC_ATOMIC_CHAR_LOCK_FREE 2
#define __GCC_IEC_559 2
#define __FLT32X_DECIMAL_DIG__ 17
#define __FLT_EVAL_METHOD__ 0
#define __cpp_binary_literals 201304L
#define __FLT64_DECIMAL_DIG__ 17
#define __cpp_noexcept_function_type 201510L
#define __GCC_ATOMIC_CHAR32_T_LOCK_FREE 2
#define __cpp_variadic_templates 200704L
#define __UINT_FAST64_MAX__ 0xffffffffffffffffUL
#define __SIG_ATOMIC_TYPE__ int
#define __DBL_MIN_10_EXP__ (-307)
#define __FINITE_MATH_ONLY__ 0
#define __cpp_variable_templates 201304L
#define __FLT32X_MAX_EXP__ 1024
#define __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 1
#define __FLT32_HAS_DENORM__ 1
#define __UINT_FAST8_MAX__ 0xff
#define __cpp_rvalue_reference 200610L
#define __cpp_nested_namespace_definitions 201411L
#define __DEC64_MAX_EXP__ 385
#define __INT8_C(c) c
#define __LDBL_HAS_INFINITY__ 1
#define __INT_LEAST8_WIDTH__ 8
#define __cpp_variadic_using 201611L
#define __UINT_LEAST64_MAX__ 0xffffffffffffffffUL
#define __INT_LEAST8_MAX__ 0x7f
#define __cpp_attributes 200809L
#define __cpp_capture_star_this 201603L
#define __SHRT_MAX__ 0x7fff
#define __LDBL_MAX__ 1.18973149535723176502126385303097021e+4932L
#define __FLT64X_MAX_10_EXP__ 4932
#define __cpp_if_constexpr 201606L
#define __BFLT16_MAX_10_EXP__ 38
#define __BFLT16_MAX_EXP__ 128
#define __LDBL_IS_IEC_60559__ 1
#define QT_NO_DEBUG 1
#define __FLT64X_HAS_QUIET_NAN__ 1
#define __UINT_LEAST8_MAX__ 0xff
#define __GCC_ATOMIC_BOOL_LOCK_FREE 2
#define __FLT128_DENORM_MIN__ 6.47517511943802511092443895822764655e-4966F128
#define __UINTMAX_TYPE__ long unsigned int
#define __cpp_nsdmi 200809L
#define __BFLT16_DECIMAL_DIG__ 4
#define __linux 1
#define __DEC32_EPSILON__ 1E-6DF
#define __FLT_EVAL_METHOD_TS_18661_3__ 0
#define __UINT32_MAX__ 0xffffffffU
#define __GXX_EXPERIMENTAL_CXX0X__ 1
#define __DBL_DENORM_MIN__ double(4.94065645841246544176568792868221372e-324L)
#define __FLT128_MIN_EXP__ (-16381)
#define __DEC64X_MAX_EXP__ 6145
#define __WINT_MIN__ 0U
#define __FLT128_MIN_10_EXP__ (-4931)
#define __FLT32X_IS_IEC_60559__ 1
#define __INT_LEAST16_WIDTH__ 16
#define __SCHAR_MAX__ 0x7f
#define __FLT128_MANT_DIG__ 113
#define __WCHAR_MIN__ (-__WCHAR_MAX__ - 1)
#define __INT64_C(c) c ## L
#define __SSP_STRONG__ 3
#define __GCC_ATOMIC_POINTER_LOCK_FREE 2
#define __ATOMIC_SEQ_CST 5
#define __unix 1
#define __INT_LEAST64_MAX__ 0x7fffffffffffffffL
#define __FLT32X_MANT_DIG__ 53
#define __GCC_ATOMIC_CHAR16_T_LOCK_FREE 2
#define __cpp_aligned_new 201606L
#define __FLT32_MAX_10_EXP__ 38
#define __FLT64X_EPSILON__ 1.08420217248550443400745280086994171e-19F64x
#define __STDC_HOSTED__ 1
#define __DEC64_MIN_EXP__ (-382)
#define __cpp_decltype_auto 201304L
#define __DBL_DIG__ 15
#define __STDC_EMBED_EMPTY__ 2
#define __FLT_EPSILON__ 1.19209289550781250000000000000000000e-7F
#define __GXX_WEAK__ 1
#define __SHRT_WIDTH__ 16
#define __FLT32_IS_IEC_60559__ 1
#define __LDBL_MIN__ 3.36210314311209350626267781732175260e-4932L
#define __DBL_IS_IEC_60559__ 1
#define __DEC32_MAX__ 9.999999E96DF
#define __cpp_threadsafe_static_init 200806L
#define __cpp_enumerator_attributes 201411L
#define __FLT64X_DENORM_MIN__ 3.64519953188247460252840593361941982e-4951F64x
#define __FLT32X_HAS_INFINITY__ 1
#define __unix__ 1
#define __INT_WIDTH__ 32
#define __STDC_IEC_559__ 1
#define __STDC_ISO_10646__ 201706L
#define __DECIMAL_DIG__ 21
#define __STDC_IEC_559_COMPLEX__ 1
#define __gnu_linux__ 1
#define __INT16_MAX__ 0x7fff
#define __FLT64_MIN_EXP__ (-1021)
#define __DEC64X_EPSILON__ 1E-33D64x
#define __FLT64X_MIN_10_EXP__ (-4931)
#define __LDBL_HAS_QUIET_NAN__ 1
#define __FLT16_MIN_EXP__ (-13)
#define __FLT64_MANT_DIG__ 53
#define __FLT64X_MANT_DIG__ 64
#define __BFLT16_DIG__ 2
#define __GNUC__ 16
#define __GXX_RTTI 1
#define __pie__ 2
#define __MMX__ 1
#define __FLT_HAS_DENORM__ 1
#define __SIZEOF_LONG_DOUBLE__ 16
#define __BIGGEST_ALIGNMENT__ 16
#define __STDC_UTF_16__ 1
#define __FLT64_MAX_10_EXP__ 308
#define __BFLT16_IS_IEC_60559__ 0
#define __FLT16_MAX_10_EXP__ 4
#define __cpp_delegating_constructors 200604L
#define __DBL_MAX__ double(1.79769313486231570814527423731704357e+308L)
#define __cpp_raw_strings 200710L
#define __INT_FAST32_MAX__ 0x7fffffffffffffffL
#define __DBL_HAS_INFINITY__ 1
#define __INT64_MAX__ 0x7fffffffffffffffL
#define __SIZEOF_FLOAT__ 4
#define __HAVE_SPECULATION_SAFE_VALUE 1
#define __cpp_fold_expressions 201603L
#define __DEC32_MIN_EXP__ (-94)
#define __INTPTR_WIDTH__ 64
#define __UINT_LEAST32_MAX__ 0xffffffffU
#define __FLT32X_HAS_DENORM__ 1
#define __INT_FAST16_TYPE__ long int
#define __MMX_WITH_SSE__ 1
#define __LDBL_HAS_DENORM__ 1
#define QT_WIDGETS_LIB 1
#define __SEG_GS 1
#define __BFLT16_EPSILON__ 7.81250000000000000000000000000000000e-3BF16
#define __cplusplus 201703L
#define __cpp_ref_qualifiers 200710L
#define __DEC32_MIN__ 1E-95DF
#define __DEPRECATED 1
#define __cpp_rvalue_references 200610L
#define __DBL_MAX_EXP__ 1024
#define __WCHAR_WIDTH__ 32
#define __FLT32_MAX__ 3.40282346638528859811704183484516925e+38F32
#define __DEC128_EPSILON__ 1E-33DL
#define __FLT16_DECIMAL_DIG__ 5
#define __SSE2_MATH__ 1
#define __ATOMIC_HLE_RELEASE 131072
#define __PTRDIFF_MAX__ 0x7fffffffffffffffL
#define __amd64 1
#define __DEC64X_MAX__ 9.999999999999999999999999999999999E6144D64x
#define __ATOMIC_HLE_ACQUIRE 65536
#define __GNUG__ 16
#define __LONG_LONG_MAX__ 0x7fffffffffffffffLL
#define __SIZEOF_SIZE_T__ 8
#define __BFLT16_HAS_INFINITY__ 1
#define __FLT64X_MIN_EXP__ (-16381)
#define __SIZEOF_WINT_T__ 4
#define __FLT32X_DIG__ 15
#define __LONG_LONG_WIDTH__ 64
#define __cpp_initializer_lists 200806L
#define __FLT32_MAX_EXP__ 128
#define ABI_ID "ELF"
#define __cpp_hex_float 201603L
#define __GXX_ABI_VERSION 1021
#define __FLT_MIN_EXP__ (-125)
#define __GCC_HAVE_DWARF2_CFI_ASM 1
#define __x86_64 1
#define __cpp_lambdas 200907L
#define __INT_FAST64_TYPE__ long int
#define __BFLT16_MAX__ 3.38953138925153547590470800371487867e+38BF16
#define __FLT64_DENORM_MIN__ 4.94065645841246544176568792868221372e-324F64
#define __cpp_template_auto 201606L
#define __FLT16_DENORM_MIN__ 5.96046447753906250000000000000000000e-8F16
#define __FLT128_EPSILON__ 1.92592994438723585305597794258492732e-34F128
#define __FLT64X_NORM_MAX__ 1.18973149535723176502126385303097021e+4932F64x
#define __SIZEOF_POINTER__ 8
#define __SIZE_TYPE__ long unsigned int
#define __LP64__ 1
#define __DBL_HAS_QUIET_NAN__ 1
#define __FLT32X_EPSILON__ 2.22044604925031308084726333618164062e-16F32x
#define __LDBL_MAX_EXP__ 16384
#define __DECIMAL_BID_FORMAT__ 1
#define __FLT64_MIN_10_EXP__ (-307)
#define __FLT16_MIN_10_EXP__ (-4)
#define __FLT64X_DECIMAL_DIG__ 21
#define __DEC128_MIN__ 1E-6143DL
#define __REGISTER_PREFIX__
#define __UINT16_MAX__ 0xffff
#define __FLT128_HAS_INFINITY__ 1
#define __FLT32_MIN__ 1.17549435082228750796873653722224568e-38F32
#define __UINT8_TYPE__ unsigned char
#define __FLT_DIG__ 6
#define __NO_INLINE__ 1
#define __DEC_EVAL_METHOD__ 2
#define QT_NO_KEYWORDS 1
#define __FLT_MANT_DIG__ 24
#define __LDBL_DECIMAL_DIG__ 21
#define __VERSION__ "16.2.1 20260810"
#define __UINT64_C(c) c ## UL
#define __cpp_unicode_characters 201411L
#define __DEC64X_MIN__ 1E-6143D64x
#define _STDC_PREDEF_H 1
#define __INT_LEAST32_MAX__ 0x7fffffff
#define __GCC_ATOMIC_INT_LOCK_FREE 2
#define __FLT128_MAX_EXP__ 16384
#define __FLT32_MANT_DIG__ 24
#define __cpp_decltype 200707L
#define __FLOAT_WORD_ORDER__ __ORDER_LITTLE_ENDIAN__
#define SIZEOF_DPTR (sizeof(void*))
#define __FLT32X_MIN_EXP__ (-1021)
#define __cpp_inline_variables 201606L
#define __STDC_IEC_60559_COMPLEX__ 201404L
#define __cpp_aggregate_bases 201603L
#define __BFLT16_MIN__ 1.17549435082228750796873653722224568e-38BF16
#define __FLT128_HAS_DENORM__ 1
#define __FLT32_DECIMAL_DIG__ 9
#define __FLT128_DIG__ 33
#define __INT32_C(c) c
#define __DEC64_EPSILON__ 1E-15DD
#define __ORDER_PDP_ENDIAN__ 3412
#define __DEC128_MIN_EXP__ (-6142)
#define __DEC128_MAX__ 9.999999999999999999999999999999999E6144DL
#define __INT_FAST32_TYPE__ long int
#define __UINT_LEAST16_TYPE__ short unsigned int
#define __DEC64X_MANT_DIG__ 34
#define __DEC128_MAX_EXP__ 6145
#define unix 1
#define __DBL_HAS_DENORM__ 1
#define __cpp_rtti 199711L
#define __UINT64_MAX__ 0xffffffffffffffffUL
#define __FLT_IS_IEC_60559__ 1
#define __GNUC_WIDE_EXECUTION_CHARSET_NAME "UTF-32LE"
#define __FLT64X_DIG__ 18
#define __INT8_TYPE__ signed char
#define __cpp_digit_separators 201309L
#define __ELF__ 1
#define __GCC_ASM_FLAG_OUTPUTS__ 1
#define __UINT32_TYPE__ unsigned int
#define __BFLT16_HAS_QUIET_NAN__ 1
#define __FLT_RADIX__ 2
#define __INT_LEAST16_TYPE__ short int
#define __LDBL_EPSILON__ 1.08420217248550443400745280086994171e-19L
#define __UINTMAX_C(c) c ## UL
#define __FLT16_DIG__ 3
#define __k8 1
#define __FLT32X_MIN__ 2.22507385850720138309023271733240406e-308F32x
#define __SIG_ATOMIC_MAX__ 0x7fffffff
#define __cpp_constexpr 201603L
#define __GCC_ATOMIC_WCHAR_T_LOCK_FREE 2
#define __USER_LABEL_PREFIX__
#define __STDC_IEC_60559_BFP__ 201404L
#define __SIZEOF_PTRDIFF_T__ 8
#define __FLT64X_HAS_INFINITY__ 1
#define __SIZEOF_LONG__ 8
#define __LDBL_DIG__ 18
#define __FLT64_IS_IEC_60559__ 1
#define __x86_64__ 1
#define __FLT16_IS_IEC_60559__ 1
#define __FLT16_MAX_EXP__ 16
#define __DEC32_SUBNORMAL_MIN__ 0.000001E-95DF
#define __STDC_EMBED_FOUND__ 1
#define __INT_FAST16_MAX__ 0x7fffffffffffffffL
#define __GCC_CONSTRUCTIVE_SIZE 64
#define __FLT64_DIG__ 15
#define __UINT_FAST32_MAX__ 0xffffffffffffffffUL
#define __UINT_LEAST64_TYPE__ long unsigned int
#define __FLT16_EPSILON__ 9.76562500000000000000000000000000000e-4F16
#define __FLT_HAS_QUIET_NAN__ 1
#define __FLT_MAX_10_EXP__ 38
#define __FLT64X_HAS_DENORM__ 1
#define __DEC128_SUBNORMAL_MIN__ 0.000000000000000000000000000000001E-6143DL
#define __FLT_HAS_INFINITY__ 1
#define __GNUC_EXECUTION_CHARSET_NAME "UTF-8"
#define __cpp_unicode_literals 200710L
#define __UINT_FAST16_TYPE__ long unsigned int
#define __DEC64_MAX__ 9.999999999999999E384DD
#define __STDC_EMBED_NOT_FOUND__ 0
#define __INT_FAST32_WIDTH__ 64
#define __CHAR16_TYPE__ short unsigned int
#define __PRAGMA_REDEFINE_EXTNAME 1
#define __DEC64X_SUBNORMAL_MIN__ 0.000000000000000000000000000000001E-6143D64x
#define __SIZE_WIDTH__ 64
#define __SEG_FS 1
#define __INT_LEAST16_MAX__ 0x7fff
#define __FLT16_NORM_MAX__ 6.55040000000000000000000000000000000e+4F16
#define __DEC64_MANT_DIG__ 16
#define QT_NETWORK_LIB 1
#define __FLT32_DENORM_MIN__ 1.40129846432481707092372958328991613e-45F32
#define __SIG_ATOMIC_WIDTH__ 32
#define __GCC_DESTRUCTIVE_SIZE 64
#define __INT_LEAST64_TYPE__ long int
#define __INT16_TYPE__ short int
#define __INT_LEAST8_TYPE__ signed char
#define __FLT16_MAX__ 6.55040000000000000000000000000000000e+4F16
#define __FLT128_MIN__ 3.36210314311209350626267781732175260e-4932F128
#define __cpp_structured_bindings 201606L
#define __SIZEOF_INT__ 4
#define __DEC32_MAX_EXP__ 97
#define __INT_FAST8_MAX__ 0x7f
#define __FLT128_MAX__ 1.18973149535723176508575932662800702e+4932F128
#define __INTPTR_MAX__ 0x7fffffffffffffffL
#define __cpp_sized_deallocation 201309L
#define __cpp_guaranteed_copy_elision 201606L
#define linux 1
#define __FLT64_HAS_QUIET_NAN__ 1
#define __FLT32_MIN_10_EXP__ (-37)
#define __EXCEPTIONS 1
#define __UINT16_C(c) c
#define __PTRDIFF_WIDTH__ 64
#define __cpp_range_based_for 201603L
#define __INT_FAST16_WIDTH__ 64
#define __FLT64_HAS_INFINITY__ 1
#define __FLT64X_MAX__ 1.18973149535723176502126385303097021e+4932F64x
#define __FLT16_HAS_INFINITY__ 1
#define __STDCPP_DEFAULT_NEW_ALIGNMENT__ 16
#define __SIG_ATOMIC_MIN__ (-__SIG_ATOMIC_MAX__ - 1)
#define __code_model_small__ 1
#define __GCC_ATOMIC_LONG_LOCK_FREE 2
#define __cpp_nontype_template_args 201411L
#define __DEC32_MANT_DIG__ 7
#define __k8__ 1
#define __INTPTR_TYPE__ long int
#define __UINT16_TYPE__ short unsigned int
#define __WCHAR_TYPE__ int
#define __pic__ 2
#define __UINTPTR_MAX__ 0xffffffffffffffffUL
#define __INT_FAST64_WIDTH__ 64
#define __INT_FAST64_MAX__ 0x7fffffffffffffffL
#define __GCC_ATOMIC_TEST_AND_SET_TRUEVAL 1
#define __FLT_NORM_MAX__ 3.40282346638528859811704183484516925e+38F
#define __FLT32_HAS_INFINITY__ 1
#define __FLT64X_MAX_EXP__ 16384
#define __UINT_FAST64_TYPE__ long unsigned int
#define QT_WEBSOCKETS_LIB 1
#define __BFLT16_MIN_EXP__ (-125)
#define __INT_MAX__ 0x7fffffff
#define __linux__ 1
#define __INT64_TYPE__ long int
#define __FLT_MAX_EXP__ 128
#define __ORDER_BIG_ENDIAN__ 4321
#define __DBL_MANT_DIG__ 53
#define QT_CORE_LIB 1
#define __SIZEOF_FLOAT128__ 16
#define __BFLT16_MANT_DIG__ 8
#define __DEC64_MIN__ 1E-383DD
#define __WINT_TYPE__ unsigned int
#define __UINT_LEAST32_TYPE__ unsigned int
#define __SIZEOF_SHORT__ 2
#define __FLT32_NORM_MAX__ 3.40282346638528859811704183484516925e+38F32
#define __SSE__ 1
#define __LDBL_MIN_EXP__ (-16381)
#define __FLT64_MAX__ 1.79769313486231570814527423731704357e+308F64
#define __DEC64X_MIN_EXP__ (-6142)
#define __amd64__ 1
#define __WINT_WIDTH__ 32
#define __INT_LEAST64_WIDTH__ 64
#define __FLT32X_MAX_10_EXP__ 308
#define __cpp_namespace_attributes 201411L
#define __SIZEOF_INT128__ 16
#define __FLT16_MIN__ 6.10351562500000000000000000000000000e-5F16
#define __FLT64X_IS_IEC_60559__ 1
#define __GXX_CONSTEXPR_ASM__ 1
#define __LDBL_MAX_10_EXP__ 4932
#define __ATOMIC_RELAXED 0
#define __DBL_EPSILON__ double(2.22044604925031308084726333618164062e-16L)
#define __INT_LEAST32_TYPE__ int
#define _LP64 1
#define __UINT8_C(c) c
#define __FLT64_MAX_EXP__ 1024
#define __cpp_return_type_deduction 201304L
#define __SIZEOF_WCHAR_T__ 4
#define __GNUC_PATCHLEVEL__ 1
#define __FLT128_NORM_MAX__ 1.18973149535723176508575932662800702e+4932F128
#define __FLT64_NORM_MAX__ 1.79769313486231570814527423731704357e+308F64
#define __FLT128_HAS_QUIET_NAN__ 1
#define __INTMAX_MAX__ 0x7fffffffffffffffL
#define __INT_FAST8_TYPE__ signed char
#define __FLT64X_MIN__ 3.36210314311209350626267781732175260e-4932F64x
#define __FLT64_EPSILON__ 2.22044604925031308084726333618164062e-16F64
#define __STDCPP_THREADS__ 1
#define __BFLT16_HAS_DENORM__ 1
#define __GNUC_STDC_INLINE__ 1
#define __FLT64_HAS_DENORM__ 1
#define __FLT32_EPSILON__ 1.19209289550781250000000000000000000e-7F32
#define __FLT16_HAS_DENORM__ 1
#define __DBL_DECIMAL_DIG__ 17
#define __STDC_UTF_32__ 1
#define __INT_FAST8_WIDTH__ 8
#define __FXSR__ 1
#define __FLT32X_MAX__ 1.79769313486231570814527423731704357e+308F32x
#define __DBL_NORM_MAX__ double(1.79769313486231570814527423731704357e+308L)
#define __BYTE_ORDER__ __ORDER_LITTLE_ENDIAN__
#define __INTMAX_WIDTH__ 64
#define __cpp_runtime_arrays 198712L
#define __FLT32_DIG__ 6
#define __UINT64_TYPE__ long unsigned int
#define __UINT32_C(c) c ## U
#define ARCHITECTURE_ID "x86_64"
#define __cpp_alias_templates 200704L
#define __FLT_DENORM_MIN__ 1.40129846432481707092372958328991613e-45F
#define __FLT128_IS_IEC_60559__ 1
#define __INT8_MAX__ 0x7f
#define __LONG_WIDTH__ 64
#define __DBL_MIN__ double(2.22507385850720138309023271733240406e-308L)
#define __PIC__ 2
#define __INT32_MAX__ 0x7fffffff
#define __UINT_FAST32_TYPE__ long unsigned int
#define __FLT16_MANT_DIG__ 11
#define __FLT32X_NORM_MAX__ 1.79769313486231570814527423731704357e+308F32x
#define __CHAR32_TYPE__ unsigned int
#define __FLT_MAX__ 3.40282346638528859811704183484516925e+38F
#define __SSE2__ 1
#define __cpp_deduction_guides 201703L
#define __BFLT16_NORM_MAX__ 3.38953138925153547590470800371487867e+38BF16
#define __INT32_TYPE__ int
#define __SIZEOF_DOUBLE__ 8
#define __cpp_exceptions 199711L
#define __FLT_MIN_10_EXP__ (-37)
#define __FLT64_MIN__ 2.22507385850720138309023271733240406e-308F64
#define __INT_LEAST32_WIDTH__ 32
#define __INTMAX_TYPE__ long int
#define __GLIBCXX_BITSIZE_INT_N_0 128
#define __FLT32X_HAS_QUIET_NAN__ 1
#define __ATOMIC_CONSUME 1
#define __GNUC_MINOR__ 2
#define __GLIBCXX_TYPE_INT_N_0 __int128
#define __UINTMAX_MAX__ 0xffffffffffffffffUL
#define __PIE__ 2
#define __FLT32X_DENORM_MIN__ 4.94065645841246544176568792868221372e-324F32x
#define __cpp_template_template_args 201611L
#define __DBL_MAX_10_EXP__ 308
#define __LDBL_DENORM_MIN__ 3.64519953188247460252840593361941982e-4951L
#define __INT16_C(c) c
#define __STDC__ 1
#define __PTRDIFF_TYPE__ long int
#define __LONG_MAX__ 0x7fffffffffffffffL
#define __FLT32X_MIN_10_EXP__ (-307)
#define __UINTPTR_TYPE__ long unsigned int
#define __DEC64_SUBNORMAL_MIN__ 0.000000000000001E-383DD
#define __DEC128_MANT_DIG__ 34
#define __LDBL_MIN_10_EXP__ (-4931)
#define __cpp_generic_lambdas 201304L
#define __SSE_MATH__ 1
#define __SIZEOF_LONG_LONG__ 8
#define __cpp_user_defined_literals 200809L
#define __FLT128_DECIMAL_DIG__ 36
#define __GCC_ATOMIC_LLONG_LOCK_FREE 2
#define __FLT32_HAS_QUIET_NAN__ 1
#define __FLT_DECIMAL_DIG__ 9
#define __UINT_FAST16_MAX__ 0xffffffffffffffffUL
#define __LDBL_NORM_MAX__ 1.18973149535723176502126385303097021e+4932L
#define __GCC_ATOMIC_SHORT_LOCK_FREE 2
#define __SIZE_MAX__ 0xffffffffffffffffUL
#define __UINT_FAST8_TYPE__ unsigned char
#define _GNU_SOURCE 1
#define __cpp_init_captures 201304L
#define __ATOMIC_ACQ_REL 4
#define __ATOMIC_RELEASE 3
Client/streamhub-qt/build/StreamHubQtClient_autogen/mocs_compilation.cpp
+10
View File
@@ -0,0 +1,10 @@
// This file is autogenerated. Changes will be overwritten.
#include "EWIEGA46WW/moc_HistoryBar.cpp"
#include "EWIEGA46WW/moc_Hub.cpp"
#include "EWIEGA46WW/moc_MainWindow.cpp"
#include "EWIEGA46WW/moc_PlotGrid.cpp"
#include "EWIEGA46WW/moc_PlotWidget.cpp"
#include "EWIEGA46WW/moc_SourceSidebar.cpp"
#include "EWIEGA46WW/moc_StatsDialog.cpp"
#include "EWIEGA46WW/moc_TriggerBar.cpp"
#include "EWIEGA46WW/moc_WsClient.cpp"
Client/streamhub-qt/build/StreamHubQtClient_autogen/timestamp
View File
Client/streamhub-qt/build/cmake_install.cmake
+86
View File
@@ -0,0 +1,86 @@
# Install script for directory: /home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt
# Set the install prefix
if(NOT DEFINED CMAKE_INSTALL_PREFIX)
set(CMAKE_INSTALL_PREFIX "/usr/local")
endif()
string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}")
# Set the install configuration name.
if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME)
if(BUILD_TYPE)
string(REGEX REPLACE "^[^A-Za-z0-9_]+" ""
CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}")
else()
set(CMAKE_INSTALL_CONFIG_NAME "")
endif()
message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"")
endif()
# Set the component getting installed.
if(NOT CMAKE_INSTALL_COMPONENT)
if(COMPONENT)
message(STATUS "Install component: \"${COMPONENT}\"")
set(CMAKE_INSTALL_COMPONENT "${COMPONENT}")
else()
set(CMAKE_INSTALL_COMPONENT)
endif()
endif()
# Install shared libraries without execute permission?
if(NOT DEFINED CMAKE_INSTALL_SO_NO_EXE)
set(CMAKE_INSTALL_SO_NO_EXE "0")
endif()
# Is this installation the result of a crosscompile?
if(NOT DEFINED CMAKE_CROSSCOMPILING)
set(CMAKE_CROSSCOMPILING "FALSE")
endif()
# Set path to fallback-tool for dependency-resolution.
if(NOT DEFINED CMAKE_OBJDUMP)
set(CMAKE_OBJDUMP "/usr/bin/objdump")
endif()
if(CMAKE_INSTALL_COMPONENT STREQUAL "Unspecified" OR NOT CMAKE_INSTALL_COMPONENT)
if(EXISTS "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/bin/StreamHubQtClient" AND
NOT IS_SYMLINK "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/bin/StreamHubQtClient")
file(RPATH_CHECK
FILE "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/bin/StreamHubQtClient"
RPATH "")
endif()
file(INSTALL DESTINATION "${CMAKE_INSTALL_PREFIX}/bin" TYPE EXECUTABLE FILES "/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/StreamHubQtClient")
if(EXISTS "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/bin/StreamHubQtClient" AND
NOT IS_SYMLINK "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/bin/StreamHubQtClient")
if(CMAKE_INSTALL_DO_STRIP)
execute_process(COMMAND "/usr/bin/strip" "$ENV{DESTDIR}${CMAKE_INSTALL_PREFIX}/bin/StreamHubQtClient")
endif()
endif()
endif()
if(CMAKE_INSTALL_COMPONENT STREQUAL "Unspecified" OR NOT CMAKE_INSTALL_COMPONENT)
include("/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/CMakeFiles/StreamHubQtClient.dir/install-cxx-module-bmi-noconfig.cmake" OPTIONAL)
endif()
string(REPLACE ";" "\n" CMAKE_INSTALL_MANIFEST_CONTENT
"${CMAKE_INSTALL_MANIFEST_FILES}")
if(CMAKE_INSTALL_LOCAL_ONLY)
file(WRITE "/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/install_local_manifest.txt"
"${CMAKE_INSTALL_MANIFEST_CONTENT}")
endif()
if(CMAKE_INSTALL_COMPONENT)
if(CMAKE_INSTALL_COMPONENT MATCHES "^[a-zA-Z0-9_.+-]+$")
set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INSTALL_COMPONENT}.txt")
else()
string(MD5 CMAKE_INST_COMP_HASH "${CMAKE_INSTALL_COMPONENT}")
set(CMAKE_INSTALL_MANIFEST "install_manifest_${CMAKE_INST_COMP_HASH}.txt")
unset(CMAKE_INST_COMP_HASH)
endif()
else()
set(CMAKE_INSTALL_MANIFEST "install_manifest.txt")
endif()
if(NOT CMAKE_INSTALL_LOCAL_ONLY)
file(WRITE "/home/martino/Projects/marte2_projects/MARTe_Integrated_components/Client/streamhub-qt/build/${CMAKE_INSTALL_MANIFEST}"
"${CMAKE_INSTALL_MANIFEST_CONTENT}")
endif()
Client/streamhub-qt/main.cpp
+36
View File
@@ -0,0 +1,36 @@
/**
* @file main.cpp
* @brief Entry point for the Qt StreamHub oscilloscope client.
*
* Usage: StreamHubQtClient [-host HOST] [-port PORT]
* Defaults: host 127.0.0.1, port 8090.
*/
#include "MainWindow.h"
#include "Theme.h"
#include <QApplication>
#include <QCommandLineParser>
int main(int argc, char** argv) {
QApplication app(argc, argv);
app.setApplicationName("StreamHubQtClient");
QCommandLineParser parser;
parser.setApplicationDescription("StreamHub oscilloscope client (Qt)");
parser.addHelpOption();
QCommandLineOption hostOpt({"H", "host"}, "Hub host", "host", "127.0.0.1");
QCommandLineOption portOpt({"p", "port"}, "Hub WS port", "port", "8090");
parser.addOption(hostOpt);
parser.addOption(portOpt);
parser.process(app);
const QString host = parser.value(hostOpt);
const uint16_t port = static_cast<uint16_t>(parser.value(portOpt).toUInt());
shq::applyTheme(app);
shq::MainWindow win(host, port ? port : 8090);
win.show();
return app.exec();
}
Client/streamhub/App.cpp
+324 -111
View File
@@ -75,9 +75,21 @@ void App::update() {
if (nowConnected && !prevConnected_) {
ws_.sendText(BuildGetSources());
ws_.sendText(BuildGetStats());
ws_.sendText(BuildHistoryInfo());
}
prevConnected_ = nowConnected;
/* Re-request history info periodically until signals are populated
* (the hub opens history files after the first data packet, which is
* after our initial connect-time query). */
if (nowConnected && historyInfo_.enabled && historyInfo_.signals.empty()) {
double now = ImGui::GetTime();
if (now - lastHistInfoReq_ > 2.0) {
ws_.sendText(BuildHistoryInfo());
lastHistInfoReq_ = now;
}
}
/* Drain WebSocket receive queue */
ws_.poll([this](const WSMessage& msg) {
if (msg.isBinary) {
@@ -99,8 +111,7 @@ void App::update() {
| ImGuiWindowFlags_NoResize
| ImGuiWindowFlags_NoMove
| ImGuiWindowFlags_NoBringToFrontOnFocus
| ImGuiWindowFlags_NoNavFocus
| ImGuiWindowFlags_MenuBar;
| ImGuiWindowFlags_NoNavFocus;
ImGui::PushStyleVar(ImGuiStyleVar_WindowRounding, 0.0f);
ImGui::PushStyleVar(ImGuiStyleVar_WindowBorderSize, 0.0f);
@@ -108,8 +119,8 @@ void App::update() {
ImGui::Begin("##main", nullptr, wf);
ImGui::PopStyleVar(3);
renderMenuBar();
renderToolbar();
if (showHistBar_) { renderHistoryBar(); }
if (showTrigBar_) { renderTriggerBar(); }
/* Horizontal split: sidebar | plot grid */
@@ -136,90 +147,33 @@ void App::update() {
if (showAddSrc_) { renderAddSourceModal(); }
}
/* ── Menu bar ────────────────────────────────────────────────────────────── */
void App::renderMenuBar() {
if (!ImGui::BeginMenuBar()) { return; }
if (ImGui::BeginMenu("File")) {
if (ImGui::MenuItem("Quit", "Alt+F4")) {
/* Signal quit via SDL event — handled in main.cpp via flag */
}
ImGui::EndMenu();
}
if (ImGui::BeginMenu("View")) {
ImGui::MenuItem("Sidebar", nullptr, &sidebarOpen_);
ImGui::MenuItem("Trigger Bar", nullptr, &showTrigBar_);
ImGui::MenuItem("Statistics", nullptr, &showStats_);
ImGui::EndMenu();
}
if (ImGui::BeginMenu("Sources")) {
if (ImGui::MenuItem(ICON_FA_PLUS " Add Source...")) { showAddSrc_ = true; }
ImGui::EndMenu();
}
if (ImGui::BeginMenu("Layout")) {
for (int i = 0; i < static_cast<int>(PlotLayout::kCount); i++) {
bool sel = (static_cast<int>(layout_) == i);
if (ImGui::MenuItem(PlotLayoutNames[i], nullptr, sel)) {
setLayout(static_cast<PlotLayout>(i));
}
}
ImGui::EndMenu();
}
/* Right-aligned: [host] : [port] [Connect/Reconnect] ● status */
bool connected = ws_.isConnected();
const char* btnLbl = connected ? "Reconnect" : "Connect";
const char* ledLbl = connected ? ICON_FA_CIRCLE " Connected"
: ICON_FA_CIRCLE " Disconnected";
/* Measure widget widths to right-align the whole group */
const ImGuiStyle& st = ImGui::GetStyle();
const float kHostW = 130.f;
const float kPortW = 52.f;
const float kBtnW = ImGui::CalcTextSize(btnLbl).x + st.FramePadding.x * 2.f;
const float kLedW = ImGui::CalcTextSize(ledLbl).x;
const float kGroupW = kHostW + 8.f + kPortW + 8.f + kBtnW + 8.f + kLedW;
ImGui::SetCursorPosX(
ImGui::GetCursorPosX() +
ImGui::GetContentRegionAvail().x - kGroupW);
ImGui::SetNextItemWidth(kHostW);
ImGui::InputText("##hubhost", hostBuf_, sizeof(hostBuf_));
ImGui::SameLine(0.f, 2.f);
ImGui::TextUnformatted(":");
ImGui::SameLine(0.f, 2.f);
ImGui::SetNextItemWidth(kPortW);
ImGui::InputText("##hubport", portBuf_, sizeof(portBuf_),
ImGuiInputTextFlags_CharsDecimal);
ImGui::SameLine(0.f, 6.f);
if (ImGui::Button(btnLbl)) {
ws_.reconnect(hostBuf_, static_cast<uint16_t>(atoi(portBuf_)));
}
ImGui::SameLine(0.f, 8.f);
ImVec4 ledColor = connected
? ImVec4(0.1f, 0.9f, 0.3f, 1.f)
: ImVec4(0.9f, 0.2f, 0.2f, 1.f);
ImGui::TextColored(ledColor, "%s", ledLbl);
ImGui::EndMenuBar();
}
/* renderMenuBar() removed — all functionality merged into toolbar + sidebar */
/* ── Toolbar ─────────────────────────────────────────────────────────────── */
void App::renderToolbar() {
ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(4.f, 4.f));
/* Layout picker — pictogram popup */
/* ── Sidebar toggle (leftmost) ───────────────────────────────────────── */
{
if (sidebarOpen_) {
ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.537f,0.706f,0.980f,0.4f));
}
if (ImGui::Button(ICON_FA_BARS "##sidebar")) { sidebarOpen_ = !sidebarOpen_; }
if (sidebarOpen_) { ImGui::PopStyleColor(); }
if (ImGui::IsItemHovered()) { ImGui::SetTooltip("Toggle sidebar"); }
}
ImGui::SameLine();
/* ── Layout picker — pictogram popup ─────────────────────────────────── */
static const int kIconCols[] = {1,2,1,3,1,2,4,1};
static const int kIconRows[] = {1,1,2,1,3,2,1,4};
static const ImVec2 kIconSz = ImVec2(36.f, 24.f);
if (ImGui::Button(ICON_FA_TABLE_CELLS_LARGE " Layout")) {
if (ImGui::Button(ICON_FA_TABLE_CELLS_LARGE "##layout")) {
ImGui::OpenPopup("##layout_pop");
}
if (ImGui::IsItemHovered()) { ImGui::SetTooltip("Layout"); }
ImGui::SameLine();
if (ImGui::BeginPopup("##layout_pop")) {
ImGui::TextDisabled("Select layout");
@@ -228,7 +182,6 @@ void App::renderToolbar() {
for (int li = 0; li < static_cast<int>(PlotLayout::kCount); li++) {
bool sel = (static_cast<int>(layout_) == li);
ImVec2 p = ImGui::GetCursorScreenPos();
/* Invisible button sized to the icon */
if (ImGui::InvisibleButton(PlotLayoutNames[li], kIconSz)) {
setLayout(static_cast<PlotLayout>(li));
ImGui::CloseCurrentPopup();
@@ -242,7 +195,7 @@ void App::renderToolbar() {
ImGui::EndPopup();
}
/* Global pause */
/* ── Global pause ────────────────────────────────────────────────────── */
if (ImGui::Button(globalPaused_ ? ICON_FA_PLAY " Resume"
: ICON_FA_PAUSE " Pause")) {
globalPaused_ = !globalPaused_;
@@ -253,45 +206,77 @@ void App::renderToolbar() {
}
ImGui::SameLine();
/* Cursors A/B (global: shared & synchronised across all plots) */
/* ── Cursors A/B toggle ──────────────────────────────────────────────── */
{
if (cursorsOn_) {
ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.537f,0.706f,0.980f,0.4f));
}
if (ImGui::Button(ICON_FA_CROSSHAIRS " Cursors")) {
cursorsOn_ = !cursorsOn_;
if (cursorsOn_) {
/* seed cursors at 25% / 75% of the live window */
const double wallNow = std::chrono::duration<double>(
std::chrono::system_clock::now().time_since_epoch()).count();
const double x0 = wallNow - windowSec_;
cursorA_ = x0 + windowSec_ * 0.25;
cursorB_ = x0 + windowSec_ * 0.75;
}
}
if (ImGui::Button(ICON_FA_CROSSHAIRS "##curs")) { cursorsOn_ = !cursorsOn_; }
if (cursorsOn_) { ImGui::PopStyleColor(); }
if (ImGui::IsItemHovered()) { ImGui::SetTooltip("Cursors A/B"); }
}
ImGui::SameLine();
/* Trigger bar toggle */
if (ImGui::Button(ICON_FA_BOLT " Trigger")) { showTrigBar_ = !showTrigBar_; }
/* ── Trigger bar toggle ──────────────────────────────────────────────── */
{
if (showTrigBar_) {
ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.537f,0.706f,0.980f,0.4f));
}
if (ImGui::Button(ICON_FA_BOLT "##trig")) { showTrigBar_ = !showTrigBar_; }
if (showTrigBar_) { ImGui::PopStyleColor(); }
if (ImGui::IsItemHovered()) { ImGui::SetTooltip("Trigger"); }
}
ImGui::SameLine();
/* Stats */
if (ImGui::Button(ICON_FA_CHART_COLUMN " Stats")) { showStats_ = !showStats_; }
/* ── History browse ──────────────────────────────────────────────────── */
{
bool histAvail = historyInfo_.enabled && !historyInfo_.signals.empty();
if (!histAvail) { ImGui::BeginDisabled(); }
if (showHistBar_) {
ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.537f,0.706f,0.980f,0.4f));
}
if (ImGui::Button(ICON_FA_CLOCK_ROTATE_LEFT "##hist")) {
if (histAvail) {
showHistBar_ = !showHistBar_;
if (showHistBar_) {
/* On first open, jump to the full history range */
double ht0 = 1e300, ht1 = -1e300;
for (const auto& hs : historyInfo_.signals) {
if (hs.t0 < ht0) ht0 = hs.t0;
if (hs.t1 > ht1) ht1 = hs.t1;
}
if (ht1 > ht0) {
for (int i = 0; i < numPlotSlots(); i++) {
liveFollow_[i] = false;
setPlotX(i, ht0, ht1);
zoomCache_[i].valid = false;
zoomCache_[i].pending = false;
histZoomCache_[i].valid = false;
histZoomCache_[i].pending = false;
zoomHist_[i].clear();
}
}
} else {
/* Closing the bar → back to live */
for (int i = 0; i < numPlotSlots(); i++) {
liveFollow_[i] = true;
}
}
}
}
if (showHistBar_) { ImGui::PopStyleColor(); }
if (!histAvail) { ImGui::EndDisabled(); }
if (ImGui::IsItemHovered()) { ImGui::SetTooltip("History browse"); }
}
ImGui::SameLine();
/* Add source */
if (ImGui::Button(ICON_FA_PLUS " Source")) { showAddSrc_ = true; }
ImGui::SameLine();
/* Time window presets (Ctrl+scroll on a plot still adjusts freely) */
/* ── Time window presets ─────────────────────────────────────────────── */
static const double kWinPresets[] = {1.0, 5.0, 10.0, 30.0, 60.0};
static const char* kWinLabels[] = {"1 s", "5 s", "10 s", "30 s", "60 s"};
char winPreview[16];
snprintf(winPreview, sizeof(winPreview), "%.3g s", windowSec_);
ImGui::SetNextItemWidth(70.f);
if (ImGui::BeginCombo("Win", winPreview)) {
if (ImGui::BeginCombo("##win", winPreview)) {
for (int wi = 0; wi < 5; wi++) {
bool sel = std::fabs(windowSec_ - kWinPresets[wi]) < 1e-9;
if (ImGui::Selectable(kWinLabels[wi], sel)) {
@@ -301,18 +286,213 @@ void App::renderToolbar() {
}
ImGui::EndCombo();
}
/* ── Right-aligned group: [Stats] [Connection ▼] ● LED ──────────────── */
bool connected = ws_.isConnected();
const char* connLabel = connected
? ICON_FA_CIRCLE " Connected"
: ICON_FA_CIRCLE " Disconnected";
const ImGuiStyle& st = ImGui::GetStyle();
const float kStatsW = ImGui::CalcTextSize(ICON_FA_CHART_COLUMN).x
+ st.FramePadding.x * 2.f;
const float kConnBtnW = ImGui::CalcTextSize(ICON_FA_LINK).x
+ st.FramePadding.x * 2.f;
const float kLedW = ImGui::CalcTextSize(connLabel).x + 8.f;
const float kGroupW = kStatsW + 4.f + kConnBtnW + 4.f + kLedW;
float rightX = ImGui::GetCursorPosX() +
ImGui::GetContentRegionAvail().x - kGroupW;
if (rightX > ImGui::GetCursorPosX()) {
ImGui::SameLine(rightX);
} else {
ImGui::SameLine();
}
/* Stats toggle */
{
if (showStats_) {
ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.537f,0.706f,0.980f,0.4f));
}
if (ImGui::Button(ICON_FA_CHART_COLUMN "##stats")) { showStats_ = !showStats_; }
if (showStats_) { ImGui::PopStyleColor(); }
if (ImGui::IsItemHovered()) { ImGui::SetTooltip("Statistics"); }
}
ImGui::SameLine(0.f, 4.f);
/* Connection dropdown */
if (ImGui::Button(ICON_FA_LINK "##conn")) {
ImGui::OpenPopup("##conn_pop");
}
if (ImGui::IsItemHovered()) { ImGui::SetTooltip("Connection"); }
if (ImGui::BeginPopup("##conn_pop")) {
ImGui::TextDisabled("Hub Connection");
ImGui::Separator();
ImGui::SetNextItemWidth(160.f);
ImGui::InputText("Host##hubhost", hostBuf_, sizeof(hostBuf_));
ImGui::SetNextItemWidth(80.f);
ImGui::InputText("Port##hubport", portBuf_, sizeof(portBuf_),
ImGuiInputTextFlags_CharsDecimal);
ImGui::Spacing();
const char* btnLbl = connected ? "Reconnect" : "Connect";
if (ImGui::Button(btnLbl, ImVec2(120.f, 0.f))) {
ws_.reconnect(hostBuf_, static_cast<uint16_t>(atoi(portBuf_)));
ImGui::CloseCurrentPopup();
}
ImGui::EndPopup();
}
ImGui::SameLine(0.f, 4.f);
/* Status LED */
ImVec4 ledColor = connected
? ImVec4(0.1f, 0.9f, 0.3f, 1.f)
: ImVec4(0.9f, 0.2f, 0.2f, 1.f);
ImGui::TextColored(ledColor, "%s", connLabel);
ImGui::PopStyleVar();
ImGui::Separator();
}
/* ── History browsing toolbar ────────────────────────────────────────────── */
void App::renderHistoryBar() {
ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(4.f, 4.f));
ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.980f,0.702f,0.529f,1.f));
/* Title */
ImGui::TextUnformatted(ICON_FA_CLOCK_ROTATE_LEFT " History");
ImGui::PopStyleColor();
ImGui::SameLine();
/* Max points control */
ImGui::SetNextItemWidth(80.f);
int mp = static_cast<int>(maxPoints_);
if (ImGui::InputInt("MaxPts", &mp, 0, 0,
ImGuiInputTextFlags_EnterReturnsTrue)) {
if (mp >= 2) {
maxPoints_ = static_cast<uint32_t>(mp);
ws_.sendText(BuildSetMaxPoints(maxPoints_));
/* ── Live button ── */
if (ImGui::SmallButton(ICON_FA_TOWER_BROADCAST " Live")) {
showHistBar_ = false;
for (int i = 0; i < numPlotSlots(); i++) {
liveFollow_[i] = true;
}
ImGui::PopStyleVar();
return;
}
ImGui::SameLine();
ImGui::TextDisabled("|"); ImGui::SameLine();
/* ── Current time range display ── */
double t0 = 0.0, t1 = 0.0;
bool haveRange = false;
for (int i = 0; i < numPlotSlots(); i++) {
if (!liveFollow_[i]) {
t0 = plotXMin_[i]; t1 = plotXMax_[i];
haveRange = true;
break;
}
}
const double wallNow = std::chrono::duration<double>(
std::chrono::system_clock::now().time_since_epoch()).count();
if (haveRange) {
double span = t1 - t0;
double ago = wallNow - t1;
char rangeLabel[128];
if (ago < 1.0) {
snprintf(rangeLabel, sizeof(rangeLabel),
"%.3g s span | now", span);
} else if (ago < 60.0) {
snprintf(rangeLabel, sizeof(rangeLabel),
"%.3g s span | %.0f s ago", span, ago);
} else if (ago < 3600.0) {
snprintf(rangeLabel, sizeof(rangeLabel),
"%.3g s span | %.1f min ago", span, ago / 60.0);
} else {
snprintf(rangeLabel, sizeof(rangeLabel),
"%.3g s span | %.1f h ago", span, ago / 3600.0);
}
ImGui::TextDisabled("%s", rangeLabel);
} else {
ImGui::TextDisabled("No plot range");
}
ImGui::SameLine();
/* ── Navigation: pan ← → ── */
if (ImGui::SmallButton(ICON_FA_CHEVRON_LEFT "##hleft")) {
for (int i = 0; i < numPlotSlots(); i++) {
if (!liveFollow_[i]) {
double span = plotXMax_[i] - plotXMin_[i];
setPlotX(i, plotXMin_[i] - span * 0.75, plotXMax_[i] - span * 0.75);
}
}
}
if (ImGui::IsItemHovered()) { ImGui::SetTooltip("Pan left (75%% of window)"); }
ImGui::SameLine(0.f, 2.f);
if (ImGui::SmallButton(ICON_FA_CHEVRON_RIGHT "##hright")) {
for (int i = 0; i < numPlotSlots(); i++) {
if (!liveFollow_[i]) {
double span = plotXMax_[i] - plotXMin_[i];
double newMax = plotXMax_[i] + span * 0.75;
/* Clamp: don't go past wallNow */
if (newMax > wallNow) {
newMax = wallNow;
double newMin = newMax - span;
setPlotX(i, newMin, newMax);
} else {
setPlotX(i, plotXMin_[i] + span * 0.75, newMax);
}
}
}
}
if (ImGui::IsItemHovered()) { ImGui::SetTooltip("Pan right (75%% of window)"); }
ImGui::SameLine();
ImGui::TextDisabled("|"); ImGui::SameLine();
/* ── Jump presets ── */
static const double kJumpSec[] = { 10.0, 30.0, 60.0,
300.0, 600.0, 1800.0, 3600.0};
static const char* kJumpLabel[] = {"10 s", "30 s", "1 min",
"5 min","10 min","30 min","1 h"};
for (int j = 0; j < 7; j++) {
char jid[32];
snprintf(jid, sizeof(jid), "%s##hj%d", kJumpLabel[j], j);
if (ImGui::SmallButton(jid)) {
for (int i = 0; i < numPlotSlots(); i++) {
liveFollow_[i] = false;
double span = plotXMax_[i] - plotXMin_[i];
if (span <= 0.0) { span = windowSec_; }
setPlotX(i, wallNow - kJumpSec[j] - span,
wallNow - kJumpSec[j]);
}
}
if (ImGui::IsItemHovered()) {
ImGui::SetTooltip("Jump to %s ago", kJumpLabel[j]);
}
if (j < 6) { ImGui::SameLine(0.f, 2.f); }
}
ImGui::SameLine();
/* ── All history ── */
bool canAll = historyInfo_.enabled && !historyInfo_.signals.empty();
if (!canAll) { ImGui::BeginDisabled(); }
if (ImGui::SmallButton("All")) {
double ht0 = 1e300, ht1 = -1e300;
for (const auto& hs : historyInfo_.signals) {
if (hs.t0 < ht0) ht0 = hs.t0;
if (hs.t1 > ht1) ht1 = hs.t1;
}
if (ht1 > ht0) {
for (int i = 0; i < numPlotSlots(); i++) {
liveFollow_[i] = false;
setPlotX(i, ht0, ht1);
zoomCache_[i].valid = false;
zoomCache_[i].pending = false;
histZoomCache_[i].valid = false;
histZoomCache_[i].pending = false;
zoomHist_[i].clear();
}
}
}
if (ImGui::IsItemHovered()) { ImGui::SetTooltip("Show all available history"); }
if (!canAll) { ImGui::EndDisabled(); }
ImGui::PopStyleVar();
ImGui::Separator();
@@ -521,6 +701,7 @@ void App::handleBinary(const uint8_t* data, size_t len) {
trigger_.status = "triggered";
trigger_.trigTime = capture_.trigTime;
trigger_.hasTrigTime = true;
resetTrigZoom();
}
return;
}
@@ -644,11 +825,17 @@ void App::onTriggerState(const std::string& json) {
trigger_.trigTime = msg.trigTime;
trigger_.hasTrigTime = true;
}
if (msg.hasWindow) {
trigger_.firedPreS = msg.preSec;
trigger_.firedPostS = msg.postSec;
trigger_.hasFiredWin = true;
}
/* Double-buffer semantics: the last recorded capture stays on display
* (even while re-armed/collecting) and is only replaced when a new
* capture frame has been fully received and parsed (handleBinary v2). */
if (msg.state == "idle") {
trigger_.hasTrigTime = false;
trigger_.hasFiredWin = false;
}
}
@@ -660,10 +847,24 @@ void App::onZoom(const std::string& json) {
for (int i = 0; i < kMaxPlotSlots; i++) {
auto& zc = zoomCache_[i];
if (zc.pending && zc.reqId == resp.reqId) {
/* Compute the actual time range from the returned data so the
* coverage check in PlotPanel can distinguish between "ring had
* data for the full window" and "ring only had partial data". */
double dataT0 = 1e300, dataT1 = -1e300;
bool anyData = false;
for (const auto& zs : resp.signals) {
for (double tv : zs.t) {
if (tv < dataT0) { dataT0 = tv; }
if (tv > dataT1) { dataT1 = tv; }
anyData = true;
}
}
if (anyData) {
zc.signals = std::move(resp.signals);
zc.t0 = zc.reqT0;
zc.t1 = zc.reqT1;
zc.t0 = dataT0;
zc.t1 = dataT1;
zc.valid = true;
}
zc.pending = false;
return;
}
@@ -717,10 +918,22 @@ void App::onHistoryZoom(const std::string& json) {
for (int i = 0; i < kMaxPlotSlots; i++) {
auto& hc = histZoomCache_[i];
if (hc.pending && hc.reqId == resp.reqId) {
/* Compute the actual time range from returned data. */
double dataT0 = 1e300, dataT1 = -1e300;
bool anyData = false;
for (const auto& zs : resp.signals) {
for (double tv : zs.t) {
if (tv < dataT0) { dataT0 = tv; }
if (tv > dataT1) { dataT1 = tv; }
anyData = true;
}
}
if (anyData) {
hc.signals = std::move(resp.signals);
hc.t0 = hc.reqT0;
hc.t1 = hc.reqT1;
hc.t0 = dataT0;
hc.t1 = dataT1;
hc.valid = true;
}
hc.pending = false;
return;
}

Some files were not shown because too many files have changed in this diff Show More