| Age | Commit message (Collapse) | Author |
|---|
|
This is needed for QML integration. Closes #155.
|
|
Causes a cache version upgrade; the old cache stores the state in an
incorrect place that won't be supported. Closes #159.
|
|
|
|
Read marker auto-promotion may be bound to a dataChanged() signal in the
client model, while a routine connection for addedMessages() is
endInsertRows(). Emitting endInsertRows() after dataChanged() over the
same rows has unpredictable consequences for representation of data in
those rows - hence the fix.
|
|
|
|
|
|
|
|
Closes #151.
|
|
This code is useful for all clients, and extensions to pretty-printing
can be later added either via making prettyPrint() virtual or even by
providing a registry of additional "text transformers" or even "event
content renderers" applied to visualise the event.
|
|
|
|
|
|
working
The sequence is: RoomMessagesJob::success -> addHistoricalMessageEvents
-> MessageEventModel notification -> QML notification about model reset
-> MessageEventModel completes updating -> QML updates from the model
but by then scrolling has already stopped at the oldest (just loaded)
event -> since there's no momentum, next batch is not fetched. In order
to address this, two things are done: in QML, the current position is
checked in modelReset() handler; in Room (this commit), prev_batch is
updated before historical messages are added (and the model gets
notified, respectively), to prevent firing another job with the old
prev_batch.
|
|
Particularly in case when there are two events that have an image with
the same file name (image.png).
|
|
Making a structure from an initializer list seems to be a problem for it if initializers are defined in the structure.
|
|
Closes #121; closes #122.
|
|
placeholder
An unqualified bind() seems to upset some build environments; also, use a User* value at hand instead of binding it at the moment of signal-slot triggering.
|
|
std::bind belongs to <functional>, don't rely on implicitly including it from other standard headers.
|
|
and User
The switch is necessary because MediaThumbnailJob is supposed to return something that can be worked on in non-GUI threads (as is the case of QML image providers), and QPixmap is not supposed for usage out of the main thread.
|
|
This will provide some backwards-compatibility to clients that are not ready to move _their_ code to C++14 (at least, it will allow them to not add C++14 requirement to their makefiles as of yet).
|
|
Also a bit of code tightening with some C++14 (but not only) things.
|
|
|
|
|
|
|
|
This causes the following changes along the way:
- Owning<> template is decommissioned.
- event.h has been rearranged, and Event/RoomEvent::fromJson static methods have been replaced with an external makeEvent<> function template. A side effect of that is that one cannot use a factory with a type other than the one it's defined for (i.e. you cannot call makeEvent<TypingEvent>) but that feature has been out of use for long anyway.
- Room::doAddNewMessageEvents() and Room::doAddHistoricalMessageEvents() have been removed, giving place to Room::onAddNewTimelineEvents() and Room::onAddHistoricalTimelineEvents(). The most important difference is that all code that must be executed now resides in addNewMessageEvents() (it moved from Room to Room::Private) and classes inheriting from Room are not obliged to call the overridden function from the overriding function (they can do it but those functions have empty bodies in Room). This was a long overdue change, and owning pointers simply mandated it. Room::onAddNewTimelineEvents/onAddHistoricalTimelineEvents should not do anything with the passed range in terms of ownership, it's just a way to allow the derived class to update his data in due course.
- Room::Private::dropDuplicateEvents() and Room::Private::insertEvents(), notably, have been updated to work with owning pointers. insertEvents() move()s pointers to the timeline, while dropDuplicateEvents uses remove_if instead of stable_partition and doesn't explicitly delete event objects.
Also, a bugfix: Event accidentally had not virtual destructor for quite a long time. According to the standard, deleting an object through a pointer to a base class without a virtual destructor leads to UB. So the fact that libqmatrixclient clients even worked all these months is mere coincidence and compiler authors good will :-D
|
|
|
|
|
|
Closes #130.
|
|
The Spec doesn't mention it but both Synapse and Riot act as if origin_server_ts was whitelisted, and it was also confirmed in #matrix-dev to be reasonable behaviour.
|
|
Closes #118
|
|
This only applies to new messages; historical redaction events are just skipped because historical events are already redacted on the server side. Closes #117.
|
|
Rewire Connection::postReceipt() to the generated job too; this call is still deprecated though.
|
|
|
|
|
|
This impacts the cache as well, as we don't save state_keys for most
state events.
|
|
* StateEvent<> is a new class template for all state events. It provides a uniform interface to the state content, as well as a means to serialize the content back to JSON. In addition, StateEvent now parses the "prev_content" JSON object, so one can refer to the previous state now (a notable step to proper reflection of state changes in the displayed timeline in clients).
* EventContent::SimpleContent, together with StateEvent<>, forms a generalisation for simple state events, such as room name, topic, aliases etc. that boil down to a single key-value pair. DECLARE_SIMPLE_STATE_EVENT is a macro defined to streamline creation of events based on SimpleContent, providing API back-compatibility for events defined so far. As a result, a very concise simplestateevents.h replaces all those room*event.* files.
* Event/RoomEvent::fromJson() code is squeezed down to plain type lists passed to makeIfMatches() "chained factory" function template. TypeId is mandatory for an event type to be included into that factory.
* Event::toTimestamp() and Event::toStringList are completely superseded by respective fromJson<>() converters.
|
|
|
|
|
|
The events are detected in /sync output, and avatars for rooms are loaded from respective URLs. Clients can use Room::avatar() method to request a pixmap of a certain size, and react to avatarChanged() in order to update the UI when new pixmaps/avatars arrive. avatarChanged() signal is overloaded with two tasks - the first firing merely indicates that a new avatar is available (without actual pixmap yet available) while the second firing means that an actual pixmap has arrived (all this is entirely transparent for clients, they just should update their pixmaps from Room::avatar() every time when Room::avatarChanged() is emitted).
|
|
Display name is a calculated thing, name is received from the server.
|
|
|
|
Notably:
* API for SendEventJob and SetRoomStateJob has been altered to accept references, not pointers.
* Methods on Room that invoke requests to the server, have lost const, because they may be reflecting the changed state on the fly, within themselves
|
|
Closes #38. Also rearranged #includes
|
|
The CS API, turns out, has a quite official extension point inside m.read event content - clients are allowed to put whatever extra data they feel reasonable.
|
|
A cref is still faster than incrementing a refcounter in QString, and all the other COW stuff, and room id is not supposed to change ever.
|
|
|
|
|
|
Otherwise, users are doomed to stay avatarless upon restoration, until they update avatars again.
|
|
|
|
It's a case when the last-read-event id refers to an event that was outside the loaded timeline and has just arrived. Depending on what messages follow the discovered last-read one, we might need to promote the read marker and update unreadMessages flag. The latter is especially relevant in our current situation when empty timelines upon the application startup are a norm.
|
|
|
