2018-01-11 19:33:26 +00:00
|
|
|
/*
|
|
|
|
This file is part of Telegram Desktop,
|
|
|
|
the official desktop application for the Telegram messaging service.
|
|
|
|
|
|
|
|
For license and copyright information please follow this link:
|
|
|
|
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
|
|
|
|
*/
|
|
|
|
#include "history/view/history_view_element.h"
|
|
|
|
|
2018-01-23 11:47:38 +00:00
|
|
|
#include "history/view/history_view_service_message.h"
|
2018-01-11 19:33:26 +00:00
|
|
|
#include "history/history_item_components.h"
|
2018-01-14 16:02:25 +00:00
|
|
|
#include "history/history_item.h"
|
2018-01-11 19:33:26 +00:00
|
|
|
#include "history/history_media.h"
|
2018-01-14 16:02:25 +00:00
|
|
|
#include "history/history_media_grouped.h"
|
2018-01-13 12:45:11 +00:00
|
|
|
#include "history/history.h"
|
2018-01-11 19:33:26 +00:00
|
|
|
#include "data/data_session.h"
|
2018-01-17 16:21:01 +00:00
|
|
|
#include "data/data_groups.h"
|
2018-01-14 16:02:25 +00:00
|
|
|
#include "data/data_media_types.h"
|
2018-01-21 19:21:08 +00:00
|
|
|
#include "lang/lang_keys.h"
|
2018-01-11 19:33:26 +00:00
|
|
|
#include "auth_session.h"
|
2018-01-14 16:02:25 +00:00
|
|
|
#include "layout.h"
|
2018-01-21 19:21:08 +00:00
|
|
|
#include "styles/style_history.h"
|
2018-01-11 19:33:26 +00:00
|
|
|
|
|
|
|
namespace HistoryView {
|
2018-01-13 12:45:11 +00:00
|
|
|
namespace {
|
2018-01-11 19:33:26 +00:00
|
|
|
|
2018-01-13 12:45:11 +00:00
|
|
|
// A new message from the same sender is attached to previous within 15 minutes.
|
|
|
|
constexpr int kAttachMessageToPreviousSecondsDelta = 900;
|
|
|
|
|
|
|
|
} // namespace
|
2018-01-14 16:02:25 +00:00
|
|
|
|
|
|
|
TextSelection UnshiftItemSelection(
|
|
|
|
TextSelection selection,
|
|
|
|
uint16 byLength) {
|
|
|
|
return (selection == FullSelection)
|
|
|
|
? selection
|
|
|
|
: ::unshiftSelection(selection, byLength);
|
|
|
|
}
|
|
|
|
|
|
|
|
TextSelection ShiftItemSelection(
|
|
|
|
TextSelection selection,
|
|
|
|
uint16 byLength) {
|
|
|
|
return (selection == FullSelection)
|
|
|
|
? selection
|
|
|
|
: ::shiftSelection(selection, byLength);
|
|
|
|
}
|
|
|
|
|
|
|
|
TextSelection UnshiftItemSelection(
|
|
|
|
TextSelection selection,
|
|
|
|
const Text &byText) {
|
|
|
|
return UnshiftItemSelection(selection, byText.length());
|
|
|
|
}
|
|
|
|
|
|
|
|
TextSelection ShiftItemSelection(
|
|
|
|
TextSelection selection,
|
|
|
|
const Text &byText) {
|
|
|
|
return ShiftItemSelection(selection, byText.length());
|
|
|
|
}
|
|
|
|
|
2018-02-02 12:51:18 +00:00
|
|
|
void UnreadBar::init(int newCount) {
|
2018-01-21 19:21:08 +00:00
|
|
|
if (freezed) {
|
|
|
|
return;
|
|
|
|
}
|
2018-02-02 12:51:18 +00:00
|
|
|
count = newCount;
|
|
|
|
text = (count == kCountUnknown)
|
|
|
|
? lang(lng_unread_bar_some)
|
|
|
|
: lng_unread_bar(lt_count, count);
|
2018-01-21 19:21:08 +00:00
|
|
|
width = st::semiboldFont->width(text);
|
|
|
|
}
|
|
|
|
|
|
|
|
int UnreadBar::height() {
|
|
|
|
return st::historyUnreadBarHeight + st::historyUnreadBarMargin;
|
|
|
|
}
|
|
|
|
|
|
|
|
int UnreadBar::marginTop() {
|
|
|
|
return st::lineWidth + st::historyUnreadBarMargin;
|
|
|
|
}
|
|
|
|
|
|
|
|
void UnreadBar::paint(Painter &p, int y, int w) const {
|
|
|
|
const auto bottom = y + height();
|
|
|
|
y += marginTop();
|
|
|
|
p.fillRect(
|
|
|
|
0,
|
|
|
|
y,
|
|
|
|
w,
|
|
|
|
height() - marginTop() - st::lineWidth,
|
|
|
|
st::historyUnreadBarBg);
|
|
|
|
p.fillRect(
|
|
|
|
0,
|
|
|
|
bottom - st::lineWidth,
|
|
|
|
w,
|
|
|
|
st::lineWidth,
|
|
|
|
st::historyUnreadBarBorder);
|
|
|
|
p.setFont(st::historyUnreadBarFont);
|
|
|
|
p.setPen(st::historyUnreadBarFg);
|
|
|
|
|
|
|
|
int left = st::msgServiceMargin.left();
|
|
|
|
int maxwidth = w;
|
|
|
|
if (Adaptive::ChatWide()) {
|
|
|
|
maxwidth = qMin(
|
|
|
|
maxwidth,
|
|
|
|
st::msgMaxWidth
|
|
|
|
+ 2 * st::msgPhotoSkip
|
|
|
|
+ 2 * st::msgMargin.left());
|
|
|
|
}
|
|
|
|
w = maxwidth;
|
|
|
|
|
|
|
|
const auto skip = st::historyUnreadBarHeight
|
|
|
|
- 2 * st::lineWidth
|
|
|
|
- st::historyUnreadBarFont->height;
|
|
|
|
p.drawText(
|
|
|
|
(w - width) / 2,
|
|
|
|
y + (skip / 2) + st::historyUnreadBarFont->ascent,
|
|
|
|
text);
|
|
|
|
}
|
|
|
|
|
2018-01-23 11:47:38 +00:00
|
|
|
|
|
|
|
void DateBadge::init(const QDateTime &date) {
|
|
|
|
text = langDayOfMonthFull(date.date());
|
|
|
|
width = st::msgServiceFont->width(text);
|
|
|
|
}
|
|
|
|
|
|
|
|
int DateBadge::height() const {
|
|
|
|
return st::msgServiceMargin.top()
|
|
|
|
+ st::msgServicePadding.top()
|
|
|
|
+ st::msgServiceFont->height
|
|
|
|
+ st::msgServicePadding.bottom()
|
|
|
|
+ st::msgServiceMargin.bottom();
|
|
|
|
}
|
|
|
|
|
|
|
|
void DateBadge::paint(Painter &p, int y, int w) const {
|
|
|
|
ServiceMessagePainter::paintDate(p, text, width, y, w);
|
|
|
|
}
|
|
|
|
|
2018-01-19 17:10:58 +00:00
|
|
|
Element::Element(
|
|
|
|
not_null<ElementDelegate*> delegate,
|
|
|
|
not_null<HistoryItem*> data)
|
|
|
|
: _delegate(delegate)
|
|
|
|
, _data(data)
|
2018-02-03 19:52:35 +00:00
|
|
|
, _dateTime(ItemDateTime(data))
|
2018-01-19 17:10:58 +00:00
|
|
|
, _context(delegate->elementContext()) {
|
2018-01-14 16:02:25 +00:00
|
|
|
Auth().data().registerItemView(this);
|
2018-01-17 16:21:01 +00:00
|
|
|
refreshMedia();
|
2018-01-30 10:51:35 +00:00
|
|
|
if (_context == Context::History) {
|
|
|
|
_data->_history->setHasPendingResizedItems();
|
|
|
|
}
|
2018-01-11 19:33:26 +00:00
|
|
|
}
|
|
|
|
|
2018-01-19 17:10:58 +00:00
|
|
|
not_null<ElementDelegate*> Element::delegate() const {
|
|
|
|
return _delegate;
|
|
|
|
}
|
|
|
|
|
2018-01-11 19:33:26 +00:00
|
|
|
not_null<HistoryItem*> Element::data() const {
|
|
|
|
return _data;
|
|
|
|
}
|
|
|
|
|
2018-02-03 19:52:35 +00:00
|
|
|
QDateTime Element::dateTime() const {
|
|
|
|
return _dateTime;
|
|
|
|
}
|
|
|
|
|
2018-01-14 16:02:25 +00:00
|
|
|
HistoryMedia *Element::media() const {
|
|
|
|
return _media.get();
|
|
|
|
}
|
|
|
|
|
2018-01-13 12:45:11 +00:00
|
|
|
Context Element::context() const {
|
|
|
|
return _context;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Element::y() const {
|
|
|
|
return _y;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Element::setY(int y) {
|
|
|
|
_y = y;
|
|
|
|
}
|
|
|
|
|
2018-02-16 17:59:35 +00:00
|
|
|
void Element::paintHighlight(
|
|
|
|
Painter &p,
|
|
|
|
int geometryHeight) const {
|
|
|
|
const auto animms = delegate()->elementHighlightTime(this);
|
|
|
|
if (!animms
|
|
|
|
|| animms >= st::activeFadeInDuration + st::activeFadeOutDuration) {
|
|
|
|
return;
|
2018-01-13 12:45:11 +00:00
|
|
|
}
|
|
|
|
|
2018-02-16 17:59:35 +00:00
|
|
|
const auto top = marginTop();
|
|
|
|
const auto bottom = marginBottom();
|
|
|
|
const auto fill = qMin(top, bottom);
|
|
|
|
const auto skiptop = top - fill;
|
|
|
|
const auto fillheight = fill + geometryHeight + fill;
|
|
|
|
|
|
|
|
const auto dt = (animms > st::activeFadeInDuration)
|
|
|
|
? (1. - (animms - st::activeFadeInDuration)
|
|
|
|
/ float64(st::activeFadeOutDuration))
|
|
|
|
: (animms / float64(st::activeFadeInDuration));
|
|
|
|
const auto o = p.opacity();
|
|
|
|
p.setOpacity(o * dt);
|
|
|
|
p.fillRect(
|
|
|
|
0,
|
|
|
|
skiptop,
|
|
|
|
width(),
|
|
|
|
fillheight,
|
|
|
|
st::defaultTextPalette.selectOverlay);
|
|
|
|
p.setOpacity(o);
|
2018-01-14 16:02:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool Element::isUnderCursor() const {
|
2018-01-26 15:40:11 +00:00
|
|
|
return _delegate->elementUnderCursor(this);
|
2018-01-13 12:45:11 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Element::setPendingResize() {
|
|
|
|
_flags |= Flag::NeedsResize;
|
|
|
|
if (_context == Context::History) {
|
|
|
|
data()->_history->setHasPendingResizedItems();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Element::pendingResize() const {
|
|
|
|
return _flags & Flag::NeedsResize;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Element::isAttachedToPrevious() const {
|
|
|
|
return _flags & Flag::AttachedToPrevious;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Element::isAttachedToNext() const {
|
|
|
|
return _flags & Flag::AttachedToNext;
|
|
|
|
}
|
|
|
|
|
2018-01-14 16:02:25 +00:00
|
|
|
int Element::skipBlockWidth() const {
|
|
|
|
return st::msgDateSpace + infoWidth() - st::msgDateDelta.x();
|
|
|
|
}
|
|
|
|
|
|
|
|
int Element::skipBlockHeight() const {
|
|
|
|
return st::msgDateFont->height - st::msgDateDelta.y();
|
|
|
|
}
|
|
|
|
|
|
|
|
QString Element::skipBlock() const {
|
|
|
|
return textcmdSkipBlock(skipBlockWidth(), skipBlockHeight());
|
|
|
|
}
|
|
|
|
|
|
|
|
int Element::infoWidth() const {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Element::isHiddenByGroup() const {
|
|
|
|
return _flags & Flag::HiddenByGroup;
|
|
|
|
}
|
2018-01-17 16:21:01 +00:00
|
|
|
|
2018-01-30 13:17:50 +00:00
|
|
|
bool Element::isHidden() const {
|
|
|
|
return isHiddenByGroup();
|
|
|
|
}
|
|
|
|
|
2018-01-17 16:21:01 +00:00
|
|
|
void Element::refreshMedia() {
|
|
|
|
_flags &= ~Flag::HiddenByGroup;
|
2018-01-14 16:02:25 +00:00
|
|
|
|
2018-01-17 16:21:01 +00:00
|
|
|
const auto item = data();
|
|
|
|
const auto media = item->media();
|
|
|
|
if (media && media->canBeGrouped()) {
|
|
|
|
if (const auto group = Auth().data().groups().find(item)) {
|
|
|
|
if (group->items.back() != item) {
|
|
|
|
_media = nullptr;
|
|
|
|
_flags |= Flag::HiddenByGroup;
|
|
|
|
} else {
|
|
|
|
_media = std::make_unique<HistoryGroupedMedia>(
|
|
|
|
this,
|
|
|
|
group->items);
|
2018-01-21 09:05:30 +00:00
|
|
|
if (!pendingResize()) {
|
|
|
|
Auth().data().requestViewResize(this);
|
|
|
|
}
|
2018-01-17 16:21:01 +00:00
|
|
|
}
|
|
|
|
return;
|
2018-01-14 16:02:25 +00:00
|
|
|
}
|
|
|
|
}
|
2018-01-17 16:21:01 +00:00
|
|
|
if (_data->media()) {
|
|
|
|
_media = _data->media()->createView(this);
|
|
|
|
} else {
|
|
|
|
_media = nullptr;
|
2018-01-14 16:02:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-13 12:45:11 +00:00
|
|
|
void Element::previousInBlocksChanged() {
|
|
|
|
recountDisplayDateInBlocks();
|
|
|
|
recountAttachToPreviousInBlocks();
|
|
|
|
}
|
|
|
|
|
2018-01-19 17:10:58 +00:00
|
|
|
void Element::nextInBlocksRemoved() {
|
2018-01-13 12:45:11 +00:00
|
|
|
setAttachToNext(false);
|
|
|
|
}
|
|
|
|
|
2018-01-14 16:02:25 +00:00
|
|
|
void Element::refreshDataId() {
|
|
|
|
if (const auto media = this->media()) {
|
2018-01-17 16:21:01 +00:00
|
|
|
media->refreshParentId(data());
|
2018-01-14 16:02:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-13 12:45:11 +00:00
|
|
|
bool Element::computeIsAttachToPrevious(not_null<Element*> previous) {
|
|
|
|
const auto item = data();
|
2018-01-23 11:47:38 +00:00
|
|
|
if (!Has<DateBadge>() && !Has<UnreadBar>()) {
|
2018-01-13 12:45:11 +00:00
|
|
|
const auto prev = previous->data();
|
2018-01-19 17:10:58 +00:00
|
|
|
const auto possible = !item->serviceMsg() && !prev->serviceMsg()
|
2018-01-13 12:45:11 +00:00
|
|
|
&& !item->isEmpty() && !prev->isEmpty()
|
2018-02-03 19:52:35 +00:00
|
|
|
&& (std::abs(prev->date() - item->date()) < kAttachMessageToPreviousSecondsDelta)
|
2018-01-19 17:10:58 +00:00
|
|
|
&& (_context == Context::Feed
|
|
|
|
|| (!item->isPost() && !prev->isPost()));
|
2018-01-13 12:45:11 +00:00
|
|
|
if (possible) {
|
|
|
|
if (item->history()->peer->isSelf()) {
|
|
|
|
return prev->senderOriginal() == item->senderOriginal()
|
|
|
|
&& (prev->Has<HistoryMessageForwarded>() == item->Has<HistoryMessageForwarded>());
|
|
|
|
} else {
|
|
|
|
return prev->from() == item->from();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-01-21 19:21:08 +00:00
|
|
|
void Element::destroyUnreadBar() {
|
|
|
|
if (!Has<UnreadBar>()) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
RemoveComponents(UnreadBar::Bit());
|
|
|
|
Auth().data().requestViewResize(this);
|
|
|
|
if (data()->mainView() == this) {
|
|
|
|
recountAttachToPreviousInBlocks();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Element::setUnreadBarCount(int count) {
|
|
|
|
const auto changed = AddComponents(UnreadBar::Bit());
|
|
|
|
const auto bar = Get<UnreadBar>();
|
|
|
|
if (bar->freezed) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
bar->init(count);
|
|
|
|
if (changed) {
|
|
|
|
if (data()->mainView() == this) {
|
|
|
|
recountAttachToPreviousInBlocks();
|
|
|
|
}
|
|
|
|
Auth().data().requestViewResize(this);
|
|
|
|
} else {
|
|
|
|
Auth().data().requestViewRepaint(this);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Element::setUnreadBarFreezed() {
|
|
|
|
if (const auto bar = Get<UnreadBar>()) {
|
|
|
|
bar->freezed = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-01-23 11:47:38 +00:00
|
|
|
int Element::displayedDateHeight() const {
|
|
|
|
if (auto date = Get<DateBadge>()) {
|
|
|
|
return date->height();
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Element::displayDate() const {
|
|
|
|
return Has<DateBadge>();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Element::isInOneDayWithPrevious() const {
|
|
|
|
return !data()->isEmpty() && !displayDate();
|
|
|
|
}
|
|
|
|
|
2018-01-13 12:45:11 +00:00
|
|
|
void Element::recountAttachToPreviousInBlocks() {
|
|
|
|
auto attachToPrevious = false;
|
|
|
|
if (const auto previous = previousInBlocks()) {
|
|
|
|
attachToPrevious = computeIsAttachToPrevious(previous);
|
|
|
|
previous->setAttachToNext(attachToPrevious);
|
|
|
|
}
|
|
|
|
setAttachToPrevious(attachToPrevious);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Element::recountDisplayDateInBlocks() {
|
|
|
|
setDisplayDate([&] {
|
|
|
|
const auto item = data();
|
|
|
|
if (item->isEmpty()) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-02-03 19:52:35 +00:00
|
|
|
if (const auto previous = previousInBlocks()) {
|
2018-01-13 12:45:11 +00:00
|
|
|
const auto prev = previous->data();
|
2018-02-03 19:52:35 +00:00
|
|
|
return prev->isEmpty()
|
|
|
|
|| (previous->dateTime().date() != dateTime().date());
|
2018-01-13 12:45:11 +00:00
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}());
|
|
|
|
}
|
|
|
|
|
|
|
|
QSize Element::countOptimalSize() {
|
|
|
|
return performCountOptimalSize();
|
|
|
|
}
|
|
|
|
|
|
|
|
QSize Element::countCurrentSize(int newWidth) {
|
|
|
|
if (_flags & Flag::NeedsResize) {
|
|
|
|
_flags &= ~Flag::NeedsResize;
|
|
|
|
initDimensions();
|
|
|
|
}
|
|
|
|
return performCountCurrentSize(newWidth);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Element::setDisplayDate(bool displayDate) {
|
|
|
|
const auto item = data();
|
2018-01-23 11:47:38 +00:00
|
|
|
if (displayDate && !Has<DateBadge>()) {
|
|
|
|
AddComponents(DateBadge::Bit());
|
2018-02-03 19:52:35 +00:00
|
|
|
Get<DateBadge>()->init(dateTime());
|
2018-01-13 12:45:11 +00:00
|
|
|
setPendingResize();
|
2018-01-23 11:47:38 +00:00
|
|
|
} else if (!displayDate && Has<DateBadge>()) {
|
|
|
|
RemoveComponents(DateBadge::Bit());
|
2018-01-13 12:45:11 +00:00
|
|
|
setPendingResize();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Element::setAttachToNext(bool attachToNext) {
|
|
|
|
if (attachToNext && !(_flags & Flag::AttachedToNext)) {
|
|
|
|
_flags |= Flag::AttachedToNext;
|
2018-01-19 17:10:58 +00:00
|
|
|
setPendingResize();
|
2018-01-13 12:45:11 +00:00
|
|
|
} else if (!attachToNext && (_flags & Flag::AttachedToNext)) {
|
|
|
|
_flags &= ~Flag::AttachedToNext;
|
2018-01-19 17:10:58 +00:00
|
|
|
setPendingResize();
|
2018-01-13 12:45:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Element::setAttachToPrevious(bool attachToPrevious) {
|
|
|
|
if (attachToPrevious && !(_flags & Flag::AttachedToPrevious)) {
|
|
|
|
_flags |= Flag::AttachedToPrevious;
|
2018-01-19 17:10:58 +00:00
|
|
|
setPendingResize();
|
2018-01-13 12:45:11 +00:00
|
|
|
} else if (!attachToPrevious && (_flags & Flag::AttachedToPrevious)) {
|
|
|
|
_flags &= ~Flag::AttachedToPrevious;
|
2018-01-19 17:10:58 +00:00
|
|
|
setPendingResize();
|
2018-01-13 12:45:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Element::displayFromPhoto() const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Element::hasFromPhoto() const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Element::hasFromName() const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Element::displayFromName() const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-01-14 16:02:25 +00:00
|
|
|
bool Element::displayForwardedFrom() const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Element::hasOutLayout() const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Element::drawBubble() const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Element::hasBubble() const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Element::hasFastReply() const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Element::displayFastReply() const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Element::displayRightAction() const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
void Element::drawRightAction(
|
|
|
|
Painter &p,
|
|
|
|
int left,
|
|
|
|
int top,
|
|
|
|
int outerWidth) const {
|
|
|
|
}
|
|
|
|
|
|
|
|
ClickHandlerPtr Element::rightActionLink() const {
|
|
|
|
return ClickHandlerPtr();
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Element::displayEditedBadge() const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-02-03 19:52:35 +00:00
|
|
|
TimeId Element::displayedEditDate() const {
|
|
|
|
return TimeId(0);
|
2018-01-14 16:02:25 +00:00
|
|
|
}
|
|
|
|
|
2018-01-18 13:59:22 +00:00
|
|
|
bool Element::hasVisibleText() const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2018-01-13 12:45:11 +00:00
|
|
|
HistoryBlock *Element::block() {
|
|
|
|
return _block;
|
|
|
|
}
|
|
|
|
|
|
|
|
const HistoryBlock *Element::block() const {
|
|
|
|
return _block;
|
|
|
|
}
|
|
|
|
|
2018-01-11 19:33:26 +00:00
|
|
|
void Element::attachToBlock(not_null<HistoryBlock*> block, int index) {
|
|
|
|
Expects(!_data->isLogEntry());
|
|
|
|
Expects(_block == nullptr);
|
|
|
|
Expects(_indexInBlock < 0);
|
|
|
|
Expects(index >= 0);
|
|
|
|
|
|
|
|
_block = block;
|
|
|
|
_indexInBlock = index;
|
|
|
|
_data->setMainView(this);
|
2018-01-19 12:13:06 +00:00
|
|
|
previousInBlocksChanged();
|
2018-01-11 19:33:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Element::removeFromBlock() {
|
|
|
|
Expects(_block != nullptr);
|
|
|
|
|
|
|
|
_block->remove(this);
|
|
|
|
}
|
|
|
|
|
2018-01-18 13:59:22 +00:00
|
|
|
void Element::refreshInBlock() {
|
|
|
|
Expects(_block != nullptr);
|
|
|
|
|
|
|
|
_block->refreshView(this);
|
|
|
|
}
|
|
|
|
|
2018-01-13 12:45:11 +00:00
|
|
|
void Element::setIndexInBlock(int index) {
|
|
|
|
Expects(_block != nullptr);
|
|
|
|
Expects(index >= 0);
|
|
|
|
|
|
|
|
_indexInBlock = index;
|
|
|
|
}
|
|
|
|
|
|
|
|
int Element::indexInBlock() const {
|
|
|
|
Expects((_indexInBlock >= 0) == (_block != nullptr));
|
|
|
|
Expects((_block == nullptr) || (_block->messages[_indexInBlock].get() == this));
|
|
|
|
|
|
|
|
return _indexInBlock;
|
|
|
|
}
|
|
|
|
|
2018-01-11 19:33:26 +00:00
|
|
|
Element *Element::previousInBlocks() const {
|
|
|
|
if (_block && _indexInBlock >= 0) {
|
|
|
|
if (_indexInBlock > 0) {
|
|
|
|
return _block->messages[_indexInBlock - 1].get();
|
|
|
|
}
|
|
|
|
if (auto previous = _block->previousBlock()) {
|
|
|
|
Assert(!previous->messages.empty());
|
|
|
|
return previous->messages.back().get();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
|
|
|
Element *Element::nextInBlocks() const {
|
|
|
|
if (_block && _indexInBlock >= 0) {
|
|
|
|
if (_indexInBlock + 1 < _block->messages.size()) {
|
|
|
|
return _block->messages[_indexInBlock + 1].get();
|
|
|
|
}
|
|
|
|
if (auto next = _block->nextBlock()) {
|
|
|
|
Assert(!next->messages.empty());
|
|
|
|
return next->messages.front().get();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2018-01-14 16:02:25 +00:00
|
|
|
void Element::drawInfo(
|
|
|
|
Painter &p,
|
|
|
|
int right,
|
|
|
|
int bottom,
|
|
|
|
int width,
|
|
|
|
bool selected,
|
|
|
|
InfoDisplayType type) const {
|
|
|
|
}
|
|
|
|
|
|
|
|
bool Element::pointInTime(
|
|
|
|
int right,
|
|
|
|
int bottom,
|
|
|
|
QPoint point,
|
|
|
|
InfoDisplayType type) const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
TextSelection Element::adjustSelection(
|
|
|
|
TextSelection selection,
|
|
|
|
TextSelectType type) const {
|
|
|
|
return selection;
|
|
|
|
}
|
|
|
|
|
2018-01-11 19:33:26 +00:00
|
|
|
void Element::clickHandlerActiveChanged(
|
|
|
|
const ClickHandlerPtr &handler,
|
|
|
|
bool active) {
|
|
|
|
if (const auto markup = _data->Get<HistoryMessageReplyMarkup>()) {
|
|
|
|
if (const auto keyboard = markup->inlineKeyboard.get()) {
|
|
|
|
keyboard->clickHandlerActiveChanged(handler, active);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
App::hoveredLinkItem(active ? this : nullptr);
|
2018-01-17 16:21:01 +00:00
|
|
|
Auth().data().requestViewRepaint(this);
|
2018-01-14 16:02:25 +00:00
|
|
|
if (const auto media = this->media()) {
|
2018-01-11 19:33:26 +00:00
|
|
|
media->clickHandlerActiveChanged(handler, active);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Element::clickHandlerPressedChanged(
|
|
|
|
const ClickHandlerPtr &handler,
|
|
|
|
bool pressed) {
|
|
|
|
if (const auto markup = _data->Get<HistoryMessageReplyMarkup>()) {
|
|
|
|
if (const auto keyboard = markup->inlineKeyboard.get()) {
|
|
|
|
keyboard->clickHandlerPressedChanged(handler, pressed);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
App::pressedLinkItem(pressed ? this : nullptr);
|
2018-01-17 16:21:01 +00:00
|
|
|
Auth().data().requestViewRepaint(this);
|
2018-01-14 16:02:25 +00:00
|
|
|
if (const auto media = this->media()) {
|
2018-01-11 19:33:26 +00:00
|
|
|
media->clickHandlerPressedChanged(handler, pressed);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Element::~Element() {
|
2018-01-31 17:10:29 +00:00
|
|
|
if (_data->mainView() == this) {
|
|
|
|
_data->clearMainView();
|
|
|
|
}
|
2018-03-10 12:47:19 +00:00
|
|
|
if (_context == Context::History) {
|
|
|
|
Auth().data().notifyViewRemoved(this);
|
|
|
|
}
|
2018-01-14 16:02:25 +00:00
|
|
|
Auth().data().unregisterItemView(this);
|
2018-01-11 19:33:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace HistoryView
|